@discordx/music/dist/index.d.mts

Powerful Discord music player library using YTDL

import { Client, Collection } from 'discord.js';
import { EventEmitter } from 'events';
import { AudioPlayerStatus } from '@discordjs/voice';

declare enum AudioNodeEvent {
    Debug = "DEBUG",
    Error = "ERROR",
    PlaybackInfo = "PLAYBACK_INFO",
    StateChange = "STATE_CHANGE",
    Subscription = "SUBSCRIPTION",
    UnSubscription = "UN_SUBSCRIPTION"
}
interface PlaybackInfoAudioNodePayload {
    ended: boolean;
    playbackDuration: number;
    playerStatus: AudioPlayerStatus;
    type: AudioNodeEvent.PlaybackInfo;
}
interface DebugAudioNodePayload {
    message: string;
    type: AudioNodeEvent.Debug;
}
interface StateChangeAudioNodePayload {
    newState: AudioPlayerStatus;
    oldState: AudioPlayerStatus;
    type: AudioNodeEvent.StateChange;
}
type AudioNodeEventPayload = PlaybackInfoAudioNodePayload | DebugAudioNodePayload | StateChangeAudioNodePayload;

declare enum ParentProcessEvent {
    AudioNodeEvent = "AUDIO_NODE_EVENT",
    AudioNodeNotFound = "AUDIO_NODE_NOT_FOUND",
    ConnectionDestroy = "CONNECTION_DESTROY",
    VoiceStateUpdate = "VOICE_STATE_UPDATE"
}
interface VoiceStateUpdateData {
    channelId: string;
    guildId: string;
    payload: VoiceStateUpdatePayload;
}
interface VoiceStateUpdatePayload {
    channel_id: string;
    guild_id: string;
    self_deaf: boolean;
    self_mute: boolean;
}
interface ConnectionDestroyData {
    channelId: string;
    guildId: string;
}
interface NodeAudioData {
    channelId: string | null;
    guildId: string;
    payload: AudioNodeEventPayload;
}
interface VoiceStateUpdateDataPayload {
    data: VoiceStateUpdateData;
    op: ParentProcessEvent.VoiceStateUpdate;
}
interface ConnectionDestroyDataPayload {
    data: ConnectionDestroyData;
    op: ParentProcessEvent.ConnectionDestroy;
}
interface NodeAudioDataPayload {
    data: NodeAudioData;
    op: ParentProcessEvent.AudioNodeEvent;
}
interface AudioNodeNotFoundData {
    guildId: string;
}
interface AudioNodeNotFoundDataPayload {
    data: AudioNodeNotFoundData;
    op: ParentProcessEvent.AudioNodeNotFound;
}
type ParentProcessDataPayload = VoiceStateUpdateDataPayload | ConnectionDestroyDataPayload | NodeAudioDataPayload | AudioNodeNotFoundDataPayload;

declare enum WorkerOperation {
    Disconnect = "DISCONNECT",
    DisconnectAll = "DISCONNECT_ALL",
    Join = "JOIN",
    OnVoiceServerUpdate = "ON_VOICE_SERVER_UPDATE",
    OnVoiceStateUpdate = "ON_VOICE_STATE_UPDATE",
    Pause = "PAUSE",
    PingPlaybackInfo = "PING_PLAYBACK_INFO",
    Play = "PLAY",
    Resume = "RESUME",
    SetVolume = "SET_VOLUME",
    Stop = "STOP"
}
interface GuildData {
    guildId: string;
}
interface DisconnectPayload {
    data: GuildData;
    op: WorkerOperation.Disconnect;
}
interface DisconnectAllPayload {
    data?: undefined;
    op: WorkerOperation.DisconnectAll;
}
interface JoinData {
    channelId: string;
    deafen?: boolean;
    group?: string;
    guildId: string;
}
interface JoinPayload {
    data: JoinData;
    op: WorkerOperation.Join;
}
interface VoiceServerUpdatePayload {
    data: any;
    op: WorkerOperation.OnVoiceServerUpdate;
}
interface VoiceUpdatePayload {
    data: any;
    op: WorkerOperation.OnVoiceStateUpdate;
}
interface NodePlayerOptions {
    initialVolume?: number;
    metadata?: unknown;
    query: string;
    seek?: number;
}
interface PlayPayload {
    data: PlayData;
    op: WorkerOperation.Play;
}
interface PlayData {
    guildId: string;
    payload: NodePlayerOptions;
}
interface SetVolumePayload {
    data: SetVolumeData;
    op: WorkerOperation.SetVolume;
}
interface SetVolumeData {
    guildId: string;
    volume: number;
}
interface PingPlaybackInfoPayload {
    data: GuildData;
    op: WorkerOperation.PingPlaybackInfo;
}
interface PausePayload {
    data: GuildData;
    op: WorkerOperation.Pause | WorkerOperation.Resume;
}
interface StopPayload {
    data: GuildData;
    op: WorkerOperation.Stop;
}
type WorkerDataPayload = DisconnectPayload | DisconnectAllPayload | JoinPayload | VoiceServerUpdatePayload | VoiceUpdatePayload | PlayPayload | SetVolumePayload | PingPlaybackInfoPayload | PausePayload | StopPayload;

declare enum QueueEvent {
    ParentProcessEvent = "PARENT_PROCESS_EVENT"
}
interface QueueEventPayloads {
    [QueueEvent.ParentProcessEvent]: ParentProcessDataPayload;
}

interface Node extends EventEmitter {
    on<T extends QueueEvent>(event: T, listener: (payload: QueueEventPayloads[T]) => void): this;
}
declare class Node extends EventEmitter {
    client: Client;
    private worker;
    constructor(client: Client);
    private sendOp;
    private setupEventListeners;
    private setupWorkerMessageHandler;
    private handleWorkerVoiceStateUpdate;
    private handleWorkerConnectionDestroy;
    join(data: JoinData): void;
    play(data: PlayData): void;
    pingPlaybackInfo(data: GuildData): void;
    setVolume(data: SetVolumeData): void;
    pause(data: GuildData): void;
    resume(data: GuildData): void;
    stop(data: GuildData): void;
    disconnect(data: GuildData): void;
    disconnectAll(): void;
}

interface Track {
    /**
     * Initial seek position on milliseconds
     */
    seek?: number;
    /**
     * Youtube URL of track
     */
    url: string;
}
declare enum RepeatMode {
    OFF = "OFF",
    REPEAT_ALL = "REPEAT_ALL",
    REPEAT_ONE = "REPEAT_ONE"
}
declare class Queue<T extends Track = Track> {
    node: Node;
    guildId: string;
    private _leaveOnFinish;
    private _currentPlaybackTrack;
    private _playbackInfo;
    private _playerState;
    private _repeatMode;
    private _volume;
    private _tracks;
    private _pingIntervalId;
    get leaveOnFinish(): boolean;
    get client(): Client;
    get tracks(): readonly T[];
    get currentPlaybackTrack(): T | null;
    get nextTrack(): T | null;
    get playbackInfo(): PlaybackInfoAudioNodePayload | null;
    get playerState(): AudioPlayerStatus;
    get isPlaying(): boolean;
    get repeatMode(): RepeatMode;
    get volume(): number;
    get size(): number;
    constructor(node: Node, guildId: string);
    /**
     * Starts a ping to keep the playback information updated.
     */
    startPing(): void;
    /**
     * Stops the ping for updating playback information.
     */
    stopPing(): void;
    /**
     * Adds tracks to the end of the queue.
     * @param track - The tracks to be added.
     */
    addTrack(...track: T[]): void;
    /**
     * Adds tracks to the beginning of the queue.
     * @param track - The tracks to be added.
     */
    addTrackFirst(...track: T[]): void;
    /**
     * Changes the position of a track in the queue.
     * @param oldIndex - The current index of the track.
     * @param newIndex - The new index for the track.
     * @throws Will throw an error if the indices are out of bounds.
     */
    changeTrackPosition(oldIndex: number, newIndex: number): void;
    /**
     * Exits the player, clearing the queue and destroying the LavaPlayer instance.
     */
    exit(): void;
    /**
     * Joins a voice channel.
     * @param data - The data required to join the channel.
     */
    join(data: Omit<JoinData, "guildId">): void;
    /**
     * Leaves the voice channel.
     */
    leave(): void;
    /**
     * Pauses the playback.
     */
    pause(): void;
    /**
     * Plays the next track in the queue.
     * @returns The next track that was played or null if the queue is empty.
     */
    playNext(): T | null;
    /**
     * Removes tracks from the queue by their indices.
     * @param indices - The indices of the tracks to be removed.
     */
    removeTracks(...indices: number[]): void;
    /**
     * Removes all tracks from the queue.
     */
    removeAllTracks(): void;
    /**
     * Resumes the playback.
     */
    resume(): void;
    /**
     * Seek the playback to specific position
     * @param seconds in milliseconds
     */
    seek(seconds: number): T | null;
    /**
     * Set leave on finish state
     */
    setLeaveOnFinish(value: boolean): void;
    /**
     * Set playback info
     */
    setPlaybackInfo(info: PlaybackInfoAudioNodePayload): void;
    /**
     * set player state
     */
    setPlayerState(state: AudioPlayerStatus): void;
    /**
     * Sets the repeat mode for the queue.
     * @param mode - The repeat mode to be set.
     */
    setRepeatMode(mode: RepeatMode): void;
    /**
     * Sets the volume for playback.
     * @param volume - The volume level to be set.
     */
    setVolume(volume: number): void;
    /**
     * Shuffles the tracks in the queue.
     */
    shuffleTracks(): void;
    /**
     * Skips the current track.
     */
    skip(): void;
}

declare class QueueManager {
    node: Node;
    queues: Collection<string, Queue<Track>>;
    constructor(node: Node);
    queue<T extends Queue = Queue>(guildId: string, resolver?: () => T): T;
}

export { AudioNodeEvent, type AudioNodeEventPayload, type AudioNodeNotFoundData, type AudioNodeNotFoundDataPayload, type ConnectionDestroyData, type ConnectionDestroyDataPayload, type DebugAudioNodePayload, type DisconnectAllPayload, type DisconnectPayload, type GuildData, type JoinData, type JoinPayload, Node, type NodeAudioData, type NodeAudioDataPayload, type NodePlayerOptions, type ParentProcessDataPayload, ParentProcessEvent, type PausePayload, type PingPlaybackInfoPayload, type PlayData, type PlayPayload, type PlaybackInfoAudioNodePayload, Queue, QueueEvent, type QueueEventPayloads, QueueManager, RepeatMode, type SetVolumeData, type SetVolumePayload, type StateChangeAudioNodePayload, type StopPayload, type Track, type VoiceServerUpdatePayload, type VoiceStateUpdateData, type VoiceStateUpdateDataPayload, type VoiceStateUpdatePayload, type VoiceUpdatePayload, type WorkerDataPayload, WorkerOperation };