# LavalinkManager **Type:** [class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/class) *extends* [node:EventEmitter](https://nodejs.org/dist/latest/docs/api/events.html#events_class_eventemitter) ## Constructor ```javascript new LavalinkManager(options:ManagerOptions) ``` ## Import {% tabs %} {% tab title="Typescript / ESM" %}

import { LavalinkManager } from "lavalink-client";

{% endtab %} {% tab title="JavaScript (cjs)" %} {% code title="index.js" lineNumbers="true" %} ```javascript const { LavalinkManager } = require("lavalink-client"); ``` {% endcode %} {% endtab %} {% endtabs %} ## Overview | Properties | Methods | Event-Listeners | | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | | [initiated](#.initated) | [createPlayer()](#.createplayer-options-playeroptions) | [trackStart](#trackstart) | | [useable](#.useable) | [getPlayer()](#.getplayer-guildid-string) | [trackEnd](#trackend) | | [options](#.options) | [deletePlayer()](#.deleteplayer-guildid-string) | [trackStuck](#trackstuck) | | [players](#.players) | [init()](#.init-clientdata-botclientoptions-important) IMPORTANT | [queueEnd](#queueend) | | [nodeManager](#.nodemanager) | [sendRawData()](#.sendrawdata-data-voicepacket-or-voiceserver-or-voicestate-or-any-important) IMPORTANT | [playerCreate](#playercreate) | | [utils](#.utils) | | [playerMove](#playermove) | | | | [playerDisconnect](#playerdisconnect) | | | | [playerSocketClose](#playersocketclose) | | | | [playerDestroy](#playerdestroy) | | | | [playerUpdate](#playerupdate) | ### **Check out** [**Example Creations** ](#example-creations)**down below** *** ## Properties ### .initated > *If the Manager was initated* **Type**: [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean) ### .useable > *If the Manager is useable (If at least 1 Node is connected)* **Type**: [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean) ### .options > *The options from the Manager* **Type**: [ManagerOptions](/lavalink-client/docs/lavalinkmanager/manager-options.md) ### .players > *All the Players of the Manager* **Type***:* [*MiniMap*](/lavalink-client/docs/other-utils-and-classes/minimap.md)*\* ### .nodeManager > *The Node Manager of the Manager* **Type***:* [*NodeManager*](/lavalink-client/docs/nodemanager.md) ### .utils > *The Manager's Utils* **Type***:* [*ManagerUtils*](/lavalink-client/docs/lavalinkmanager/managerutils.md) *** ## Methods ### .init(clientData: [BotClientOptions](/lavalink-client/requirements.md)) IMPORTANT! > *Initializes the Manager and connects all Nodes* **Returns**: [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<[LavalinkManager](/lavalink-client/docs/lavalinkmanager.md)>

botClient.on("ready", async () => { // only init it when the Bot is ready...
  await botClient.lavalink.init({ 
    id: botClient.user.id, 
    username: botclient.user.username
  });
});

### .createPlayer(options: [PlayerOptions](/lavalink-client/docs/player/playeroptions.md)) > *Create or get a Player* **Returns**: [Player](/lavalink-client/docs/player.md) ```typescript const newPlayer = await client.lavalink.createPlayer({ guildId: interaction.guildId, voiceChannelId: interaction.member.voice?.channelId, textChannelId: interaction.channelId, // (optional) selfDeaf: true, // (optional) selfMute: false, // (optional) volume: client.defaultVolume, // (optional) default volume instaUpdateFiltersFix: true, // (optional) applyVolumeAsFilter: false, // (optional) // node: "YOUR_NODE_ID", // (optional) // vcRegion: interaction.member.voice?.channel?.rtcRegion // (optional) }); ``` ### .getPlayer(guildId:[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)) > *Create a Player* **Returns**: [Player](/lavalink-client/docs/player.md) | [undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)

const player = client.lavalink.getPlayer(interaction.guildId);

{% hint style="info" %} Important Conditions to check: * player is not undefined * player is connected to a VoiceChannel * user in a VoiceChannel && player in same VoiceChannel as user * player.node is Connected * player is playing / there is a current song in player.queue {% endhint %} ### .deletePlayer(guildId:[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)) > *Removes a Player from the saved* [*MiniMap*](/lavalink-client/docs/other-utils-and-classes/minimap.md)*, needs to be destroyed first* **Returns**: [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)

client.lavalink.deletePlayer(oldPlayer?.guildId || interaction.guildId);

### .sendRawData(data : VoicePacket | VoiceServer | VoiceState | any) IMPORTANT! > *Sends Raw Discord's Clients Event Data to the Manager* **Returns**: [void](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void)

botClient.on("raw", (data) => client.lavalink.sendRawData(data));

*** ## Event-Listeners > *All Events you can listen to on the LavalinkManager Class* ### trackStart > *Emitted whenever a Track plays*

Parameter	Type	Description
player	Player	The Player for this Event
track	Track	The current playing track (player.queue.current)
payload	TrackStartEvent	The Payload Lavalink sent

```typescript client.lavalink.on("trackStart", (player, track, payload) => { }); ``` ### trackEnd > *Emitted whenever a Track finished playing.*

Parameter	Type	Description
player	Player	The Player for this Event
track	Track	The Track that finished Playing
payload	TrackEndEvent	The Payload Lavalink sent

```typescript client.lavalink.on("trackEnd", (player, track, payload) => { }); ``` ### trackStuck > *Emitted whenever a Track got stuck while playing*

Parameter	Type	Description
player	Player	The Player for this Event
track	Track	The Track that got stuck
payload	TrackStuckEvent	The Payload Lavalink sent

```typescript client.lavalink.on("trackStuck", (player, track, payload) => { }); ``` ### trackError > Emitted whenever a Track errored

Parameter	Type	Description
player	Player	The Player for this Event
track	Track \| UnresolvedTrack	The Track that Errored
payload	TrackExceptionEvent	The Payload Lavalink sent

```typescript client.lavalink.on("trackError", (player, track, payload) => { }); ``` ### queueEnd > Emitted when the track Ended, but there are no more tracks in the queue > > (trackEnd, does NOT get exexcuted)

Parameter	Type	Description
player	Player	The Player for this Event
track	Track	The last played track
payload	TrackEndEvent \| TrackStuckEvent \| TrackExceptionEvent	The Payload Lavalink sent

```typescript client.lavalink.on("queueEnd", (player, track, payload) => { }); ``` ### playerCreate > Emitted whenver a Player gets created

Parameter	Type	Description
player	Player	The created Player

```typescript client.lavalink.on("playerCreate", (player) => { }); ``` ### playerMove > Emitted whenever a Player gets moved between Voice Channels

Parameter	Type	Description
player	Player	The Player for this Event
oldVoiceChannelId	string	old Voice Channel Id
newVoiceChannelId	string	new Voice Channel Id

```typescript client.lavalink.on("playerMove", (player, oldVCId, newVCId) => { }); ``` ### playerDisconnect > Emitted whenever a player is disconnected from a channel

Parameter	Type	Description
player	Player	The Player for this Event
voiceChannelId	string	The disconnected voice Channel

```typescript client.lavalink.on("playerDisconnect", (player, voiceChannelId) => { }); ``` ### playerSocketClose > Emitted when a Node-Socket got closed for a specific Player

Parameter	Type	Description
player	Player	The Player for this Event
payload	WebSocketClosedEvent	The Payload Lavalink sent

```typescript client.lavalink.on("playerSocketClose", (player, track, payload) => { }); ``` ### playerDestroy > Emitted whenever a Player got destroyed

Parameter	Type	Description
player	Player	The Destroyed Player
destroyReason	?PlayerDestroyReasons	The Destroy Reason (if provided)

```typescript client.lavalink.on("playerDestroy", (player, destroyReason) => { }); ``` ### playerUpdate > Emitted whenever a Player gets an update from Lavalink's playerUpdate Event

Parameter	Type	Description
oldPlayerJson	PlayerJson	Player Data before it was udpated
newPlayer	Player	Afterwards the Player got updated

```typescript client.lavalink.on("playerUpdate", (oldPlayerJson, newPlayer) => { }); ``` ## Example-Creations

Example Creation

```typescript import { Client, GatewayIntentBits } from "discord.js"; import { createClient, RedisClientType } from 'redis'; import { LavalinkManager } from "../src"; ``` ```typescript // The Bot Client, here a discord.js one const client = new Client({ intents: [ GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates ] }) as Client & { redis: RedisClientType, lavalink: LavalinkManager }; ```

client.lavalink = new LavalinkManager({
    nodes: [
        {
            authorization: "yourverystrongpassword",
            host: "localhost",
            port: 2333,
            id: "testnode",
            requestTimeout: 10000,
        }
    ],
    sendToShard: (guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
    autoSkip: true,
    client: {
        id: envConfig.clientId, // REQUIRED! (at least after the .init)
        username: "TESTBOT"
    },
    playerOptions: {
        applyVolumeAsFilter: false,
        clientBasedPositionUpdateInterval: 50,
        defaultSearchPlatform: "ytmsearch",
        volumeDecrementer: 0.75, // on client 100% == on lavalink 75%
        onDisconnect: {
            autoReconnect: true, // automatically attempts a reconnect, if the bot disconnects from the voice channel, if it fails, it gets destroyed
            destroyPlayer: false // overrides autoReconnect and directly destroys the player if the bot disconnects from the vc
        },
        onEmptyQueue: {
            destroyAfterMs: 30_000, // 0 === instantly destroy | don't provide the option, to don't destroy the player
        },
        useUnresolvedData: true
    },
    queueOptions: {
        maxPreviousTracks: 10
    },
});

Finally, initatlize the Manager and send Raw Data! ```typescript client.on("ready", async () => { await client.lavalink.init({ id: client.user.id, username: client.user.username }); }); client.on("raw", data => client.lavalink.sendRawData(data)); ```

### Advanced Example Creation

Example with Redis-Queue, Request-Transformer, Autoplay Function, ...

```typescript import { Client, GatewayIntentBits } from "discord.js"; import { createClient, RedisClientType } from 'redis'; import { LavalinkManager, QueueStoreManager , QueueChangesWatcher } from "lavalink-client"; ``` ```typescript // The Bot Client, here a discord.js one const client = new Client({ intents: [ GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates ] }) as Client & { redis: RedisClientType, lavalink: LavalinkManager }; ``` ```typescript // The Custom Redis Server client.redis = createClient({ url: "redis://localhost:6379", password: "your_very_strong_password" }); client.redis.connect(); client.redis.on("error", (err) => console.log('Redis Client Error', err)); ``` ```typescript // Create the Lavalink Server client.lavalink = new LavalinkManager({ nodes: [ { authorization: "yourverystrongpassword", host: "localhost", port: 2333, id: "testnode", requestTimeout: 10000, } ], sendToShard: (guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload), autoSkip: true, client: { id: envConfig.clientId, // REQUIRED! (at least after the .init) username: "TESTBOT" }, playerOptions: { applyVolumeAsFilter: false, clientBasedPositionUpdateInterval: 50, defaultSearchPlatform: "ytmsearch", volumeDecrementer: 0.75, // on client 100% == on lavalink 75% requesterTransformer: requesterTransformer, onDisconnect: { autoReconnect: true, // automatically attempts a reconnect, if the bot disconnects from the voice channel, if it fails, it gets destroyed destroyPlayer: false // overrides autoReconnect and directly destroys the player if the bot disconnects from the vc }, onEmptyQueue: { destroyAfterMs: 30_000, // 0 === instantly destroy | don't provide the option, to don't destroy the player autoPlayFunction: autoPlayFunction, }, useUnresolvedData: true }, queueOptions: { maxPreviousTracks: 10, queueStore: new myCustomStore(client.redis), queueChangesWatcher: new myCustomWatcher(client) }, }); ``` Custom Queue Store Class (Saving the queue on a redis server) ```typescript export class myCustomStore implements QueueStoreManager { private redis:RedisClientType; constructor(redisClient:RedisClientType) { this.redis = redisClient; } async get(guildId): Promise { return await this.redis.get(this.id(guildId)); } async set(guildId, stringifiedQueueData): Promise { // await this.delete(guildId); // redis requires you to delete it first; return await this.redis.set(this.id(guildId), stringifiedQueueData); } async delete(guildId): Promise { return await this.redis.del(this.id(guildId)); } async parse(stringifiedQueueData): Promise> { return JSON.parse(stringifiedQueueData); } async stringify(parsedQueueData): Promise { return JSON.stringify(parsedQueueData); } // you can add more utils if you need to... private id(guildId) { return `lavalinkqueue_${guildId}`; // transform the id } } ``` Custom Queue Changes Watcher Class, for seeing changes within the Queue ```typescript export class myCustomWatcher implements QueueChangesWatcher { private client:BotClient; constructor(client:BotClient) { this.client = client; } shuffled(guildId, oldStoredQueue, newStoredQueue) { console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: Queue got shuffled`) } tracksAdd(guildId, tracks, position, oldStoredQueue, newStoredQueue) { console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: ${tracks.length} Tracks got added into the Queue at position #${position}`); } tracksRemoved(guildId, tracks, position, oldStoredQueue, newStoredQueue) { console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: ${tracks.length} Tracks got removed from the Queue at position #${position}`); } } ``` Custom Autoplay function, which gets executed, before the "queueEnd" Event fires, and if there is a new track added in the queue, then it plays it. else "queueEnd" will fire ```typescript export const autoPlayFunction = async (player, lastPlayedTrack) => { if(lastPlayedTrack.info.sourceName === "spotify") { const filtered = player.queue.previous.filter(v => v.info.sourceName === "spotify").slice(0, 5); const ids = filtered.map(v => v.info.identifier || v.info.uri.split("/")?.reverse()?.[0] || v.info.uri.split("/")?.reverse()?.[1]); if(ids.length >= 2) { const res = await player.search({ query: `seed_tracks=${ids.join(",")}`, //`seed_artists=${artistIds.join(",")}&seed_genres=${genre.join(",")}&seed_tracks=${trackIds.join(",")}`; source: "sprec" }, lastPlayedTrack.requester).then(response => { response.tracks = response.tracks.filter(v => v.info.identifier !== lastPlayedTrack.info.identifier); // remove the lastPlayed track if it's in there.. return response; }).catch(console.warn); if(res && res.tracks.length) await player.queue.add(res.tracks.slice(0, 5).map(track => { // transform the track plugininfo so you can figure out if the track is from autoplay or not. track.pluginInfo.clientData = { ...(track.pluginInfo.clientData||{}), fromAutoplay: true }; return track; })); else console.log("Spotify - NOTHING GOT ADDED"); } return; } if(lastPlayedTrack.info.sourceName === "youtube" || lastPlayedTrack.info.sourceName === "youtubemusic") { const res = await player.search({ query:`https://www.youtube.com/watch?v=${lastPlayedTrack.info.identifier}&list=RD${lastPlayedTrack.info.identifier}`, source: "youtube" }, lastPlayedTrack.requester).then(response => { response.tracks = response.tracks.filter(v => v.info.identifier !== lastPlayedTrack.info.identifier); // remove the lastPlayed track if it's in there.. return response; }).catch(console.warn); if(res && res.tracks.length) await player.queue.add(res.tracks.slice(0, 5).map(track => { // transform the track plugininfo so you can figure out if the track is from autoplay or not. track.pluginInfo.clientData = { ...(track.pluginInfo.clientData||{}), fromAutoplay: true }; return track; })); else console.log("YT - NOTHING GOT ADDED"); return; } return } ``` Custom requestTransformer Function, which allows you to provide just a User Object into the "requester" parameter(s) and then transform it to save memory!\ Attention: This function might get executed on already transformed requesters, if you re-use it. ```typescript export const requesterTransformer = (requester:any):CustomRequester => { // if it's already the transformed requester if(typeof requester === "object" && "avatar" in requester && Object.keys(requester).length === 3) return requester as CustomRequester; // if it's still a discord.js User if(typeof requester === "object" && "displayAvatarURL" in requester) { // it's a user return { id: requester.id, username: requester.username, avatar: requester.displayAvatarURL(), } } // if it's non of the above return { id: requester!.toString(), username: "unknown" }; // reteurn something that makes sense for you! } export interface CustomRequester { id: string, username: string, avatar?: string, } ``` Finally, initatlize the Manager and send Raw Data! ```typescript client.on("ready", async () => { await client.lavalink.init({ id: client.user.id, username: client.user.username }); }); client.on("raw", data => client.lavalink.sendRawData(data)); ```

--- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://lc4.gitbook.io/lavalink-client/docs/lavalinkmanager.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.