Star ✨ on GitHub

Events

API reference for events in Moonlink.js

Moonlink.js emits various events that you can listen to in order to react to changes in the state of players, nodes, and tracks. These events are essential for creating an interactive and responsive music bot.

Listening to Events

To listen to events, you can use the on() method of the Manager:

// Create the Manager
const manager = new Manager({
  // ... options
});

// Listen to an event
manager.on('trackStart', (player, track) => {
  console.log(`Now playing: ${track.title}`);
});

Debug Events

debug

debugevent

Debug

Emitted when debug information is available.

Parameters
argsrequiredany[]
Debug arguments
::

Usage Example

manager.on('debug', (...args) => {
  console.log('[DEBUG]', {
    timestamp: new Date().toISOString(),
    info: args
  });
});
[DEBUG] {
  timestamp: "2024-03-15T12:34:56.789Z",
  info: ["Connecting to node", "Node-1", { host: "localhost", port: 2333 }]
}

Use this event during development for detailed debugging information.
:: ::

autoLeaved

autoLeavedevent

Auto Leaved

Emitted when a player automatically leaves a voice channel.

Parameters
playerrequiredPlayer
The player that left
trackrequiredTrack
The track that was playing

Usage Example

manager.on('autoLeaved', (player, track) => {
  console.log(`[AUTO] Player left:`, {
    guild: player.guildId,
    track: {
      title: track.title,
      author: track.author
    },
    channel: player.voiceChannelId
  });

  const embed = new EmbedBuilder()
    .setColor('#ff6b6b')
    .setTitle('🚪 Auto Leave')
    .setDescription(`Left voice channel due to inactivity while playing **${track.title}**`);

  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) {
    channel.send({ embeds: [embed] });
  }
});
[AUTO] Player left: {
  guild: "123456789012345678",
  track: {
    title: "Never Gonna Give You Up",
    author: "Rick Astley"
  },
  channel: "123456789012345678"
}

Use this event to handle automatic disconnections and cleanup.

Node Events

nodeCreate

nodeCreateevent

Node Create

Emitted when a new node is created.

Parameters
noderequiredNode
The created node

Usage Example

manager.on('nodeCreate', (node) => {
  console.log(`[NODE] New node created:`, {
    identifier: node.identifier,
    host: node.host,
    port: node.port,
    secure: node.secure
  });

  const embed = new EmbedBuilder()
    .setColor('#4ade80')
    .setTitle('🆕 Node Created')
    .setDescription(`New node ${node.identifier} created at ${node.host}:${node.port}`);

  // Notify admin channel
  const adminChannel = client.channels.cache.get('ADMIN_CHANNEL_ID');
  if (adminChannel) {
    adminChannel.send({ embeds: [embed] });
  }
});
[NODE] New node created: {
  identifier: "Node-1",
  host: "localhost",
  port: 2333,
  secure: false
}

Monitor node creation for system setup and maintenance.

nodeReady

nodeReadyevent

Node Ready

Emitted when a node is ready.

Parameters
noderequiredNode
The ready node
statsrequiredINodeStats
The node statistics

Usage Example

manager.on('nodeReady', (node, stats) => {
  console.log(`Node ${node.identifier} is ready`, stats);
});
[NODE] Node-1 is ready {
  players: 5,
  cpu: 0.5,
  memory: {
    free: 1000000000,
    used: 500000000,
    allocated: 1500000000
  }
}

Monitor node readiness for system monitoring.

nodeConnected

nodeConnectedevent

Node Connected

Emitted when a node successfully connects.

Parameters
noderequiredNode
The connected node
::

Usage Example

manager.on('nodeConnected', (node) => {
  console.log(`Node ${node.identifier} connected`);
});
[NODE] Node-1 connected

Track node connections for system monitoring.

::

nodeError

nodeErrorevent

Node Error

Emitted when a node encounters an error.

Parameters
noderequiredNode
The node that encountered the error
errorrequiredError
The error that occurred

Usage Example

manager.on('nodeError', (node, error) => {
  console.log(`[NODE] Error occurred:`, {
    identifier: node.identifier,
    error: {
      name: error.name,
      message: error.message,
      stack: error.stack
    }
  });

  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('⚠️ Node Error')
    .setDescription(`Error on node ${node.identifier}\n\`\`\`\n${error.message}\n\`\`\``);

  // Notify admin channel
  const adminChannel = client.channels.cache.get('ADMIN_CHANNEL_ID');
  if (adminChannel) {
    adminChannel.send({ embeds: [embed] });
  }
});
[NODE] Error occurred: {
  identifier: "Node-1",
  error: {
    name: "Error",
    message: "Failed to connect to Lavalink server",
    stack: "Error: Failed to connect..."
  }
}

Handle node errors to maintain system stability.

nodeReconnect

nodeReconnectevent

Node Reconnect

Emitted when a node attempts to reconnect.

Parameters
noderequiredNode
The node attempting to reconnect

Usage Example

manager.on('nodeReconnect', (node) => {
  console.log(`[NODE] Reconnection attempt:`, {
    identifier: node.identifier,
    attempt: node.reconnectAttempts,
    timeout: node.reconnectTimeout
  });

  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('🔄 Node Reconnecting')
    .setDescription(`Node ${node.identifier} is attempting to reconnect\nAttempt: ${node.reconnectAttempts}`);

  // Notify admin channel
  const adminChannel = client.channels.cache.get('ADMIN_CHANNEL_ID');
  if (adminChannel) {
    adminChannel.send({ embeds: [embed] });
  }
});
[NODE] Reconnection attempt: {
  identifier: "Node-1",
  attempt: 1,
  timeout: 5000
}

Monitor reconnection attempts to ensure node stability.

nodeDisconnect

nodeDisconnectevent

Node Disconnect

Emitted when a node disconnects.

Parameters
noderequiredNode
The disconnected node
coderequirednumber
Disconnect code
reasonrequiredstring
Disconnect reason

Usage Example

manager.on('nodeDisconnect', (node, code, reason) => {
  console.log(`[NODE] Disconnected:`, {
    identifier: node.identifier,
    code: code,
    reason: reason,
    reconnecting: node.reconnecting
  });

  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('🔌 Node Disconnected')
    .setDescription(`Node ${node.identifier} disconnected\nCode: ${code}\nReason: ${reason}`);

  // Notify admin channel
  const adminChannel = client.channels.cache.get('ADMIN_CHANNEL_ID');
  if (adminChannel) {
    adminChannel.send({ embeds: [embed] });
  }
});
[NODE] Disconnected: {
  identifier: "Node-1",
  code: 1006,
  reason: "Connection closed abnormally",
  reconnecting: true
}

Handle node disconnections to maintain service reliability.

nodeDestroy

nodeDestroyevent

Node Destroy

Emitted when a node is destroyed.

Parameters
noderequiredNode
The destroyed node

Usage Example

manager.on('nodeDestroy', (node) => {
  console.log(`[NODE] Destroyed:`, {
    identifier: node.identifier,
    timestamp: new Date().toISOString()
  });

  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('💥 Node Destroyed')
    .setDescription(`Node ${node.identifier} has been destroyed`);

  // Notify admin channel
  const adminChannel = client.channels.cache.get('ADMIN_CHANNEL_ID');
  if (adminChannel) {
    adminChannel.send({ embeds: [embed] });
  }
});
  [NODE] Destroyed: {
    identifier: "Node-1",
    timestamp: "2024-03-15T12:34:56.789Z"
  }
#footer Use this event to handle cleanup after node destruction. ::

::

nodeAutoResumed

nodeAutoResumedevent

Node Auto Resumed

Emitted when a node automatically resumes its players.

Parameters
noderequiredNode
The node that resumed
playersrequiredPlayer[]
Array of resumed players

Usage Example

manager.on('nodeAutoResumed', (node, players) => {
  console.log(`[NODE] Auto-resumed:`, {
    identifier: node.identifier,
    playersCount: players.length,
    players: players.map(p => ({
      guild: p.guildId,
      track: p.queue.current?.title
    }))
  });

  const embed = new EmbedBuilder()
    .setColor('#4ade80')
    .setTitle('♻️ Players Resumed')
    .setDescription(`${players.length} players resumed on node ${node.identifier}`);

  // Notify players about resumption
  players.forEach(player => {
    const channel = client.channels.cache.get(player.textChannelId);
    if (channel) {
      channel.send('✅ Player resumed after node reconnection');
    }
  });
});
[NODE] Auto-resumed: {
  identifier: "Node-1",
  playersCount: 2,
  players: [
    {
      guild: "123456789012345678",
      track: "Never Gonna Give You Up"
    },
    {
      guild: "876543210987654321",
      track: "Despacito"
    }
  ]
}

Handle automatic player resumption after node reconnection.

Player Events

playerCreate

playerCreateevent

Player Create

Emitted when a new player is created.

Parameters
playerrequiredPlayer
The created player

Usage Example

manager.on('playerCreate', (player) => {
  console.log(`[PLAYER] Created:`, {
    guild: player.guildId,
    node: player.node.identifier,
    voiceChannel: player.voiceChannelId,
    textChannel: player.textChannelId
  });

  const embed = new EmbedBuilder()
    .setColor('#4ade80')
    .setTitle('🎵 Player Created')
    .setDescription(`Music player created in <#${player.voiceChannelId}>`);

  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) {
    channel.send({ embeds: [embed] });
  }
});
[PLAYER] Created: {
  guild: "123456789012345678",
  node: "Node-1",
  voiceChannel: "123456789012345678",
  textChannel: "876543210987654321"
}

Initialize player settings and setup event handlers.

playerUpdate

playerUpdateevent

Player Update

Emitted when a player is updated.

Parameters
playerrequiredPlayer
The updated player
trackrequiredTrack
The updated track
payloadrequiredany
The payload data

Usage Example

manager.on('playerUpdate', (player, track, payload) => {
  console.log(`Player updated: ${player.guildId}`, payload);
});
[PLAYER] Updated: {
  guild: "123456789012345678",
  track: {
    title: "Never Gonna Give You Up",
    author: "Rick Astley"
  },
  payload: {
    volume: 1.0,
    loop: false,
    autoplay: true
  }
}

Handle player updates and implement additional logic if needed.

playerDestroy

playerDestroyevent

Player Destroy

Emitted when a player is destroyed.

Parameters
playerrequiredPlayer
The destroyed player

Usage Example

manager.on('playerDestroy', (player) => {
  console.log(`[PLAYER] Destroyed:`, {
    guild: player.guildId,
    node: player.node.identifier,
    reason: player.state
  });

  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('👋 Player Destroyed')
    .setDescription('Music player has been destroyed');

  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) {
    channel.send({ embeds: [embed] });
  }

  // Cleanup any resources
  player.queue.clear();
});
[PLAYER] Destroyed: {
  guild: "123456789012345678",
  node: "Node-1",
  reason: "disconnected"
}
#footer Clean up resources and notify users when a player is destroyed. :: :: ::

playerSwitchedNode

playerSwitchedNodeevent

Player Switched Node

Emitted when a player switches to a different node.

Parameters
playerrequiredPlayer
The player that switched
oldNoderequiredNode
The previous node
newNoderequiredNode
The new node
::

Usage Example

manager.on('playerSwitchedNode', (player, oldNode, newNode) => {
  console.log(`Player switched from node ${oldNode.identifier} to ${newNode.identifier}`);
});
[PLAYER] Switched node: {
  guild: "123456789012345678",
  oldNode: "Node-1",
  newNode: "Node-2"
}

Handle node switches to maintain playback continuity.

::

Player Control Events

playerTriggeredPlay

playerTriggeredPlayevent

Player Triggered Play

Emitted when a player starts playing.

Parameters
playerrequiredPlayer
The player that started playing
trackrequiredTrack
The track that started playing

Usage Example

manager.on('playerTriggeredPlay', (player, track) => {
  console.log(`Player started playing: ${track.title}`);
});
[PLAYER] Started playing: {
  guild: "123456789012345678",
  track: {
    title: "Never Gonna Give You Up",
    author: "Rick Astley"
  }
}

Handle player start events and implement additional logic if needed.

playerTriggeredPause

playerTriggeredPauseevent

Player Triggered Pause

Emitted when a player is paused.

Parameters
playerrequiredPlayer
The player that was paused
::

Usage Example

manager.on('playerTriggeredPause', (player) => {
  console.log(`Player paused: ${player.guildId}`);
});
[PLAYER] Paused: {
  guild: "123456789012345678"
}

Handle player pause events and implement additional logic if needed.

::

playerTriggeredResume

playerTriggeredResumeevent

Player Triggered Resume

Emitted when a player resumes playing.

Parameters
playerrequiredPlayer
The player that resumed playing

Usage Example

manager.on('playerTriggeredResume', (player) => {
  console.log(`Player resumed: ${player.guildId}`);
});
[PLAYER] Resumed: {
  guild: "123456789012345678"
}

Handle player resume events and implement additional logic if needed.

playerTriggeredStop

playerTriggeredStopevent

Player Triggered Stop

Emitted when a player stops playing.

Parameters
playerrequiredPlayer
The player that stopped playing

Usage Example

manager.on('playerTriggeredStop', (player) => {
  console.log(`Player stopped: ${player.guildId}`);
});
[PLAYER] Stopped: {
  guild: "123456789012345678"
}

Handle WebSocket errors and implement recovery strategies.

Filter Events

filterUpdate

filterUpdateevent

Filter Update

Emitted when audio filters are updated.

Parameters
playerrequiredPlayer
The player whose filters were updated
filtersrequiredFilters
The updated filters object
::

Usage Example

manager.on('filterUpdate', (player, filters) => {
  console.log(`[FILTER] Updated:`, {
    guild: player.guildId,
    filters: {
      volume: filters.volume,
      equalizer: filters.equalizer,
      karaoke: filters.karaoke,
      timescale: filters.timescale,
      tremolo: filters.tremolo,
      vibrato: filters.vibrato,
      rotation: filters.rotation,
      distortion: filters.distortion,
      channelMix: filters.channelMix,
      lowPass: filters.lowPass
    }
  });

  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('🎛️ Filters Updated')
    .setDescription('Audio filters have been updated')
    .addFields(
      Object.entries(filters)
        .filter(([_, value]) => value !== null && value !== undefined)
        .map(([key, value]) => ({
          name: key.charAt(0).toUpperCase() + key.slice(1),
          value: typeof value === 'object' ? 'Applied' : String(value),
          inline: true
        }))
    );

  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) {
    channel.send({ embeds: [embed] });
  }
});
[FILTER] Updated: {
  guild: "123456789012345678",
  filters: {
    volume: 1.0,
    equalizer: [
      { band: 0, gain: 0.2 },
      { band: 1, gain: 0.15 }
    ],
    karaoke: null,
    timescale: { speed: 1.1, pitch: 1.0, rate: 1.0 },
    tremolo: null,
    vibrato: null,
    rotation: null,
    distortion: null,
    channelMix: null,
    lowPass: null
  }
}

Monitor and display audio filter changes.

::

Events

playerTriggeredSkip

playerTriggeredSkipevent

Player Triggered Skip

Emitido quando uma track é pulada.Parâmetros:

  • player: Player - O player
  • oldTrack: Record<string, any> - Track anterior
  • currentTrack: Track - Nova track
  • position: number - Posição atual
manager.on('playerTriggeredSkip', (player, oldTrack, currentTrack, position) => {
  console.log(`Track pulada: ${oldTrack.title} -> ${currentTrack.title} (Posição: ${position})`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('⏭️ Track Pulada')
    .setDescription(`Pulou **${oldTrack.title}**\nAgora tocando: **${currentTrack.title}**`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerTriggeredSeek

playerTriggeredSeekevent

Player Triggered Seek

Emitido quando a posição da track é alterada.Parâmetros:

  • player: Player - O player
  • position: number - Nova posição em milissegundos
manager.on('playerTriggeredSeek', (player, position) => {
  const timeString = new Date(position).toISOString().substr(11, 8);
  console.log(`Posição alterada para ${timeString}`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('⏩ Posição Alterada')
    .setDescription(`Avançou para ${timeString}`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerTriggeredShuffle

playerTriggeredShuffleevent

Player Triggered Shuffle

Emitido quando a fila é embaralhada.Parâmetros:

  • player: Player - O player
  • oldQueue: Record<string, any> - Fila anterior
  • currentQueue: Track[] - Nova fila
manager.on('playerTriggeredShuffle', (player, oldQueue, currentQueue) => {
  console.log(`Fila embaralhada: ${currentQueue.length} tracks`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('🔀 Fila Embaralhada')
    .setDescription(`${currentQueue.length} tracks na fila`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerChangedVolume

playerChangedVolumeevent

Player Changed Volume

Emitido quando o volume é alterado.Parâmetros:

  • player: Player - O player
  • oldVolume: number - Volume anterior
  • volume: number - Novo volume
manager.on('playerChangedVolume', (player, oldVolume, volume) => {
  console.log(`Volume alterado: ${oldVolume} -> ${volume}`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('🔊 Volume Alterado')
    .setDescription(`Volume: ${volume}%`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerChangedLoop

playerChangedLoopevent

Player Changed Loop

Emitido quando o modo de loop é alterado.Parâmetros:

  • player: Player - O player
  • oldLoop: TPlayerLoop - Modo anterior
  • loop: TPlayerLoop - Novo modo
manager.on('playerChangedLoop', (player, oldLoop, loop) => {
  console.log(`Loop alterado: ${oldLoop} -> ${loop}`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('🔁 Loop Alterado')
    .setDescription(`Modo: ${loop}`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerAutoPlaySet

playerAutoPlaySetevent

Player Auto Play Set

Emitido quando o autoplay é alterado.Parâmetros:

  • player: Player - O player
  • autoPlay: boolean - Novo estado
manager.on('playerAutoPlaySet', (player, autoPlay) => {
  console.log(`Autoplay ${autoPlay ? 'ativado' : 'desativado'}`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('🎵 Autoplay')
    .setDescription(`Autoplay ${autoPlay ? 'ativado' : 'desativado'}`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerAutoLeaveSet

playerAutoLeaveSetevent

Player Auto Leave Set

Emitido quando o autoleave é alterado.Parâmetros:

  • player: Player - O player
  • autoLeave: boolean - Novo estado
manager.on('playerAutoLeaveSet', (player, autoLeave) => {
  console.log(`Autoleave ${autoLeave ? 'ativado' : 'desativado'}`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('👋 Auto Leave')
    .setDescription(`Auto leave ${autoLeave ? 'ativado' : 'desativado'}`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerTextChannelIdSet

playerTextChannelIdSetevent

Player Text Channel ID Set

Emitido quando o canal de texto é alterado.Parâmetros:

  • player: Player - O player
  • oldChannel: string - Canal anterior
  • newChannel: string - Novo canal
manager.on('playerTextChannelIdSet', (player, oldChannel, newChannel) => {
  console.log(`Canal de texto alterado: ${oldChannel} -> ${newChannel}`);
});

playerVoiceChannelIdSet

playerVoiceChannelIdSetevent

Player Voice Channel ID Set

Emitido quando o canal de voz é alterado.Parâmetros:

  • player: Player - O player
  • oldChannel: string - Canal anterior
  • newChannel: string - Novo canal
manager.on('playerVoiceChannelIdSet', (player, oldChannel, newChannel) => {
  console.log(`Canal de voz alterado: ${oldChannel} -> ${newChannel}`);
});

playerNodeSet

playerNodeSetevent

Player Node Set

Emitido quando o node do player é alterado.Parâmetros:

  • player: Player - O player
  • oldNode: string - Node anterior
  • newNode: string - Novo node
manager.on('playerNodeSet', (player, oldNode, newNode) => {
  console.log(`Node alterado: ${oldNode} -> ${newNode}`);
});

playerConnected

playerConnectedevent

Player Connected

Emitido quando um player conecta.Parâmetros:

  • player: Player - O player conectado
manager.on('playerConnected', (player) => {
  console.log(`Player conectado em ${player.guildId}`);
  
  const embed = new EmbedBuilder()
    .setColor('#4ade80')
    .setTitle('🔌 Conectado')
    .setDescription(`Conectado ao canal de voz`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerDisconnected

playerDisconnectedevent

Player Disconnected

Emitido quando um player desconecta.Parâmetros:

  • player: Player - O player desconectado
manager.on('playerDisconnected', (player) => {
  console.log(`Player desconectado em ${player.guildId}`);
  
  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('🔌 Desconectado')
    .setDescription(`Desconectado do canal de voz`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerMoved

playerMovedevent

Player Moved

Emitido quando um player muda de canal.Parâmetros:

  • player: Player - O player movido
  • oldChannel: string - Canal anterior
  • newChannel: string - Novo canal
manager.on('playerMoved', (player, oldChannel, newChannel) => {
  console.log(`Player movido: ${oldChannel} -> ${newChannel}`);
  
  const embed = new EmbedBuilder()
    .setColor('#fbbf24')
    .setTitle('↔️ Canal Alterado')
    .setDescription(`Movido para <#${newChannel}>`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

playerDestroyed

playerDestroyedevent

Player Destroyed

Emitido quando um player é destruído.Parâmetros:

  • player: Player - O player destruído
manager.on('playerDestroyed', (player) => {
  console.log(`Player destruído em ${player.guildId}`);
  
  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('💥 Player Destruído')
    .setDescription(`O player foi destruído`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

trackStart

trackStartevent

Track Start

Emitido quando uma track começa a tocar.Parâmetros:

  • player: Player - O player
  • track: Track - A track iniciada
manager.on('trackStart', (player, track) => {
  console.log(`Tocando: ${track.title}`);
  
  const embed = new EmbedBuilder()
    .setColor('#4ade80')
    .setTitle('🎵 Tocando Agora')
    .setDescription(`**${track.title}**`)
    .addFields(
      { name: 'Artista', value: track.author, inline: true },
      { name: 'Duração', value: formatTime(track.duration), inline: true }
    )
    .setThumbnail(track.artworkUrl);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

trackEnd

trackEndevent

Track End

Emitido quando uma track termina.Parâmetros:

  • player: Player - O player
  • track: Track - A track finalizada
  • type: TTrackEndType - Tipo de finalização
  • payload?: any - Dados adicionais
manager.on('trackEnd', (player, track, type, payload) => {
  console.log(`Track finalizada: ${track.title} (${type})`);
  
  const embed = new EmbedBuilder()
    .setColor('#94a3b8')
    .setTitle('🎵 Track Finalizada')
    .setDescription(`**${track.title}** terminou`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

trackStuck

trackStuckevent

Track Stuck

Emitido quando uma track trava.Parâmetros:

  • player: Player - O player
  • track: Track - A track travada
  • threshold: number - Limite de tempo
manager.on('trackStuck', (player, track, threshold) => {
  console.log(`Track travou: ${track.title} (${threshold}ms)`);
  
  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('⚠️ Track Travada')
    .setDescription(`**${track.title}** travou\nTempo limite: ${threshold}ms`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

trackException

trackExceptionevent

Track Exception

Emitido quando ocorre um erro na track.Parâmetros:

  • player: Player - O player
  • track: Track - A track com erro
  • exception: any - O erro ocorrido
manager.on('trackException', (player, track, exception) => {
  console.log(`Erro na track ${track.title}:`, exception);
  
  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('❌ Erro na Track')
    .setDescription(`Erro ao tocar **${track.title}**\n\`${exception.message}\``);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

queueEnd

queueEndevent

Queue End

Emitido quando a fila termina.Parâmetros:

  • player: Player - O player
  • track?: any - Última track tocada
manager.on('queueEnd', (player, track) => {
  console.log(`Fila finalizada em ${player.guildId}`);
  
  const embed = new EmbedBuilder()
    .setColor('#94a3b8')
    .setTitle('🎵 Fila Finalizada')
    .setDescription('Todas as tracks foram tocadas');
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});

socketClosed

socketClosedevent

Socket Closed

Emitido quando o socket é fechado.Parâmetros:

  • player: Player - O player
  • code: number - Código de fechamento
  • reason: string - Motivo do fechamento
  • byRemote: boolean - Se foi fechado remotamente
manager.on('socketClosed', (player, code, reason, byRemote) => {
  console.log(`Socket fechado: ${reason} (${code})`);
  
  const embed = new EmbedBuilder()
    .setColor('#ef4444')
    .setTitle('🔌 Conexão Fechada')
    .setDescription(`Conexão fechada: ${reason}\nCódigo: ${code}`);
  
  const channel = client.channels.cache.get(player.textChannelId);
  if (channel) channel.send({ embeds: [embed] });
});