magmastream 2.9.0-dev.27 → 2.9.0-dev.29

package/dist/index.d.ts

@@ -1,8 +1,12 @@
-import { User, ClientUser, Message } from 'discord.js';
-import WebSocket from 'ws';
 import { Collection } from '@discordjs/collection';
+import { GatewayVoiceStateUpdate } from 'discord-api-types/v10';
 import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import { User, ClientUser, Message, Client } from 'discord.js';
 import { Redis } from 'ioredis';
+import { Client as Client$1 } from 'eris';
+import { ClusterClient, ShardClient } from 'detritus-client';
+import { Client as Client$2 } from 'oceanic.js';
 
 /** Represents an equalizer band. */
 interface Band {
@@ -24,7 +28,7 @@ declare class Rest {
     private readonly url;
     /** The Manager instance. */
     manager: Manager;
-    constructor(node: Node, manager: Manager);
+    constructor(node: Node$1, manager: Manager);
     /**
      * Sets the session ID.
      * This method is used to set the session ID after a resume operation is done.
@@ -130,6 +134,180 @@ interface playOptions {
     };
 }
 
+/**
+ * State Storage Enum
+ */
+declare enum StateStorageType {
+    Collection = "collection",
+    Redis = "redis"
+}
+/**
+ * AutoPlay Platform Enum
+ */
+declare enum AutoPlayPlatform {
+    Spotify = "spotify",
+    Deezer = "deezer",
+    SoundCloud = "soundcloud",
+    Tidal = "tidal",
+    VKMusic = "vkmusic",
+    Qobuz = "qobuz",
+    YouTube = "youtube"
+}
+/**
+ * State Types Enum
+ */
+declare enum StateTypes {
+    Connected = "CONNECTED",
+    Connecting = "CONNECTING",
+    Disconnected = "DISCONNECTED",
+    Disconnecting = "DISCONNECTING",
+    Destroying = "DESTROYING"
+}
+/**
+ * Load Types Enum
+ */
+declare enum LoadTypes {
+    Track = "track",
+    Playlist = "playlist",
+    Search = "search",
+    Empty = "empty",
+    Error = "error"
+}
+/**
+ * Search Platform Enum
+ */
+declare enum SearchPlatform {
+    AppleMusic = "amsearch",
+    Bandcamp = "bcsearch",
+    Deezer = "dzsearch",
+    Jiosaavn = "jssearch",
+    Qobuz = "qbsearch",
+    SoundCloud = "scsearch",
+    Spotify = "spsearch",
+    Tidal = "tdsearch",
+    VKMusic = "vksearch",
+    YouTube = "ytsearch",
+    YouTubeMusic = "ytmsearch"
+}
+/**
+ * Player State Event Types Enum
+ */
+declare enum PlayerStateEventTypes {
+    AutoPlayChange = "playerAutoplay",
+    ConnectionChange = "playerConnection",
+    RepeatChange = "playerRepeat",
+    PauseChange = "playerPause",
+    QueueChange = "queueChange",
+    TrackChange = "trackChange",
+    VolumeChange = "volumeChange",
+    ChannelChange = "channelChange",
+    PlayerCreate = "playerCreate",
+    PlayerDestroy = "playerDestroy"
+}
+/**
+ * Track Source Types Enum
+ */
+declare enum TrackSourceTypes {
+    AppleMusic = "applemusic",
+    Bandcamp = "bandcamp",
+    Deezer = "deezer",
+    Jiosaavn = "jiosaavn",
+    SoundCloud = "soundcloud",
+    Spotify = "spotify",
+    Tidal = "tidal",
+    VKMusic = "vkmusic",
+    YouTube = "youtube"
+}
+/**
+ * Use Node Options Enum
+ */
+declare enum UseNodeOptions {
+    LeastLoad = "leastLoad",
+    LeastPlayers = "leastPlayers"
+}
+/**
+ * Track Partial Enum
+ */
+declare enum TrackPartial {
+    /** The base64 encoded string of the track */
+    Track = "track",
+    /** The title of the track */
+    Title = "title",
+    /** The track identifier */
+    Identifier = "identifier",
+    /** The author of the track */
+    Author = "author",
+    /** The length of the track in milliseconds */
+    Duration = "duration",
+    /** The ISRC of the track */
+    Isrc = "isrc",
+    /** Whether the track is seekable */
+    IsSeekable = "isSeekable",
+    /** Whether the track is a stream */
+    IsStream = "isStream",
+    /** The URI of the track */
+    Uri = "uri",
+    /** The artwork URL of the track */
+    ArtworkUrl = "artworkUrl",
+    /** The source name of the track */
+    SourceName = "sourceName",
+    /** The thumbnail of the track */
+    ThumbNail = "thumbnail",
+    /** The requester of the track */
+    Requester = "requester",
+    /** The plugin info of the track */
+    PluginInfo = "pluginInfo",
+    /** The custom data of the track */
+    CustomData = "customData"
+}
+declare enum ManagerEventTypes {
+    ChapterStarted = "chapterStarted",
+    ChaptersLoaded = "chaptersLoaded",
+    Debug = "debug",
+    NodeConnect = "nodeConnect",
+    NodeCreate = "nodeCreate",
+    NodeDestroy = "nodeDestroy",
+    NodeDisconnect = "nodeDisconnect",
+    NodeError = "nodeError",
+    NodeRaw = "nodeRaw",
+    NodeReconnect = "nodeReconnect",
+    PlayerCreate = "playerCreate",
+    PlayerDestroy = "playerDestroy",
+    PlayerDisconnect = "playerDisconnect",
+    PlayerMove = "playerMove",
+    PlayerRestored = "playerRestored",
+    PlayerStateUpdate = "playerStateUpdate",
+    QueueEnd = "queueEnd",
+    RestoreComplete = "restoreComplete",
+    SegmentSkipped = "segmentSkipped",
+    SegmentsLoaded = "segmentsLoaded",
+    SocketClosed = "socketClosed",
+    TrackEnd = "trackEnd",
+    TrackError = "trackError",
+    TrackStart = "trackStart",
+    TrackStuck = "trackStuck"
+}
+/**
+ * Track End Reason Enum
+ */
+declare enum TrackEndReasonTypes {
+    Finished = "finished",
+    LoadFailed = "loadFailed",
+    Stopped = "stopped",
+    Replaced = "replaced",
+    Cleanup = "cleanup"
+}
+/**
+ * Severity Types Enum
+ */
+declare enum SeverityTypes {
+    Common = "common",
+    Suspicious = "suspicious",
+    Fault = "fault"
+}
+/**
+ * SponsorBlock Segment Enum
+ */
 declare enum SponsorBlockSegment {
     Sponsor = "sponsor",
     SelfPromo = "selfpromo",
@@ -140,632 +318,359 @@ declare enum SponsorBlockSegment {
     MusicOfftopic = "music_offtopic",
     Filler = "filler"
 }
-declare class Node {
-    options: NodeOptions;
-    /** The socket for the node. */
-    socket: WebSocket | null;
-    /** The stats for the node. */
-    stats: NodeStats;
-    /** The manager for the node */
+
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+declare class Queue extends Array<Track> implements IQueue {
+    /** The current track */
+    current: Track | null;
+    /** The previous tracks */
+    previous: Track[];
+    /** The Manager instance. */
     manager: Manager;
-    /** The node's session ID. */
-    sessionId: string | null;
-    /** The REST instance. */
-    readonly rest: Rest;
-    /** Actual Lavalink information of the node. */
-    info: LavalinkInfo | null;
-    private static _manager;
-    private reconnectTimeout?;
-    private reconnectAttempts;
+    /** The guild ID property. */
+    guildId: string;
     /**
-     * Creates an instance of Node.
-     * @param options
+     * Constructs a new Queue.
+     * @param guildId The guild ID.
+     * @param manager The Manager instance.
      */
-    constructor(options: NodeOptions);
-    /** Returns if connected to the Node. */
-    get connected(): boolean;
-    /** Returns the address for this node. */
-    get address(): string;
-    /** @hidden */
-    static init(manager: Manager): void;
+    constructor(guildId: string, manager: Manager);
+    getCurrent(): Promise<Track | null>;
+    setCurrent(track: Track | null): Promise<void>;
+    getPrevious(): Promise<Track[]>;
+    addPrevious(track: Track | Track[]): Promise<void>;
+    setPrevious(tracks: Track[]): Promise<void>;
+    popPrevious(): Promise<Track | null>;
+    clearPrevious(): Promise<void>;
     /**
-     * Creates the sessionIds.json file if it doesn't exist. This file is used to
-     * store the session IDs for each node. The session IDs are used to identify
-     * the node when resuming a session.
+     * The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
      */
-    createSessionIdsFile(): void;
+    duration(): Promise<number>;
     /**
-     * Loads session IDs from the sessionIds.json file if it exists.
-     * The session IDs are used to resume sessions for each node.
-     *
-     * The session IDs are stored in the sessionIds.json file as a composite key
-     * of the node identifier and cluster ID. This allows multiple clusters to
-     * be used with the same node identifier.
+     * The total size of tracks in the queue including the current track.
+     * This includes the current track if it is not null.
+     * @returns The total size of tracks in the queue including the current track.
      */
-    loadSessionIds(): void;
+    totalSize(): Promise<number>;
     /**
-     * Updates the session ID in the sessionIds.json file.
-     *
-     * This method is called after the session ID has been updated, and it
-     * writes the new session ID to the sessionIds.json file.
-     *
-     * @remarks
-     * The session ID is stored in the sessionIds.json file as a composite key
-     * of the node identifier and cluster ID. This allows multiple clusters to
-     * be used with the same node identifier.
+     * The size of tracks in the queue.
+     * This does not include the currently playing track.
+     * @returns The size of tracks in the queue.
      */
-    updateSessionId(): void;
+    size(): Promise<number>;
     /**
-     * Connects to the Node.
-     *
-     * @remarks
-     * If the node is already connected, this method will do nothing.
-     * If the node has a session ID, it will be sent in the headers of the WebSocket connection.
-     * If the node has no session ID but the `enableSessionResumeOption` option is true, it will use the session ID
-     * stored in the sessionIds.json file if it exists.
+     * Adds a track to the queue.
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
      */
-    connect(): void;
+    add(track: Track | Track[], offset?: number): Promise<void>;
     /**
-     * Destroys the node and cleans up associated resources.
-     *
-     * This method emits a debug event indicating that the node is being destroyed and attempts
-     * to automatically move all players connected to the node to a usable one. It then closes
-     * the WebSocket connection, removes all event listeners, and clears the reconnect timeout.
-     * Finally, it emits a "nodeDestroy" event and removes the node from the manager.
-     *
-     * @returns {Promise<void>} A promise that resolves when the node and its resources have been destroyed.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Attempts to reconnect to the node if the connection is lost.
-     *
-     * This method is called when the WebSocket connection is closed
-     * unexpectedly. It will attempt to reconnect to the node after a
-     * specified delay, and will continue to do so until the maximum
-     * number of retry attempts is reached or the node is manually destroyed.
-     * If the maximum number of retry attempts is reached, an error event
-     * will be emitted and the node will be destroyed.
-     *
-     * @returns {Promise<void>} - Resolves when the reconnection attempt is scheduled.
-     * @emits {debug} - Emits a debug event indicating the node is attempting to reconnect.
-     * @emits {nodeReconnect} - Emits a nodeReconnect event when the node is attempting to reconnect.
-     * @emits {nodeError} - Emits an error event if the maximum number of retry attempts is reached.
-     * @emits {nodeDestroy} - Emits a nodeDestroy event if the maximum number of retry attempts is reached.
+     * Removes track(s) from the queue.
+     * @param startOrPosition If a single number is provided, it will be treated as the position of the track to remove.
+     *                         If two numbers are provided, they will be used as the start and end of a range of tracks to remove.
+     * @param end Optional, end of the range of tracks to remove.
+     * @returns The removed track(s).
      */
-    private reconnect;
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
     /**
-     * Handles the "open" event emitted by the WebSocket connection.
-     *
-     * This method is called when the WebSocket connection is established.
-     * It clears any existing reconnect timeouts, emits a debug event
-     * indicating the node is connected, and emits a "nodeConnect" event
-     * with the node as the argument.
+     * Clears the queue.
+     * This will remove all tracks from the queue and emit a state update event.
      */
-    protected open(): void;
+    clear(): Promise<void>;
     /**
-     * Handles the "close" event emitted by the WebSocket connection.
-     *
-     * This method is called when the WebSocket connection is closed.
-     * It emits a "nodeDisconnect" event with the node and the close event as arguments,
-     * and a debug event indicating the node is disconnected.
-     * It then attempts to move all players connected to that node to a useable one.
-     * If the close event was not initiated by the user, it will also attempt to reconnect.
-     *
-     * @param {number} code The close code of the WebSocket connection.
-     * @param {string} reason The reason for the close event.
-     * @returns {Promise<void>} A promise that resolves when the disconnection is handled.
+     * Shuffles the queue.
+     * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    protected close(code: number, reason: string): Promise<void>;
+    shuffle(): Promise<void>;
     /**
-     * Handles the "error" event emitted by the WebSocket connection.
-     *
-     * This method is called when an error occurs on the WebSocket connection.
-     * It emits a "nodeError" event with the node and the error as arguments and
-     * a debug event indicating the error on the node.
-     * @param {Error} error The error that occurred.
+     * Shuffles the queue to play tracks requested by each user one block at a time.
      */
-    protected error(error: Error): void;
+    userBlockShuffle(): Promise<void>;
     /**
-     * Handles incoming messages from the Lavalink WebSocket connection.
-     * @param {Buffer | string} d The message received from the WebSocket connection.
-     * @returns {Promise<void>} A promise that resolves when the message is handled.
-     * @emits {debug} - Emits a debug event with the message received from the WebSocket connection.
-     * @emits {nodeError} - Emits a nodeError event if an unexpected op is received.
-     * @emits {nodeRaw} - Emits a nodeRaw event with the raw message received from the WebSocket connection.
-     * @private
+     * Shuffles the queue to play tracks requested by each user one by one.
      */
-    protected message(d: Buffer | string): Promise<void>;
-    /**
-     * Handles an event emitted from the Lavalink node.
-     * @param {PlayerEvent & PlayerEvents} payload The event emitted from the node.
-     * @returns {Promise<void>} A promise that resolves when the event has been handled.
-     * @private
+    roundRobinShuffle(): Promise<void>;
+    dequeue(): Promise<Track | undefined>;
+    enqueueFront(track: Track | Track[]): Promise<void>;
+    getTracks(): Promise<Track[]>;
+    getSlice(start?: number, end?: number): Promise<Track[]>;
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+}
+
+/**
+ * Manager Options
+ */
+interface ManagerOptions {
+    /** The state storage options.
+     *
+     * @default { type: StateStorageType.Collection }
      */
-    protected handleEvent(payload: PlayerEvent & PlayerEvents): Promise<void>;
-    /**
-     * Emitted when a new track starts playing.
-     * @param {Player} player The player that started playing the track.
-     * @param {Track} track The track that started playing.
-     * @param {TrackStartEvent} payload The payload of the event emitted by the node.
-     * @private
+    stateStorage?: StateStorageOptions;
+    /** Enable priority mode over least player count or load balancing? */
+    enablePriorityMode?: boolean;
+    /** Automatically play the next track when the current one ends. */
+    playNextOnEnd?: boolean;
+    /** An array of search platforms to use for autoplay. First to last matters
+     * Use enum `AutoPlayPlatform`.
      */
-    protected trackStart(player: Player, track: Track, payload: TrackStartEvent): void;
+    autoPlaySearchPlatforms?: AutoPlayPlatform[];
+    /** The client ID to use. */
+    clientId?: string;
+    /** Value to use for the `Client-Name` header. */
+    clientName?: string;
+    /** The array of shard IDs connected to this manager instance. */
+    clusterId?: number;
+    /** List of plugins to load. */
+    enabledPlugins?: Plugin[];
+    /** The default search platform to use.
+     * Use enum `SearchPlatform`. */
+    defaultSearchPlatform?: SearchPlatform;
+    /** The last.fm API key.
+     * If you need to create one go here: https://www.last.fm/api/account/create.
+     * If you already have one, get it from here: https://www.last.fm/api/accounts. */
+    lastFmApiKey?: string;
+    /** The maximum number of previous tracks to store. */
+    maxPreviousTracks?: number;
+    /** The array of nodes to connect to. */
+    nodes?: NodeOptions[];
+    /** Whether the YouTube video titles should be replaced if the Author does not exactly match. */
+    normalizeYouTubeTitles?: boolean;
+    /** An array of track properties to keep. `track` will always be present. */
+    trackPartial?: TrackPartial[];
+    /** Use the least amount of players or least load? */
+    useNode?: UseNodeOptions.LeastLoad | UseNodeOptions.LeastPlayers;
     /**
-     * Emitted when a track ends playing.
-     * @param {Player} player - The player that the track ended on.
-     * @param {Track} track - The track that ended.
-     * @param {TrackEndEvent} payload - The payload of the event emitted by the node.
-     * @private
+     * Function to send data to the websocket.
+     * @param id The ID of the node to send the data to.
+     * @param payload The payload to send.
      */
-    protected trackEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
+    send?: (packet: DiscordPacket) => unknown;
+}
+/**
+ * State Storage Options
+ */
+interface StateStorageOptions {
+    type: StateStorageType;
+    redisConfig?: RedisConfig;
+}
+/**
+ * Payload
+ */
+interface Payload {
+    /** The OP code */
+    op: number;
+    d: {
+        guild_id: string;
+        channel_id: string | null;
+        self_mute: boolean;
+        self_deaf: boolean;
+    };
+}
+/**
+ * Discord Packet
+ */
+interface DiscordPacket {
     /**
-     * Handles autoplay logic for a player.
-     * This method is responsible for selecting an appropriate method of autoplay
-     * and executing it. If autoplay is not enabled or all attempts have failed,
-     * it will return false.
-     * @param {Player} player - The player to handle autoplay for.
-     * @param {number} attempt - The current attempt number of the autoplay.
-     * @returns {Promise<boolean>} A promise that resolves to a boolean indicating if autoplay was successful.
-     * @private
+     * opcode for the payload
      */
-    private handleAutoplay;
+    op: number;
     /**
-     * Handles the scenario when a track fails to play or load.
-     * Shifts the queue to the next track and emits a track end event.
-     * If there is no next track, handles the queue end scenario.
-     * If autoplay is enabled, plays the next track.
-     *
-     * @param {Player} player - The player instance associated with the track.
-     * @param {Track} track - The track that failed.
-     * @param {TrackEndEvent} payload - The event payload containing details about the track end.
-     * @returns {Promise<void>} A promise that resolves when the track failure has been processed.
-     * @private
+     * event data
      */
-    private handleFailedTrack;
+    d: any;
     /**
-     * Handles the scenario when a track is repeated.
-     * Shifts the queue to the next track and emits a track end event.
-     * If there is no next track, handles the queue end scenario.
-     * If autoplay is enabled, plays the next track.
-     *
-     * @param {Player} player - The player instance associated with the track.
-     * @param {Track} track - The track that is repeated.
-     * @param {TrackEndEvent} payload - The event payload containing details about the track end.
-     * @returns {Promise<void>} A promise that resolves when the repeated track has been processed.
-     * @private
+     * sequence number, used for resuming sessions and heartbeats
      */
-    private handleRepeatedTrack;
+    s?: number;
     /**
-     * Plays the next track in the queue.
-     * Updates the queue by shifting the current track to the previous track
-     * and plays the next track if autoplay is enabled.
-     *
-     * @param {Player} player - The player associated with the track.
-     * @param {Track} track - The track that has ended.
-     * @param {TrackEndEvent} payload - The event payload containing additional data about the track end event.
-     * @returns {void}
-     * @private
+     * the event name for this payload
      */
-    private playNextTrack;
+    t?: string;
+}
+/**
+ * Player Update Voice State
+ */
+interface PlayerUpdateVoiceState {
     /**
-     * Handles the event when a queue ends.
-     * If autoplay is enabled, attempts to play the next track in the queue using the autoplay logic.
-     * If all attempts fail, resets the player state and emits the `queueEnd` event.
-     * @param {Player} player - The player associated with the track.
-     * @param {Track} track - The track that has ended.
-     * @param {TrackEndEvent} payload - The event payload containing additional data about the track end event.
-     * @returns {Promise<void>} A promise that resolves when the queue end processing is complete.
+     * The session id of the voice connection
      */
-    queueEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
+    sessionId: string;
     /**
-     * Fetches the lyrics of a track from the Lavalink node.
-     * This method uses the `lavalyrics-plugin` to fetch the lyrics.
-     * If the plugin is not available, it will throw a RangeError.
-     *
-     * @param {Track} track - The track to fetch the lyrics for.
-     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @returns {Promise<Lyrics>} A promise that resolves with the lyrics data.
+     * Event data
      */
-    getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics>;
+    event: VoiceServerUpdate;
+}
+/**
+ * Voice Server Update
+ */
+interface VoiceServerUpdate {
     /**
-     * Handles the event when a track becomes stuck during playback.
-     * Stops the current track and emits a `trackStuck` event.
-     *
-     * @param {Player} player - The player associated with the track that became stuck.
-     * @param {Track} track - The track that became stuck.
-     * @param {TrackStuckEvent} payload - The event payload containing additional data about the track stuck event.
-     * @returns {void}
-     * @protected
+     * The token for the session
      */
-    protected trackStuck(player: Player, track: Track, payload: TrackStuckEvent): Promise<void>;
+    token: string;
     /**
-     * Handles the event when a track has an error during playback.
-     * Stops the current track and emits a `trackError` event.
-     *
-     * @param {Player} player - The player associated with the track that had an error.
-     * @param {Track} track - The track that had an error.
-     * @param {TrackExceptionEvent} payload - The event payload containing additional data about the track error event.
-     * @returns {void}
-     * @protected
+     * Guild if of the voice connection
      */
-    protected trackError(player: Player, track: Track, payload: TrackExceptionEvent): Promise<void>;
+    guild_id: string;
     /**
-     * Emitted when the WebSocket connection for a player closes.
-     * The payload of the event will contain the close code and reason if provided.
-     * @param {Player} player - The player associated with the WebSocket connection.
-     * @param {WebSocketClosedEvent} payload - The event payload containing additional data about the WebSocket close event.
+     * The endpoint lavalink will connect to
      */
-    protected socketClosed(player: Player, payload: WebSocketClosedEvent): void;
-    /**
-     * Emitted when the segments for a track are loaded.
-     * The payload of the event will contain the segments.
-     * @param {Player} player - The player associated with the segments.
-     * @param {Track} track - The track associated with the segments.
-     * @param {SponsorBlockSegmentsLoaded} payload - The event payload containing additional data about the segments loaded event.
-     */
-    private sponsorBlockSegmentLoaded;
-    /**
-     * Emitted when a segment of a track is skipped using the sponsorblock plugin.
-     * The payload of the event will contain the skipped segment.
-     * @param {Player} player - The player associated with the skipped segment.
-     * @param {Track} track - The track associated with the skipped segment.
-     * @param {SponsorBlockSegmentSkipped} payload - The event payload containing additional data about the segment skipped event.
-     */
-    private sponsorBlockSegmentSkipped;
-    /**
-     * Emitted when chapters for a track are loaded using the sponsorblock plugin.
-     * The payload of the event will contain the chapters.
-     * @param {Player} player - The player associated with the chapters.
-     * @param {Track} track - The track associated with the chapters.
-     * @param {SponsorBlockChaptersLoaded} payload - The event payload containing additional data about the chapters loaded event.
-     */
-    private sponsorBlockChaptersLoaded;
-    /**
-     * Emitted when a chapter of a track is started using the sponsorblock plugin.
-     * The payload of the event will contain the started chapter.
-     * @param {Player} player - The player associated with the started chapter.
-     * @param {Track} track - The track associated with the started chapter.
-     * @param {SponsorBlockChapterStarted} payload - The event payload containing additional data about the chapter started event.
-     */
-    private sponsorBlockChapterStarted;
-    /**
-     * Fetches Lavalink node information.
-     * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.
-     */
-    fetchInfo(): Promise<LavalinkInfo>;
-    /**
-     * Gets the current sponsorblock segments for a player.
-     * @param {Player} player - The player to get the sponsorblocks for.
-     * @returns {Promise<SponsorBlockSegment[]>} A promise that resolves to the sponsorblock segments.
-     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
-     */
-    getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
-    /**
-     * Sets the sponsorblock segments for a player.
-     * @param {Player} player - The player to set the sponsor blocks for.
-     * @param {SponsorBlockSegment[]} segments - The sponsorblock segments to set. Defaults to `[SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]` if not provided.
-     * @returns {Promise<void>} The promise is resolved when the operation is complete.
-     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
-     * @throws {RangeError} If no segments are provided.
-     * @throws {SyntaxError} If an invalid sponsorblock is provided.
-     * @example
-     * ```ts
-     * // use it on the player via player.setSponsorBlock();
-     * player.setSponsorBlock([SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]);
-     * ```
-     */
-    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
-    /**
-     * Deletes the sponsorblock segments for a player.
-     * @param {Player} player - The player to delete the sponsorblocks for.
-     * @returns {Promise<void>} The promise is resolved when the operation is complete.
-     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
-     */
-    deleteSponsorBlock(player: Player): Promise<void>;
-    /**
-     * Creates a README.md or README.txt file in the magmastream directory
-     * if it doesn't already exist. This file is used to store player data
-     * for autoresume and other features.
-     * @private
-     */
-    private createReadmeFile;
+    endpoint: string;
 }
-interface NodeOptions {
-    /** The host for the node. */
+/**
+ * Redis Configuration
+ */
+interface RedisConfig {
     host: string;
-    /** The port for the node. */
-    port?: number;
-    /** The password for the node. */
+    port: string;
     password?: string;
-    /** Whether the host uses SSL. */
-    useSSL?: boolean;
-    /** The identifier for the node. */
-    identifier?: string;
-    /** The maxRetryAttempts for the node. */
-    maxRetryAttempts?: number;
-    /** The retryDelayMs for the node. */
-    retryDelayMs?: number;
-    /** Whether to resume the previous session. */
-    enableSessionResumeOption?: boolean;
-    /** The time the lavalink server will wait before it removes the player. */
-    sessionTimeoutMs?: number;
-    /** The timeout used for api calls. */
-    apiRequestTimeoutMs?: number;
-    /** Priority of the node. */
-    nodePriority?: number;
+    db?: number;
+    prefix?: string;
 }
-interface NodeStats {
-    /** The amount of players on the node. */
-    players: number;
-    /** The amount of playing players on the node. */
-    playingPlayers: number;
-    /** The uptime for the node. */
-    uptime: number;
-    /** The memory stats for the node. */
-    memory: MemoryStats;
-    /** The cpu stats for the node. */
-    cpu: CPUStats;
-    /** The frame stats for the node. */
-    frameStats: FrameStats;
+/**
+ * Player State Update Event
+ */
+interface PlayerStateUpdateEvent {
+    changeType: PlayerStateEventTypes;
+    details?: AutoplayChangeEvent | ConnectionChangeEvent | RepeatChangeEvent | PauseChangeEvent | QueueChangeEvent | TrackChangeEvent | VolumeChangeEvent | ChannelChangeEvent;
 }
-interface MemoryStats {
-    /** The free memory of the allocated amount. */
-    free: number;
-    /** The used memory of the allocated amount. */
-    used: number;
-    /** The total allocated memory. */
-    allocated: number;
-    /** The reservable memory. */
-    reservable: number;
+/**
+ * Autoplay Change Event
+ */
+interface AutoplayChangeEvent {
+    previousAutoplay: boolean;
+    currentAutoplay: boolean;
 }
-interface CPUStats {
-    /** The core amount the host machine has. */
-    cores: number;
-    /** The system load. */
-    systemLoad: number;
-    /** The lavalink load. */
-    lavalinkLoad: number;
+/**
+ * Connection Change Event
+ */
+interface ConnectionChangeEvent {
+    changeType: "connect" | "disconnect";
+    previousConnection: boolean;
+    currentConnection: boolean;
 }
-interface FrameStats {
-    /** The amount of sent frames. */
-    sent?: number;
-    /** The amount of nulled frames. */
-    nulled?: number;
-    /** The amount of deficit frames. */
-    deficit?: number;
+/**
+ * Repeat Change Event
+ */
+interface RepeatChangeEvent {
+    changeType: "dynamic" | "track" | "queue" | null;
+    previousRepeat: string | null;
+    currentRepeat: string | null;
 }
-interface LavalinkInfo {
-    version: {
-        semver: string;
-        major: number;
-        minor: number;
-        patch: number;
-        preRelease: string;
-    };
-    buildTime: number;
-    git: {
-        branch: string;
-        commit: string;
-        commitTime: number;
-    };
-    jvm: string;
-    lavaplayer: string;
-    sourceManagers: string[];
-    filters: string[];
-    plugins: {
-        name: string;
-        version: string;
-    }[];
+/**
+ * Pause Change Event
+ */
+interface PauseChangeEvent {
+    previousPause: boolean | null;
+    currentPause: boolean | null;
 }
-interface LyricsLine {
-    timestamp: number;
-    duration: number;
-    line: string;
-    plugin: object;
+/**
+ * Queue Change Event
+ */
+interface QueueChangeEvent {
+    changeType: "add" | "remove" | "clear" | "shuffle" | "roundRobin" | "userBlock" | "autoPlayAdd";
+    tracks?: Track[];
 }
-interface Lyrics {
-    source: string;
-    provider: string;
-    text?: string;
-    lines: LyricsLine[];
-    plugin: object[];
+/**
+ * Track Change Event
+ */
+interface TrackChangeEvent {
+    changeType: "start" | "end" | "previous" | "timeUpdate" | "autoPlay";
+    track: Track;
+    previousTime?: number | null;
+    currentTime?: number | null;
 }
-
 /**
- * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ * Volume Change Event
  */
-declare class Queue extends Array<Track> implements IQueue {
-    /** The current track */
-    current: Track | null;
-    /** The previous tracks */
-    previous: Track[];
-    /** The Manager instance. */
-    manager: Manager;
-    /** The guild ID property. */
-    guildId: string;
-    /**
-     * Constructs a new Queue.
-     * @param guildId The guild ID.
-     * @param manager The Manager instance.
-     */
-    constructor(guildId: string, manager: Manager);
-    getCurrent(): Promise<Track | null>;
-    setCurrent(track: Track | null): Promise<void>;
-    getPrevious(): Promise<Track[]>;
-    addPrevious(track: Track | Track[]): Promise<void>;
-    setPrevious(tracks: Track[]): Promise<void>;
-    popPrevious(): Promise<Track | null>;
-    clearPrevious(): Promise<void>;
-    /**
-     * The total duration of the queue in milliseconds.
-     * This includes the duration of the currently playing track.
-     */
-    duration(): Promise<number>;
-    /**
-     * The total size of tracks in the queue including the current track.
-     * This includes the current track if it is not null.
-     * @returns The total size of tracks in the queue including the current track.
-     */
-    totalSize(): Promise<number>;
-    /**
-     * The size of tracks in the queue.
-     * This does not include the currently playing track.
-     * @returns The size of tracks in the queue.
-     */
-    size(): Promise<number>;
-    /**
-     * Adds a track to the queue.
-     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
-     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
-     */
-    add(track: Track | Track[], offset?: number): Promise<void>;
-    /**
-     * Removes track(s) from the queue.
-     * @param startOrPosition If a single number is provided, it will be treated as the position of the track to remove.
-     *                         If two numbers are provided, they will be used as the start and end of a range of tracks to remove.
-     * @param end Optional, end of the range of tracks to remove.
-     * @returns The removed track(s).
-     */
-    remove(position?: number): Promise<Track[]>;
-    remove(start: number, end: number): Promise<Track[]>;
-    /**
-     * Clears the queue.
-     * This will remove all tracks from the queue and emit a state update event.
-     */
-    clear(): Promise<void>;
-    /**
-     * Shuffles the queue.
-     * This will randomize the order of the tracks in the queue and emit a state update event.
-     */
-    shuffle(): Promise<void>;
-    /**
-     * Shuffles the queue to play tracks requested by each user one block at a time.
-     */
-    userBlockShuffle(): Promise<void>;
-    /**
-     * Shuffles the queue to play tracks requested by each user one by one.
-     */
-    roundRobinShuffle(): Promise<void>;
-    dequeue(): Promise<Track | undefined>;
-    enqueueFront(track: Track | Track[]): Promise<void>;
-    getTracks(): Promise<Track[]>;
-    getSlice(start?: number, end?: number): Promise<Track[]>;
-    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
-}
-
-declare abstract class TrackUtils {
-    static trackPartial: TrackPartial[] | null;
-    private static manager;
-    /**
-     * Initializes the TrackUtils class with the given manager.
-     * @param manager The manager instance to use.
-     * @hidden
-     */
-    static init(manager: Manager): void;
-    /**
-     * Sets the partial properties for the Track class. If a Track has some of its properties removed by the partial,
-     * it will be considered a partial Track.
-     * @param {TrackPartial} partial The array of string property names to remove from the Track class.
-     */
-    static setTrackPartial(partial: TrackPartial[]): void;
-    /**
-     * Checks if the provided argument is a valid Track.
-     * If provided an array then every element will be checked.
-     * @param trackOrTracks The Track or array of Tracks to check.
-     * @returns {boolean} Whether the provided argument is a valid Track.
-     */
-    static validate(trackOrTracks: unknown): boolean;
-    /**
-     * Builds a Track from the raw data from Lavalink and a optional requester.
-     * @param data The raw data from Lavalink to build the Track from.
-     * @param requester The user who requested the track, if any.
-     * @returns The built Track.
-     */
-    static build<T = User | ClientUser>(data: TrackData, requester?: T): Track;
-}
-declare abstract class AutoPlayUtils {
-    private static manager;
-    /**
-     * Initializes the AutoPlayUtils class with the given manager.
-     * @param manager The manager instance to use.
-     * @hidden
-     */
-    static init(manager: Manager): void;
-    /**
-     * Gets recommended tracks for the given track.
-     * @param track The track to get recommended tracks for.
-     * @returns An array of recommended tracks.
-     */
-    static getRecommendedTracks(track: Track): Promise<Track[]>;
-    /**
-     * Gets recommended tracks from Last.fm for the given track.
-     * @param track The track to get recommended tracks for.
-     * @param apiKey The API key for Last.fm.
-     * @returns An array of recommended tracks.
-     */
-    static getRecommendedTracksFromLastFm(track: Track, apiKey: string): Promise<Track[]>;
-    /**
-     * Gets recommended tracks from the given source.
-     * @param track The track to get recommended tracks for.
-     * @param platform The source to get recommended tracks from.
-     * @returns An array of recommended tracks.
-     */
-    static getRecommendedTracksFromSource(track: Track, platform: string): Promise<Track[]>;
+interface VolumeChangeEvent {
+    previousVolume: number | null;
+    currentVolume: number | null;
 }
-/** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
-declare abstract class Structure {
-    /**
-     * Extends a class.
-     * @param name
-     * @param extender
-     */
-    static extend<K extends keyof Extendable, T extends Extendable[K]>(name: K, extender: (target: Extendable[K]) => T): T;
-    /**
-     * Get a structure from available structures by name.
-     * @param name
-     */
-    static get<K extends keyof Extendable>(name: K): Extendable[K];
+/**
+ * Channel Change Event
+ */
+interface ChannelChangeEvent {
+    changeType: "text" | "voice";
+    previousChannel: string | null;
+    currentChannel: string | null;
 }
-type Sizes = "0" | "1" | "2" | "3" | "default" | "mqdefault" | "hqdefault" | "maxresdefault";
-declare enum LoadTypes {
-    Track = "track",
-    Playlist = "playlist",
-    Search = "search",
-    Empty = "empty",
-    Error = "error"
+/**
+ * Track
+ */
+interface Track {
+    /** The base64 encoded track. */
+    readonly track: string;
+    /** The artwork url of the track. */
+    readonly artworkUrl: string;
+    /** The track source name. */
+    readonly sourceName: TrackSourceName;
+    /** The title of the track. */
+    title: string;
+    /** The identifier of the track. */
+    readonly identifier: string;
+    /** The author of the track. */
+    author: string;
+    /** The duration of the track. */
+    readonly duration: number;
+    /** The ISRC of the track. */
+    readonly isrc: string;
+    /** If the track is seekable. */
+    readonly isSeekable: boolean;
+    /** If the track is a stream.. */
+    readonly isStream: boolean;
+    /** The uri of the track. */
+    readonly uri: string;
+    /** The thumbnail of the track or null if it's a unsupported source. */
+    readonly thumbnail: string | null;
+    /** The user that requested the track. */
+    requester?: User | ClientUser;
+    /** Displays the track thumbnail with optional size or null if it's a unsupported source. */
+    displayThumbnail(size?: Sizes): string;
+    /** Additional track info provided by plugins. */
+    pluginInfo: TrackPluginInfo;
+    /** Add your own data to the track. */
+    customData: Record<string, unknown>;
 }
-type LoadType = keyof typeof LoadTypes;
-declare enum StateTypes {
-    Connected = "CONNECTED",
-    Connecting = "CONNECTING",
-    Disconnected = "DISCONNECTED",
-    Disconnecting = "DISCONNECTING",
-    Destroying = "DESTROYING"
+/**
+ * Track Plugin Info
+ */
+interface TrackPluginInfo {
+    albumName?: string;
+    albumUrl?: string;
+    artistArtworkUrl?: string;
+    artistUrl?: string;
+    isPreview?: string;
+    previewUrl?: string;
 }
-type State = keyof typeof StateTypes;
-type SponsorBlockSegmentEvents = SponsorBlockSegmentSkipped | SponsorBlockSegmentsLoaded | SponsorBlockChapterStarted | SponsorBlockChaptersLoaded;
-type SponsorBlockSegmentEventType = "SegmentSkipped" | "SegmentsLoaded" | "ChapterStarted" | "ChaptersLoaded";
-type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents;
-type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted";
-declare enum TrackEndReasonTypes {
-    Finished = "finished",
-    LoadFailed = "loadFailed",
-    Stopped = "stopped",
-    Replaced = "replaced",
-    Cleanup = "cleanup"
+/**
+ * Search Query
+ */
+interface SearchQuery {
+    /** The source to search from. */
+    source?: SearchPlatform;
+    /** The query to search for. */
+    query: string;
 }
-type TrackEndReason = keyof typeof TrackEndReasonTypes;
-declare enum SeverityTypes {
-    Common = "common",
-    Suspicious = "suspicious",
-    Fault = "fault"
+/**
+ * Lavalink Response
+ */
+interface LavalinkResponse {
+    loadType: LoadTypes;
+    data: TrackData[] | PlaylistRawData;
 }
-type Severity = keyof typeof SeverityTypes;
+/**
+ * Track Data
+ */
 interface TrackData {
     /** The track information. */
     encoded: string;
@@ -774,6 +679,22 @@ interface TrackData {
     /** Additional track info provided by plugins. */
     pluginInfo: Record<string, string>;
 }
+/**
+ * Playlist Raw Data
+ */
+interface PlaylistRawData {
+    info: {
+        /** The playlist name. */
+        name: string;
+    };
+    /** Addition info provided by plugins. */
+    pluginInfo: object;
+    /** The tracks of the playlist */
+    tracks: TrackData[];
+}
+/**
+ * Track Data Info
+ */
 interface TrackDataInfo {
     identifier: string;
     isSeekable: boolean;
@@ -786,83 +707,205 @@ interface TrackDataInfo {
     artworkUrl?: string;
     sourceName?: TrackSourceName;
 }
-declare enum TrackSourceTypes {
-    AppleMusic = "applemusic",
-    Bandcamp = "bandcamp",
-    Deezer = "deezer",
-    Jiosaavn = "jiosaavn",
-    SoundCloud = "soundcloud",
-    Spotify = "spotify",
-    Tidal = "tidal",
-    VKMusic = "vkmusic",
-    YouTube = "youtube"
-}
-type TrackSourceName = keyof typeof TrackSourceTypes;
-interface Extendable {
-    Player: typeof Player;
-    Queue: typeof Queue;
-    Node: typeof Node;
-}
-interface VoiceServer {
-    token: string;
-    guild_id: string;
-    endpoint: string;
-}
-interface VoiceState {
-    op: "voiceUpdate";
+/**
+ * LavaPlayer
+ */
+interface LavaPlayer {
     guildId: string;
-    event: VoiceServer;
-    sessionId?: string;
-}
-interface VoiceState {
-    guild_id: string;
-    user_id: string;
-    session_id: string;
-    channel_id: string;
+    track: TrackData;
+    volume: number;
+    paused: boolean;
+    state: {
+        time: number;
+        position: number;
+        connected: boolean;
+        ping: number;
+    };
+    voice: {
+        token: string;
+        endpoint: string;
+        sessionId: string;
+    };
+    filters: Record<string, unknown>;
+}
+/**
+ * Search Result
+ */
+interface SearchResult {
+    /** The load type of the result. */
+    loadType: LoadTypes;
+    /** The array of tracks from the result. */
+    tracks: Track[];
+    /** The playlist info if the load type is 'playlist'. */
+    playlist?: PlaylistData;
+}
+/**
+ * Playlist Data
+ */
+interface PlaylistData {
+    /** The playlist name. */
+    name: string;
+    /** Requester of playlist. */
+    requester: User | ClientUser;
+    /** More playlist information. */
+    playlistInfo: PlaylistInfoData[];
+    /** The length of the playlist. */
+    duration: number;
+    /** The songs of the playlist. */
+    tracks: Track[];
+}
+/**
+ * Playlist Info Data
+ */
+interface PlaylistInfoData {
+    /** Url to playlist. */
+    url: string;
+    /** Type is always playlist in that case. */
+    type: string;
+    /** ArtworkUrl of playlist */
+    artworkUrl: string;
+    /** Number of total tracks in playlist */
+    totalTracks: number;
+    /** Author of playlist */
+    author: string;
+}
+/**
+ * Manager Events
+ */
+interface ManagerEvents {
+    [ManagerEventTypes.ChapterStarted]: [player: Player, track: Track, payload: SponsorBlockChapterStarted];
+    [ManagerEventTypes.ChaptersLoaded]: [player: Player, track: Track, payload: SponsorBlockChaptersLoaded];
+    [ManagerEventTypes.Debug]: [info: string];
+    [ManagerEventTypes.NodeConnect]: [node: Node];
+    [ManagerEventTypes.NodeCreate]: [node: Node];
+    [ManagerEventTypes.NodeDestroy]: [node: Node];
+    [ManagerEventTypes.NodeDisconnect]: [node: Node, reason: {
+        code?: number;
+        reason?: string;
+    }];
+    [ManagerEventTypes.NodeError]: [node: Node, error: Error];
+    [ManagerEventTypes.NodeRaw]: [payload: unknown];
+    [ManagerEventTypes.NodeReconnect]: [node: Node];
+    [ManagerEventTypes.PlayerCreate]: [player: Player];
+    [ManagerEventTypes.PlayerDestroy]: [player: Player];
+    [ManagerEventTypes.PlayerDisconnect]: [player: Player, oldChannel: string];
+    [ManagerEventTypes.PlayerMove]: [player: Player, initChannel: string, newChannel: string];
+    [ManagerEventTypes.PlayerRestored]: [player: Player, node: Node];
+    [ManagerEventTypes.PlayerStateUpdate]: [oldPlayer: Player, newPlayer: Player, changeType: PlayerStateUpdateEvent];
+    [ManagerEventTypes.QueueEnd]: [player: Player, track: Track, payload: TrackEndEvent];
+    [ManagerEventTypes.RestoreComplete]: [node: Node];
+    [ManagerEventTypes.SegmentSkipped]: [player: Player, track: Track, payload: SponsorBlockSegmentSkipped];
+    [ManagerEventTypes.SegmentsLoaded]: [player: Player, track: Track, payload: SponsorBlockSegmentsLoaded];
+    [ManagerEventTypes.SocketClosed]: [player: Player, payload: WebSocketClosedEvent];
+    [ManagerEventTypes.TrackEnd]: [player: Player, track: Track, payload: TrackEndEvent];
+    [ManagerEventTypes.TrackError]: [player: Player, track: Track, payload: TrackExceptionEvent];
+    [ManagerEventTypes.TrackStart]: [player: Player, track: Track, payload: TrackStartEvent];
+    [ManagerEventTypes.TrackStuck]: [player: Player, track: Track, payload: TrackStuckEvent];
 }
+/**
+ * Voice Packet
+ */
 interface VoicePacket {
     t?: "VOICE_SERVER_UPDATE" | "VOICE_STATE_UPDATE";
     d: VoiceState | VoiceServer;
 }
+/**
+ * Voice Server
+ */
+interface VoiceServer {
+    token: string;
+    guild_id: string;
+    endpoint: string;
+}
+interface Extendable {
+    Player: typeof Player;
+    Queue: typeof Queue;
+    Node: typeof Node;
+}
+/**
+ * Voice State
+ */
+interface VoiceState {
+    op: "voiceUpdate";
+    guildId: string;
+    event: VoiceServer;
+    sessionId?: string;
+}
+/**
+ * Voice State
+ */
+interface VoiceState {
+    guild_id: string;
+    user_id: string;
+    session_id: string;
+    channel_id: string;
+}
+/**
+ * Node Message
+ */
 interface NodeMessage extends NodeStats {
     type: PlayerEventType;
     op: "stats" | "playerUpdate" | "event";
     guildId: string;
 }
+/**
+ * PlayerEvent interface
+ */
 interface PlayerEvent {
     op: "event";
     type: PlayerEventType;
     guildId: string;
 }
+/**
+ * Exception interface
+ */
 interface Exception {
     message: string;
     severity: SeverityTypes;
     cause: string;
 }
+/**
+ * TrackStartEvent interface
+ */
 interface TrackStartEvent extends PlayerEvent {
     type: "TrackStartEvent";
     track: TrackData;
 }
+/**
+ * TrackEndEvent interface
+ */
 interface TrackEndEvent extends PlayerEvent {
     type: "TrackEndEvent";
     track: TrackData;
     reason: TrackEndReasonTypes;
 }
+/**
+ * TrackExceptionEvent interface
+ */
 interface TrackExceptionEvent extends PlayerEvent {
     exception?: Exception;
     guildId: string;
     type: "TrackExceptionEvent";
 }
+/**
+ * TrackStuckEvent interface
+ */
 interface TrackStuckEvent extends PlayerEvent {
     type: "TrackStuckEvent";
     thresholdMs: number;
 }
+/**
+ * WebSocketClosedEvent interface
+ */
 interface WebSocketClosedEvent extends PlayerEvent {
     type: "WebSocketClosedEvent";
     code: number;
     reason: string;
     byRemote: boolean;
 }
+/**
+ * SponsorBlockSegmentsLoaded interface
+ */
 interface SponsorBlockSegmentsLoaded extends PlayerEvent {
     type: "SegmentsLoaded";
     segments: {
@@ -871,6 +914,9 @@ interface SponsorBlockSegmentsLoaded extends PlayerEvent {
         end: number;
     }[];
 }
+/**
+ * SponsorBlockSegmentSkipped interface
+ */
 interface SponsorBlockSegmentSkipped extends PlayerEvent {
     type: "SegmentSkipped";
     segment: {
@@ -879,6 +925,9 @@ interface SponsorBlockSegmentSkipped extends PlayerEvent {
         end: number;
     };
 }
+/**
+ * SponsorBlockChapterStarted interface
+ */
 interface SponsorBlockChapterStarted extends PlayerEvent {
     type: "ChapterStarted";
     /** The chapter which started */
@@ -890,6 +939,9 @@ interface SponsorBlockChapterStarted extends PlayerEvent {
         duration: number;
     };
 }
+/**
+ * SponsorBlockChaptersLoaded interface
+ */
 interface SponsorBlockChaptersLoaded extends PlayerEvent {
     type: "ChaptersLoaded";
     /** All chapters loaded */
@@ -901,6 +953,9 @@ interface SponsorBlockChaptersLoaded extends PlayerEvent {
         duration: number;
     }[];
 }
+/**
+ * PlayerUpdate interface
+ */
 interface PlayerUpdate {
     op: "playerUpdate";
     /** The guild id of the player. */
@@ -916,576 +971,869 @@ interface PlayerUpdate {
         ping: number;
     };
 }
-interface IQueue {
-    getCurrent(): Promise<Track | null>;
-    setCurrent(track: Track | null): Promise<void>;
-    getPrevious(): Promise<Track[]>;
-    addPrevious(track: Track | Track[]): Promise<void>;
-    setPrevious(track: Track | Track[]): Promise<void>;
-    /** Get newest track (index 0) */
-    popPrevious(): Promise<Track | null>;
-    clearPrevious(): Promise<void>;
-    size(): Promise<number>;
-    totalSize(): Promise<number>;
-    duration(): Promise<number>;
-    add(track: Track | Track[], offset?: number): Promise<void>;
-    remove(start?: number, end?: number): Promise<Track[]>;
-    clear(): Promise<void>;
-    dequeue(): Promise<Track | undefined>;
-    enqueueFront(track: Track | Track[]): Promise<void>;
-    getTracks(): Promise<Track[]>;
-    getSlice(start?: number, end?: number): Promise<Track[]>;
-    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
-    shuffle(): Promise<void>;
-    userBlockShuffle(): Promise<void>;
-    roundRobinShuffle(): Promise<void>;
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+/**
+ * Node Options
+ */
+interface NodeOptions {
+    /** The host for the node. */
+    host: string;
+    /** The port for the node. */
+    port?: number;
+    /** The password for the node. */
+    password?: string;
+    /** Whether the host uses SSL. */
+    useSSL?: boolean;
+    /** The identifier for the node. */
+    identifier?: string;
+    /** The maxRetryAttempts for the node. */
+    maxRetryAttempts?: number;
+    /** The retryDelayMs for the node. */
+    retryDelayMs?: number;
+    /** Whether to resume the previous session. */
+    enableSessionResumeOption?: boolean;
+    /** The time the lavalink server will wait before it removes the player. */
+    sessionTimeoutMs?: number;
+    /** The timeout used for api calls. */
+    apiRequestTimeoutMs?: number;
+    /** Priority of the node. */
+    nodePriority?: number;
 }
-
 /**
- * The main hub for interacting with Lavalink and using Magmastream,
+ * NodeOptions interface
  */
-declare class Manager extends EventEmitter {
-    /** The map of players. */
-    readonly players: Collection<string, Player>;
-    /** The map of nodes. */
-    readonly nodes: Collection<string, Node>;
-    /** The options that were set. */
-    readonly options: ManagerOptions;
-    initiated: boolean;
-    redis?: Redis;
-    /**
-     * Initiates the Manager class.
-     * @param options
-     * @param options.enabledPlugins - An array of enabledPlugins to load.
-     * @param options.nodes - An array of node options to create nodes from.
-     * @param options.playNextOnEnd - Whether to automatically play the first track in the queue when the player is created.
-     * @param options.autoPlaySearchPlatforms - The search platform autoplay will use. Fallback to Youtube if not found.
-     * @param options.enablePriorityMode - Whether to use the priority when selecting a node to play on.
-     * @param options.clientName - The name of the client to send to Lavalink.
-     * @param options.defaultSearchPlatform - The default search platform to use when searching for tracks.
-     * @param options.useNode - The strategy to use when selecting a node to play on.
-     * @param options.trackPartial - The partial track search results to use when searching for tracks. This partials will always be presented on each track.
-     * @param options.eventBatchDuration - The duration to wait before processing the collected player state events.
-     * @param options.eventBatchInterval - The interval to wait before processing the collected player state events.
-     */
-    constructor(options: ManagerOptions);
-    /**
-     * Initiates the Manager.
-     * @param clientId - The Discord client ID (required).
-     * @param clusterId - The cluster ID which runs the current process (required).
-     * @returns The manager instance.
-     */
-    init(clientId: string, clusterId?: number): this;
-    /**
-     * Searches the enabled sources based off the URL or the `source` property.
-     * @param query
-     * @param requester
-     * @returns The search result.
-     */
-    search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
-    /**
-     * Returns a player or undefined if it does not exist.
-     * @param guildId The guild ID of the player to retrieve.
-     * @returns The player if it exists, undefined otherwise.
-     */
-    getPlayer(guildId: string): Player | undefined;
-    /**
-     * @deprecated - Will be removed with v2.10.0 use {@link getPlayer} instead
-     * Returns a player or undefined if it does not exist.
-     * @param guildId The guild ID of the player to retrieve.
-     * @returns The player if it exists, undefined otherwise.
-     */
-    get(guildId: string): Promise<Player | undefined>;
-    /**
-     * Creates a player or returns one if it already exists.
-     * @param options The options to create the player with.
-     * @returns The created player.
-     */
-    create(options: PlayerOptions): Player;
-    /**
-     * Destroys a player.
-     * @param guildId The guild ID of the player to destroy.
-     * @returns A promise that resolves when the player has been destroyed.
-     */
-    destroy(guildId: string): Promise<void>;
-    /**
-     * Creates a new node or returns an existing one if it already exists.
-     * @param options - The options to create the node with.
-     * @returns The created node.
-     */
-    createNode(options: NodeOptions): Node;
-    /**
-     * Destroys a node if it exists. Emits a debug event if the node is found and destroyed.
-     * @param identifier - The identifier of the node to destroy.
-     * @returns {void}
-     * @emits {debug} - Emits a debug message indicating the node is being destroyed.
-     */
-    destroyNode(identifier: string): Promise<void>;
-    /**
-     * Attaches an event listener to the manager.
-     * @param event The event to listen for.
-     * @param listener The function to call when the event is emitted.
-     * @returns The manager instance for chaining.
-     */
-    on<T extends keyof ManagerEvents>(event: T, listener: (...args: ManagerEvents[T]) => void): this;
-    /**
-     * Updates the voice state of a player based on the provided data.
-     * @param data - The data containing voice state information, which can be a VoicePacket, VoiceServer, or VoiceState.
-     * @returns A promise that resolves when the voice state update is handled.
-     * @emits {debug} - Emits a debug message indicating the voice state is being updated.
-     */
-    updateVoiceState(data: VoicePacket | VoiceServer | VoiceState): Promise<void>;
-    /**
-     * Decodes an array of base64 encoded tracks and returns an array of TrackData.
-     * Emits a debug event with the tracks being decoded.
-     * @param tracks - An array of base64 encoded track strings.
-     * @returns A promise that resolves to an array of TrackData objects.
-     * @throws Will throw an error if no nodes are available or if the API request fails.
-     */
-    decodeTracks(tracks: string[]): Promise<TrackData[]>;
-    /**
-     * Decodes a base64 encoded track and returns a TrackData.
-     * @param track - The base64 encoded track string.
-     * @returns A promise that resolves to a TrackData object.
-     * @throws Will throw an error if no nodes are available or if the API request fails.
-     */
-    decodeTrack(track: string): Promise<TrackData>;
-    /**
-     * Saves player states to the JSON file.
-     * @param {string} guildId - The guild ID of the player to save
-     */
-    savePlayerState(guildId: string): Promise<void>;
-    /**
-     * Sleeps for a specified amount of time.
-     * @param ms The amount of time to sleep in milliseconds.
-     * @returns A promise that resolves after the specified amount of time.
-     */
-    private sleep;
-    /**
-     * Loads player states from the JSON file.
-     * @param nodeId The ID of the node to load player states from.
-     * @returns A promise that resolves when the player states have been loaded.
-     */
-    loadPlayerStates(nodeId: string): Promise<void>;
-    /**
-     * Returns the node to use based on the configured `useNode` and `enablePriorityMode` options.
-     * If `enablePriorityMode` is true, the node is chosen based on priority, otherwise it is chosen based on the `useNode` option.
-     * If `useNode` is "leastLoad", the node with the lowest load is chosen, if it is "leastPlayers", the node with the fewest players is chosen.
-     * If `enablePriorityMode` is false and `useNode` is not set, the node with the lowest load is chosen.
-     * @returns {Node} The node to use.
-     */
-    get useableNode(): Node;
-    /**
-     * Handles the shutdown of the process by saving all active players' states and optionally cleaning up inactive players.
-     * This function is called when the process is about to exit.
-     * It iterates through all players and calls {@link savePlayerState} to save their states.
-     * Optionally, it also calls {@link cleanupInactivePlayers} to remove any stale player state files.
-     * After saving and cleaning up, it exits the process.
-     */
-    handleShutdown(): Promise<void>;
-    /**
-     * Parses a YouTube title into a clean title and author.
-     * @param title - The original title of the YouTube video.
-     * @param originalAuthor - The original author of the YouTube video.
-     * @returns An object with the clean title and author.
-     */
-    private parseYouTubeTitle;
-    /**
-     * Balances brackets in a given string by ensuring all opened brackets are closed correctly.
-     * @param str - The input string that may contain unbalanced brackets.
-     * @returns A new string with balanced brackets.
-     */
-    private balanceBrackets;
-    /**
-     * Escapes a string by replacing special regex characters with their escaped counterparts.
-     * @param string - The string to escape.
-     * @returns The escaped string.
-     */
-    private escapeRegExp;
-    /**
-     * Checks if the given data is a voice update.
-     * @param data The data to check.
-     * @returns Whether the data is a voice update.
-     */
-    private isVoiceUpdate;
-    /**
-     * Determines if the provided update is a valid voice update.
-     * A valid update must contain either a token or a session_id.
-     *
-     * @param update - The voice update data to validate, which can be a VoicePacket, VoiceServer, or VoiceState.
-     * @returns {boolean} - True if the update is valid, otherwise false.
-     */
-    private isValidUpdate;
-    /**
-     * Handles a voice server update by updating the player's voice state and sending the voice state to the Lavalink node.
-     * @param player The player for which the voice state is being updated.
-     * @param update The voice server data received from Discord.
-     * @returns A promise that resolves when the voice state update is handled.
-     * @emits {debug} - Emits a debug message indicating the voice state is being updated.
-     */
-    private handleVoiceServerUpdate;
-    /**
-     * Handles a voice state update by updating the player's voice channel and session ID if provided, or by disconnecting and destroying the player if the channel ID is null.
-     * @param player The player for which the voice state is being updated.
-     * @param update The voice state data received from Discord.
-     * @emits {playerMove} - Emits a player move event if the channel ID is provided and the player is currently connected to a different voice channel.
-     * @emits {playerDisconnect} - Emits a player disconnect event if the channel ID is null.
-     */
-    private handleVoiceStateUpdate;
-    /**
-     * Gets each player's JSON file
-     * @param {string} guildId - The guild ID
-     * @returns {string} The path to the player's JSON file
-     */
-    private getPlayerFilePath;
-    /**
-     * Serializes a Player instance to avoid circular references.
-     * @param player The Player instance to serialize
-     * @returns The serialized Player instance
-     */
-    serializePlayer(player: Player): Record<string, unknown>;
-    /**
-     * Checks for players that are no longer active and deletes their saved state files.
-     * This is done to prevent stale state files from accumulating on the file system.
-     */
-    private cleanupInactivePlayers;
-    /**
-     * Returns the nodes that has the least load.
-     * The load is calculated by dividing the lavalink load by the number of cores.
-     * The result is multiplied by 100 to get a percentage.
-     * @returns {Collection<string, Node>}
-     */
-    private get leastLoadNode();
-    /**
-     * Returns the nodes that have the least amount of players.
-     * Filters out disconnected nodes and sorts the remaining nodes
-     * by the number of players in ascending order.
-     * @returns {Collection<string, Node>} A collection of nodes sorted by player count.
-     */
-    private get leastPlayersNode();
-    /**
-     * Returns a node based on priority.
-     * The nodes are sorted by priority in descending order, and then a random number
-     * between 0 and 1 is generated. The node that has a cumulative weight greater than or equal to the
-     * random number is returned.
-     * If no node has a cumulative weight greater than or equal to the random number, the node with the
-     * lowest load is returned.
-     * @returns {Node} The node to use.
-     */
-    private get priorityNode();
-}
-interface Payload {
-    /** The OP code */
-    op: number;
-    d: {
-        guild_id: string;
-        channel_id: string | null;
-        self_mute: boolean;
-        self_deaf: boolean;
-    };
-}
-interface ManagerOptions {
-    /** The state storage options.
-     *
-     * @default { type: StateStorageType.Collection }
-     */
-    stateStorage?: StateStorageOptions;
-    /** Enable priority mode over least player count or load balancing? */
-    enablePriorityMode?: boolean;
-    /** Automatically play the next track when the current one ends. */
-    playNextOnEnd?: boolean;
-    /** An array of search platforms to use for autoplay. First to last matters
-     * Use enum `AutoPlayPlatform`.
-     */
-    autoPlaySearchPlatforms?: AutoPlayPlatform[];
-    /** The client ID to use. */
-    clientId?: string;
-    /** Value to use for the `Client-Name` header. */
-    clientName?: string;
-    /** The array of shard IDs connected to this manager instance. */
-    clusterId?: number;
-    /** List of plugins to load. */
-    enabledPlugins?: Plugin[];
-    /** The default search platform to use.
-     * Use enum `SearchPlatform`. */
-    defaultSearchPlatform?: SearchPlatform;
-    /** The last.fm API key.
-     * If you need to create one go here: https://www.last.fm/api/account/create.
-     * If you already have one, get it from here: https://www.last.fm/api/accounts. */
-    lastFmApiKey?: string;
-    /** The maximum number of previous tracks to store. */
-    maxPreviousTracks?: number;
-    /** The array of nodes to connect to. */
-    nodes?: NodeOptions[];
-    /** Whether the YouTube video titles should be replaced if the Author does not exactly match. */
-    normalizeYouTubeTitles?: boolean;
-    /** An array of track properties to keep. `track` will always be present. */
-    trackPartial?: TrackPartial[];
-    /** Use the least amount of players or least load? */
-    useNode?: UseNodeOptions.LeastLoad | UseNodeOptions.LeastPlayers;
-    /**
-     * Function to send data to the websocket.
-     * @param id The ID of the node to send the data to.
-     * @param payload The payload to send.
-     */
-    send(id: string, payload: Payload): void;
-}
-interface RedisConfig {
+interface NodeOptions {
+    /** The host for the node. */
     host: string;
-    port: string;
+    /** The port for the node. */
+    port?: number;
+    /** The password for the node. */
     password?: string;
-    db?: number;
-    prefix?: string;
-}
-declare enum StateStorageType {
-    Collection = "collection",
-    Redis = "redis"
-}
-interface StateStorageOptions {
-    type: StateStorageType;
-    redisConfig?: RedisConfig;
+    /** Whether the host uses SSL. */
+    useSSL?: boolean;
+    /** The identifier for the node. */
+    identifier?: string;
+    /** The maxRetryAttempts for the node. */
+    maxRetryAttempts?: number;
+    /** The retryDelayMs for the node. */
+    retryDelayMs?: number;
+    /** Whether to resume the previous session. */
+    enableSessionResumeOption?: boolean;
+    /** The time the lavalink server will wait before it removes the player. */
+    sessionTimeoutMs?: number;
+    /** The timeout used for api calls. */
+    apiRequestTimeoutMs?: number;
+    /** Priority of the node. */
+    nodePriority?: number;
 }
-declare enum TrackPartial {
-    /** The base64 encoded string of the track */
-    Track = "track",
-    /** The title of the track */
-    Title = "title",
-    /** The track identifier */
-    Identifier = "identifier",
-    /** The author of the track */
-    Author = "author",
-    /** The length of the track in milliseconds */
-    Duration = "duration",
-    /** The ISRC of the track */
-    Isrc = "isrc",
-    /** Whether the track is seekable */
-    IsSeekable = "isSeekable",
-    /** Whether the track is a stream */
-    IsStream = "isStream",
-    /** The URI of the track */
-    Uri = "uri",
-    /** The artwork URL of the track */
-    ArtworkUrl = "artworkUrl",
-    /** The source name of the track */
-    SourceName = "sourceName",
-    /** The thumbnail of the track */
-    ThumbNail = "thumbnail",
-    /** The requester of the track */
-    Requester = "requester",
-    /** The plugin info of the track */
-    PluginInfo = "pluginInfo",
-    /** The custom data of the track */
-    CustomData = "customData"
-}
-declare enum UseNodeOptions {
-    LeastLoad = "leastLoad",
-    LeastPlayers = "leastPlayers"
-}
-type UseNodeOption = keyof typeof UseNodeOptions;
-declare enum SearchPlatform {
-    AppleMusic = "amsearch",
-    Bandcamp = "bcsearch",
-    Deezer = "dzsearch",
-    Jiosaavn = "jssearch",
-    Qobuz = "qbsearch",
-    SoundCloud = "scsearch",
-    Spotify = "spsearch",
-    Tidal = "tdsearch",
-    VKMusic = "vksearch",
-    YouTube = "ytsearch",
-    YouTubeMusic = "ytmsearch"
-}
-declare enum AutoPlayPlatform {
-    Spotify = "spotify",
-    Deezer = "deezer",
-    SoundCloud = "soundcloud",
-    Tidal = "tidal",
-    VKMusic = "vkmusic",
-    Qobuz = "qobuz",
-    YouTube = "youtube"
+/**
+ * NodeStats interface
+ */
+interface NodeStats {
+    /** The amount of players on the node. */
+    players: number;
+    /** The amount of playing players on the node. */
+    playingPlayers: number;
+    /** The uptime for the node. */
+    uptime: number;
+    /** The memory stats for the node. */
+    memory: MemoryStats;
+    /** The cpu stats for the node. */
+    cpu: CPUStats;
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
 }
-declare enum PlayerStateEventTypes {
-    AutoPlayChange = "playerAutoplay",
-    ConnectionChange = "playerConnection",
-    RepeatChange = "playerRepeat",
-    PauseChange = "playerPause",
-    QueueChange = "queueChange",
-    TrackChange = "trackChange",
-    VolumeChange = "volumeChange",
-    ChannelChange = "channelChange",
-    PlayerCreate = "playerCreate",
-    PlayerDestroy = "playerDestroy"
+/**
+ * NodeStats interface
+ */
+interface NodeStats {
+    /** The amount of players on the node. */
+    players: number;
+    /** The amount of playing players on the node. */
+    playingPlayers: number;
+    /** The uptime for the node. */
+    uptime: number;
+    /** The memory stats for the node. */
+    memory: MemoryStats;
+    /** The cpu stats for the node. */
+    cpu: CPUStats;
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
 }
-interface PlayerStateUpdateEvent {
-    changeType: PlayerStateEventTypes;
-    details?: AutoplayChangeEvent | ConnectionChangeEvent | RepeatChangeEvent | PauseChangeEvent | QueueChangeEvent | TrackChangeEvent | VolumeChangeEvent | ChannelChangeEvent;
+/**
+ * MemoryStats interface
+ */
+interface MemoryStats {
+    /** The free memory of the allocated amount. */
+    free: number;
+    /** The used memory of the allocated amount. */
+    used: number;
+    /** The total allocated memory. */
+    allocated: number;
+    /** The reservable memory. */
+    reservable: number;
 }
-interface AutoplayChangeEvent {
-    previousAutoplay: boolean;
-    currentAutoplay: boolean;
+/**
+ * CPUStats interface
+ */
+interface CPUStats {
+    /** The core amount the host machine has. */
+    cores: number;
+    /** The system load. */
+    systemLoad: number;
+    /** The lavalink load. */
+    lavalinkLoad: number;
 }
-interface ConnectionChangeEvent {
-    changeType: "connect" | "disconnect";
-    previousConnection: boolean;
-    currentConnection: boolean;
+/**
+ * FrameStats interface
+ */
+interface FrameStats {
+    /** The amount of sent frames. */
+    sent?: number;
+    /** The amount of nulled frames. */
+    nulled?: number;
+    /** The amount of deficit frames. */
+    deficit?: number;
 }
-interface RepeatChangeEvent {
-    changeType: "dynamic" | "track" | "queue" | null;
-    previousRepeat: string | null;
-    currentRepeat: string | null;
+/**
+ * LavalinkInfo interface
+ */
+interface LavalinkInfo {
+    version: {
+        semver: string;
+        major: number;
+        minor: number;
+        patch: number;
+        preRelease: string;
+    };
+    buildTime: number;
+    git: {
+        branch: string;
+        commit: string;
+        commitTime: number;
+    };
+    jvm: string;
+    lavaplayer: string;
+    sourceManagers: string[];
+    filters: string[];
+    plugins: {
+        name: string;
+        version: string;
+    }[];
 }
-interface PauseChangeEvent {
-    previousPause: boolean | null;
-    currentPause: boolean | null;
+/**
+ * LyricsLine interface
+ */
+interface LyricsLine {
+    timestamp: number;
+    duration: number;
+    line: string;
+    plugin: object;
 }
-interface QueueChangeEvent {
-    changeType: "add" | "remove" | "clear" | "shuffle" | "roundRobin" | "userBlock" | "autoPlayAdd";
-    tracks?: Track[];
+/**
+ * Lyrics interface
+ */
+interface Lyrics {
+    source: string;
+    provider: string;
+    text?: string;
+    lines: LyricsLine[];
+    plugin: object[];
 }
-interface TrackChangeEvent {
-    changeType: "start" | "end" | "previous" | "timeUpdate" | "autoPlay";
-    track: Track;
-    previousTime?: number | null;
-    currentTime?: number | null;
+/**
+ * PlayerOptions interface
+ */
+interface PlayerOptions {
+    /** The guild ID the Player belongs to. */
+    guildId: string;
+    /** The text channel the Player belongs to. */
+    textChannelId: string;
+    /** The voice channel the Player belongs to. */
+    voiceChannelId?: string;
+    /** The node the Player uses. */
+    node?: string;
+    /** The initial volume the Player will use. */
+    volume?: number;
+    /** If the player should mute itself. */
+    selfMute?: boolean;
+    /** If the player should deaf itself. */
+    selfDeafen?: boolean;
 }
-interface VolumeChangeEvent {
-    previousVolume: number | null;
-    currentVolume: number | null;
+/**
+ * PlayOptions interface
+ */
+interface PlayOptions {
+    /** The position to start the track. */
+    readonly startTime?: number;
+    /** The position to end the track. */
+    readonly endTime?: number;
+    /** Whether to not replace the track if a play payload is sent. */
+    readonly noReplace?: boolean;
 }
-interface ChannelChangeEvent {
-    changeType: "text" | "voice";
-    previousChannel: string | null;
-    currentChannel: string | null;
+interface ManagerInitOptions {
+    clientId?: string;
+    clusterId?: number;
 }
-interface SearchQuery {
-    /** The source to search from. */
-    source?: SearchPlatform;
-    /** The query to search for. */
-    query: string;
+interface EqualizerBand {
+    /** The band number being 0 to 14. */
+    band: number;
+    /** The gain amount being -0.25 to 1.00, 0.25 being double. */
+    gain: number;
 }
-interface LavalinkResponse {
-    loadType: LoadTypes;
-    data: TrackData[] | PlaylistRawData;
+/**
+ * PlayerStore interface
+ */
+interface PlayerStore {
+    get(guildId: string): Promise<Player | undefined>;
+    set(guildId: string, player: Player): Promise<void>;
+    delete(guildId: string): Promise<void>;
+    keys(): Promise<string[]>;
+    has(guildId: string): Promise<boolean>;
+    filter(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Map<string, Player>>;
+    find(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Player | undefined>;
+    map<T>(callback: (player: Player, guildId: string) => T | Promise<T>): Promise<T[]>;
+    forEach(callback: (player: Player, guildId: string) => void | Promise<void>): Promise<void>;
+    some(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
+    every(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
+    size(): Promise<number>;
+    clear(): Promise<void>;
+    entries(): AsyncIterableIterator<[string, Player]>;
 }
-interface SearchResult {
-    /** The load type of the result. */
-    loadType: LoadTypes;
-    /** The array of tracks from the result. */
-    tracks: Track[];
-    /** The playlist info if the load type is 'playlist'. */
-    playlist?: PlaylistData;
-}
-interface PlaylistRawData {
-    info: {
-        /** The playlist name. */
-        name: string;
-    };
-    /** Addition info provided by plugins. */
-    pluginInfo: object;
-    /** The tracks of the playlist */
-    tracks: TrackData[];
-}
-interface PlaylistInfoData {
-    /** Url to playlist. */
-    url: string;
-    /** Type is always playlist in that case. */
-    type: string;
-    /** ArtworkUrl of playlist */
-    artworkUrl: string;
-    /** Number of total tracks in playlist */
-    totalTracks: number;
-    /** Author of playlist */
-    author: string;
-}
-interface PlaylistData {
-    /** The playlist name. */
-    name: string;
-    /** Requester of playlist. */
-    requester: User | ClientUser;
-    /** More playlist information. */
-    playlistInfo: PlaylistInfoData[];
-    /** The length of the playlist. */
-    duration: number;
-    /** The songs of the playlist. */
-    tracks: Track[];
-}
-declare enum ManagerEventTypes {
-    ChapterStarted = "chapterStarted",
-    ChaptersLoaded = "chaptersLoaded",
-    Debug = "debug",
-    NodeConnect = "nodeConnect",
-    NodeCreate = "nodeCreate",
-    NodeDestroy = "nodeDestroy",
-    NodeDisconnect = "nodeDisconnect",
-    NodeError = "nodeError",
-    NodeRaw = "nodeRaw",
-    NodeReconnect = "nodeReconnect",
-    PlayerCreate = "playerCreate",
-    PlayerDestroy = "playerDestroy",
-    PlayerDisconnect = "playerDisconnect",
-    PlayerMove = "playerMove",
-    PlayerRestored = "playerRestored",
-    PlayerStateUpdate = "playerStateUpdate",
-    QueueEnd = "queueEnd",
-    RestoreComplete = "restoreComplete",
-    SegmentSkipped = "segmentSkipped",
-    SegmentsLoaded = "segmentsLoaded",
-    SocketClosed = "socketClosed",
-    TrackEnd = "trackEnd",
-    TrackError = "trackError",
-    TrackStart = "trackStart",
-    TrackStuck = "trackStuck"
+/**
+ * Queue interface
+ */
+interface IQueue {
+    getCurrent(): Promise<Track | null>;
+    setCurrent(track: Track | null): Promise<void>;
+    getPrevious(): Promise<Track[]>;
+    addPrevious(track: Track | Track[]): Promise<void>;
+    setPrevious(track: Track | Track[]): Promise<void>;
+    /** Get newest track (index 0) */
+    popPrevious(): Promise<Track | null>;
+    clearPrevious(): Promise<void>;
+    size(): Promise<number>;
+    totalSize(): Promise<number>;
+    duration(): Promise<number>;
+    add(track: Track | Track[], offset?: number): Promise<void>;
+    remove(start?: number, end?: number): Promise<Track[]>;
+    clear(): Promise<void>;
+    dequeue(): Promise<Track | undefined>;
+    enqueueFront(track: Track | Track[]): Promise<void>;
+    getTracks(): Promise<Track[]>;
+    getSlice(start?: number, end?: number): Promise<Track[]>;
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    shuffle(): Promise<void>;
+    userBlockShuffle(): Promise<void>;
+    roundRobinShuffle(): Promise<void>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
 }
-interface ManagerEvents {
-    [ManagerEventTypes.ChapterStarted]: [player: Player, track: Track, payload: SponsorBlockChapterStarted];
-    [ManagerEventTypes.ChaptersLoaded]: [player: Player, track: Track, payload: SponsorBlockChaptersLoaded];
-    [ManagerEventTypes.Debug]: [info: string];
-    [ManagerEventTypes.NodeConnect]: [node: Node];
-    [ManagerEventTypes.NodeCreate]: [node: Node];
-    [ManagerEventTypes.NodeDestroy]: [node: Node];
-    [ManagerEventTypes.NodeDisconnect]: [node: Node, reason: {
-        code?: number;
-        reason?: string;
-    }];
-    [ManagerEventTypes.NodeError]: [node: Node, error: Error];
-    [ManagerEventTypes.NodeRaw]: [payload: unknown];
-    [ManagerEventTypes.NodeReconnect]: [node: Node];
-    [ManagerEventTypes.PlayerCreate]: [player: Player];
-    [ManagerEventTypes.PlayerDestroy]: [player: Player];
-    [ManagerEventTypes.PlayerDisconnect]: [player: Player, oldChannel: string];
-    [ManagerEventTypes.PlayerMove]: [player: Player, initChannel: string, newChannel: string];
-    [ManagerEventTypes.PlayerRestored]: [player: Player, node: Node];
-    [ManagerEventTypes.PlayerStateUpdate]: [oldPlayer: Player, newPlayer: Player, changeType: PlayerStateUpdateEvent];
-    [ManagerEventTypes.QueueEnd]: [player: Player, track: Track, payload: TrackEndEvent];
-    [ManagerEventTypes.RestoreComplete]: [node: Node];
-    [ManagerEventTypes.SegmentSkipped]: [player: Player, track: Track, payload: SponsorBlockSegmentSkipped];
-    [ManagerEventTypes.SegmentsLoaded]: [player: Player, track: Track, payload: SponsorBlockSegmentsLoaded];
-    [ManagerEventTypes.SocketClosed]: [player: Player, payload: WebSocketClosedEvent];
-    [ManagerEventTypes.TrackEnd]: [player: Player, track: Track, payload: TrackEndEvent];
-    [ManagerEventTypes.TrackError]: [player: Player, track: Track, payload: TrackExceptionEvent];
-    [ManagerEventTypes.TrackStart]: [player: Player, track: Track, payload: TrackStartEvent];
-    [ManagerEventTypes.TrackStuck]: [player: Player, track: Track, payload: TrackStuckEvent];
+/**
+ * Sizes Enum type
+ */
+type Sizes = "0" | "1" | "2" | "3" | "default" | "mqdefault" | "hqdefault" | "maxresdefault";
+/**
+ * Track Source Name Enum type
+ */
+type TrackSourceName = keyof typeof TrackSourceTypes;
+/**
+ * Use Node Option Enum type
+ */
+type UseNodeOption = keyof typeof UseNodeOptions;
+/**
+ * Track End Reason Enum type
+ */
+type TrackEndReason = keyof typeof TrackEndReasonTypes;
+/**
+ * Player Event Type Enum type
+ */
+type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted";
+/**
+ * Severity Types Enum type
+ */
+type Severity = keyof typeof SeverityTypes;
+/**
+ * SponsorBlock Segment Events Enum type
+ */
+type SponsorBlockSegmentEvents = SponsorBlockSegmentSkipped | SponsorBlockSegmentsLoaded | SponsorBlockChapterStarted | SponsorBlockChaptersLoaded;
+/**
+ * SponsorBlock Segment Event Type Enum type
+ */
+type SponsorBlockSegmentEventType = "SegmentSkipped" | "SegmentsLoaded" | "ChapterStarted" | "ChaptersLoaded";
+/**
+ * Player Events Enum type
+ */
+type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents;
+/**
+ * Load Type Enum type
+ */
+type LoadType = keyof typeof LoadTypes;
+
+declare class Node$1 {
+    manager: Manager;
+    options: NodeOptions;
+    /** The socket for the node. */
+    socket: WebSocket | null;
+    /** The stats for the node. */
+    stats: NodeStats;
+    /** The manager for the node */
+    /** The node's session ID. */
+    sessionId: string | null;
+    /** The REST instance. */
+    readonly rest: Rest;
+    /** Actual Lavalink information of the node. */
+    info: LavalinkInfo | null;
+    private reconnectTimeout?;
+    private reconnectAttempts;
+    /**
+     * Creates an instance of Node.
+     * @param options
+     */
+    constructor(manager: Manager, options: NodeOptions);
+    /** Returns if connected to the Node. */
+    get connected(): boolean;
+    /** Returns the address for this node. */
+    get address(): string;
+    /**
+     * Creates the sessionIds.json file if it doesn't exist. This file is used to
+     * store the session IDs for each node. The session IDs are used to identify
+     * the node when resuming a session.
+     */
+    createSessionIdsFile(): void;
+    /**
+     * Loads session IDs from the sessionIds.json file if it exists.
+     * The session IDs are used to resume sessions for each node.
+     *
+     * The session IDs are stored in the sessionIds.json file as a composite key
+     * of the node identifier and cluster ID. This allows multiple clusters to
+     * be used with the same node identifier.
+     */
+    loadSessionIds(): void;
+    /**
+     * Updates the session ID in the sessionIds.json file.
+     *
+     * This method is called after the session ID has been updated, and it
+     * writes the new session ID to the sessionIds.json file.
+     *
+     * @remarks
+     * The session ID is stored in the sessionIds.json file as a composite key
+     * of the node identifier and cluster ID. This allows multiple clusters to
+     * be used with the same node identifier.
+     */
+    updateSessionId(): void;
+    /**
+     * Connects to the Node.
+     *
+     * @remarks
+     * If the node is already connected, this method will do nothing.
+     * If the node has a session ID, it will be sent in the headers of the WebSocket connection.
+     * If the node has no session ID but the `enableSessionResumeOption` option is true, it will use the session ID
+     * stored in the sessionIds.json file if it exists.
+     */
+    connect(): void;
+    /**
+     * Destroys the node and cleans up associated resources.
+     *
+     * This method emits a debug event indicating that the node is being destroyed and attempts
+     * to automatically move all players connected to the node to a usable one. It then closes
+     * the WebSocket connection, removes all event listeners, and clears the reconnect timeout.
+     * Finally, it emits a "nodeDestroy" event and removes the node from the manager.
+     *
+     * @returns {Promise<void>} A promise that resolves when the node and its resources have been destroyed.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Attempts to reconnect to the node if the connection is lost.
+     *
+     * This method is called when the WebSocket connection is closed
+     * unexpectedly. It will attempt to reconnect to the node after a
+     * specified delay, and will continue to do so until the maximum
+     * number of retry attempts is reached or the node is manually destroyed.
+     * If the maximum number of retry attempts is reached, an error event
+     * will be emitted and the node will be destroyed.
+     *
+     * @returns {Promise<void>} - Resolves when the reconnection attempt is scheduled.
+     * @emits {debug} - Emits a debug event indicating the node is attempting to reconnect.
+     * @emits {nodeReconnect} - Emits a nodeReconnect event when the node is attempting to reconnect.
+     * @emits {nodeError} - Emits an error event if the maximum number of retry attempts is reached.
+     * @emits {nodeDestroy} - Emits a nodeDestroy event if the maximum number of retry attempts is reached.
+     */
+    private reconnect;
+    /**
+     * Handles the "open" event emitted by the WebSocket connection.
+     *
+     * This method is called when the WebSocket connection is established.
+     * It clears any existing reconnect timeouts, emits a debug event
+     * indicating the node is connected, and emits a "nodeConnect" event
+     * with the node as the argument.
+     */
+    protected open(): void;
+    /**
+     * Handles the "close" event emitted by the WebSocket connection.
+     *
+     * This method is called when the WebSocket connection is closed.
+     * It emits a "nodeDisconnect" event with the node and the close event as arguments,
+     * and a debug event indicating the node is disconnected.
+     * It then attempts to move all players connected to that node to a useable one.
+     * If the close event was not initiated by the user, it will also attempt to reconnect.
+     *
+     * @param {number} code The close code of the WebSocket connection.
+     * @param {string} reason The reason for the close event.
+     * @returns {Promise<void>} A promise that resolves when the disconnection is handled.
+     */
+    protected close(code: number, reason: string): Promise<void>;
+    /**
+     * Handles the "error" event emitted by the WebSocket connection.
+     *
+     * This method is called when an error occurs on the WebSocket connection.
+     * It emits a "nodeError" event with the node and the error as arguments and
+     * a debug event indicating the error on the node.
+     * @param {Error} error The error that occurred.
+     */
+    protected error(error: Error): void;
+    /**
+     * Handles incoming messages from the Lavalink WebSocket connection.
+     * @param {Buffer | string} d The message received from the WebSocket connection.
+     * @returns {Promise<void>} A promise that resolves when the message is handled.
+     * @emits {debug} - Emits a debug event with the message received from the WebSocket connection.
+     * @emits {nodeError} - Emits a nodeError event if an unexpected op is received.
+     * @emits {nodeRaw} - Emits a nodeRaw event with the raw message received from the WebSocket connection.
+     * @private
+     */
+    protected message(d: Buffer | string): Promise<void>;
+    /**
+     * Handles an event emitted from the Lavalink node.
+     * @param {PlayerEvent & PlayerEvents} payload The event emitted from the node.
+     * @returns {Promise<void>} A promise that resolves when the event has been handled.
+     * @private
+     */
+    protected handleEvent(payload: PlayerEvent & PlayerEvents): Promise<void>;
+    /**
+     * Emitted when a new track starts playing.
+     * @param {Player} player The player that started playing the track.
+     * @param {Track} track The track that started playing.
+     * @param {TrackStartEvent} payload The payload of the event emitted by the node.
+     * @private
+     */
+    protected trackStart(player: Player, track: Track, payload: TrackStartEvent): void;
+    /**
+     * Emitted when a track ends playing.
+     * @param {Player} player - The player that the track ended on.
+     * @param {Track} track - The track that ended.
+     * @param {TrackEndEvent} payload - The payload of the event emitted by the node.
+     * @private
+     */
+    protected trackEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
+    /**
+     * Handles autoplay logic for a player.
+     * This method is responsible for selecting an appropriate method of autoplay
+     * and executing it. If autoplay is not enabled or all attempts have failed,
+     * it will return false.
+     * @param {Player} player - The player to handle autoplay for.
+     * @param {number} attempt - The current attempt number of the autoplay.
+     * @returns {Promise<boolean>} A promise that resolves to a boolean indicating if autoplay was successful.
+     * @private
+     */
+    private handleAutoplay;
+    /**
+     * Handles the scenario when a track fails to play or load.
+     * Shifts the queue to the next track and emits a track end event.
+     * If there is no next track, handles the queue end scenario.
+     * If autoplay is enabled, plays the next track.
+     *
+     * @param {Player} player - The player instance associated with the track.
+     * @param {Track} track - The track that failed.
+     * @param {TrackEndEvent} payload - The event payload containing details about the track end.
+     * @returns {Promise<void>} A promise that resolves when the track failure has been processed.
+     * @private
+     */
+    private handleFailedTrack;
+    /**
+     * Handles the scenario when a track is repeated.
+     * Shifts the queue to the next track and emits a track end event.
+     * If there is no next track, handles the queue end scenario.
+     * If autoplay is enabled, plays the next track.
+     *
+     * @param {Player} player - The player instance associated with the track.
+     * @param {Track} track - The track that is repeated.
+     * @param {TrackEndEvent} payload - The event payload containing details about the track end.
+     * @returns {Promise<void>} A promise that resolves when the repeated track has been processed.
+     * @private
+     */
+    private handleRepeatedTrack;
+    /**
+     * Plays the next track in the queue.
+     * Updates the queue by shifting the current track to the previous track
+     * and plays the next track if autoplay is enabled.
+     *
+     * @param {Player} player - The player associated with the track.
+     * @param {Track} track - The track that has ended.
+     * @param {TrackEndEvent} payload - The event payload containing additional data about the track end event.
+     * @returns {void}
+     * @private
+     */
+    private playNextTrack;
+    /**
+     * Handles the event when a queue ends.
+     * If autoplay is enabled, attempts to play the next track in the queue using the autoplay logic.
+     * If all attempts fail, resets the player state and emits the `queueEnd` event.
+     * @param {Player} player - The player associated with the track.
+     * @param {Track} track - The track that has ended.
+     * @param {TrackEndEvent} payload - The event payload containing additional data about the track end event.
+     * @returns {Promise<void>} A promise that resolves when the queue end processing is complete.
+     */
+    queueEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
+    /**
+     * Fetches the lyrics of a track from the Lavalink node.
+     * This method uses the `lavalyrics-plugin` to fetch the lyrics.
+     * If the plugin is not available, it will throw a RangeError.
+     *
+     * @param {Track} track - The track to fetch the lyrics for.
+     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
+     * @returns {Promise<Lyrics>} A promise that resolves with the lyrics data.
+     */
+    getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics>;
+    /**
+     * Handles the event when a track becomes stuck during playback.
+     * Stops the current track and emits a `trackStuck` event.
+     *
+     * @param {Player} player - The player associated with the track that became stuck.
+     * @param {Track} track - The track that became stuck.
+     * @param {TrackStuckEvent} payload - The event payload containing additional data about the track stuck event.
+     * @returns {void}
+     * @protected
+     */
+    protected trackStuck(player: Player, track: Track, payload: TrackStuckEvent): Promise<void>;
+    /**
+     * Handles the event when a track has an error during playback.
+     * Stops the current track and emits a `trackError` event.
+     *
+     * @param {Player} player - The player associated with the track that had an error.
+     * @param {Track} track - The track that had an error.
+     * @param {TrackExceptionEvent} payload - The event payload containing additional data about the track error event.
+     * @returns {void}
+     * @protected
+     */
+    protected trackError(player: Player, track: Track, payload: TrackExceptionEvent): Promise<void>;
+    /**
+     * Emitted when the WebSocket connection for a player closes.
+     * The payload of the event will contain the close code and reason if provided.
+     * @param {Player} player - The player associated with the WebSocket connection.
+     * @param {WebSocketClosedEvent} payload - The event payload containing additional data about the WebSocket close event.
+     */
+    protected socketClosed(player: Player, payload: WebSocketClosedEvent): void;
+    /**
+     * Emitted when the segments for a track are loaded.
+     * The payload of the event will contain the segments.
+     * @param {Player} player - The player associated with the segments.
+     * @param {Track} track - The track associated with the segments.
+     * @param {SponsorBlockSegmentsLoaded} payload - The event payload containing additional data about the segments loaded event.
+     */
+    private sponsorBlockSegmentLoaded;
+    /**
+     * Emitted when a segment of a track is skipped using the sponsorblock plugin.
+     * The payload of the event will contain the skipped segment.
+     * @param {Player} player - The player associated with the skipped segment.
+     * @param {Track} track - The track associated with the skipped segment.
+     * @param {SponsorBlockSegmentSkipped} payload - The event payload containing additional data about the segment skipped event.
+     */
+    private sponsorBlockSegmentSkipped;
+    /**
+     * Emitted when chapters for a track are loaded using the sponsorblock plugin.
+     * The payload of the event will contain the chapters.
+     * @param {Player} player - The player associated with the chapters.
+     * @param {Track} track - The track associated with the chapters.
+     * @param {SponsorBlockChaptersLoaded} payload - The event payload containing additional data about the chapters loaded event.
+     */
+    private sponsorBlockChaptersLoaded;
+    /**
+     * Emitted when a chapter of a track is started using the sponsorblock plugin.
+     * The payload of the event will contain the started chapter.
+     * @param {Player} player - The player associated with the started chapter.
+     * @param {Track} track - The track associated with the started chapter.
+     * @param {SponsorBlockChapterStarted} payload - The event payload containing additional data about the chapter started event.
+     */
+    private sponsorBlockChapterStarted;
+    /**
+     * Fetches Lavalink node information.
+     * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.
+     */
+    fetchInfo(): Promise<LavalinkInfo>;
+    /**
+     * Gets the current sponsorblock segments for a player.
+     * @param {Player} player - The player to get the sponsorblocks for.
+     * @returns {Promise<SponsorBlockSegment[]>} A promise that resolves to the sponsorblock segments.
+     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
+     */
+    getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
+    /**
+     * Sets the sponsorblock segments for a player.
+     * @param {Player} player - The player to set the sponsor blocks for.
+     * @param {SponsorBlockSegment[]} segments - The sponsorblock segments to set. Defaults to `[SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]` if not provided.
+     * @returns {Promise<void>} The promise is resolved when the operation is complete.
+     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
+     * @throws {RangeError} If no segments are provided.
+     * @throws {SyntaxError} If an invalid sponsorblock is provided.
+     * @example
+     * ```ts
+     * // use it on the player via player.setSponsorBlock();
+     * player.setSponsorBlock([SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]);
+     * ```
+     */
+    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
+    /**
+     * Deletes the sponsorblock segments for a player.
+     * @param {Player} player - The player to delete the sponsorblocks for.
+     * @returns {Promise<void>} The promise is resolved when the operation is complete.
+     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
+     */
+    deleteSponsorBlock(player: Player): Promise<void>;
+    /**
+     * Creates a README.md or README.txt file in the magmastream directory
+     * if it doesn't already exist. This file is used to store player data
+     * for autoresume and other features.
+     * @private
+     */
+    private createReadmeFile;
 }
-interface PlayerStore {
+
+/**
+ * The main hub for interacting with Lavalink and using Magmastream,
+ */
+declare class Manager extends EventEmitter {
+    /** The map of players. */
+    readonly players: Collection<string, Player>;
+    /** The map of nodes. */
+    readonly nodes: Collection<string, Node$1>;
+    /** The options that were set. */
+    readonly options: ManagerOptions;
+    initiated: boolean;
+    redis?: Redis;
+    private _send?;
+    /**
+     * Initiates the Manager class.
+     * @param options
+     * @param options.enabledPlugins - An array of enabledPlugins to load.
+     * @param options.nodes - An array of node options to create nodes from.
+     * @param options.playNextOnEnd - Whether to automatically play the first track in the queue when the player is created.
+     * @param options.autoPlaySearchPlatforms - The search platform autoplay will use. Fallback to Youtube if not found.
+     * @param options.enablePriorityMode - Whether to use the priority when selecting a node to play on.
+     * @param options.clientName - The name of the client to send to Lavalink.
+     * @param options.defaultSearchPlatform - The default search platform to use when searching for tracks.
+     * @param options.useNode - The strategy to use when selecting a node to play on.
+     * @param options.trackPartial - The partial track search results to use when searching for tracks. This partials will always be presented on each track.
+     * @param options.eventBatchDuration - The duration to wait before processing the collected player state events.
+     * @param options.eventBatchInterval - The interval to wait before processing the collected player state events.
+     */
+    constructor(options: ManagerOptions);
+    /**
+     * Initiates the Manager.
+     * @param clientId - The Discord client ID (only required when not using any of the magmastream wrappers).
+     * @param clusterId - The cluster ID which runs the current process (required).
+     * @returns The manager instance.
+     */
+    init(options?: ManagerInitOptions): this;
+    /**
+     * Searches the enabled sources based off the URL or the `source` property.
+     * @param query
+     * @param requester
+     * @returns The search result.
+     */
+    search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
+    /**
+     * Returns a player or undefined if it does not exist.
+     * @param guildId The guild ID of the player to retrieve.
+     * @returns The player if it exists, undefined otherwise.
+     */
+    getPlayer(guildId: string): Player | undefined;
+    /**
+     * @deprecated - Will be removed with v2.10.0 use {@link getPlayer} instead
+     * Returns a player or undefined if it does not exist.
+     * @param guildId The guild ID of the player to retrieve.
+     * @returns The player if it exists, undefined otherwise.
+     */
     get(guildId: string): Promise<Player | undefined>;
-    set(guildId: string, player: Player): Promise<void>;
-    delete(guildId: string): Promise<void>;
-    keys(): Promise<string[]>;
-    has(guildId: string): Promise<boolean>;
-    filter(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Map<string, Player>>;
-    find(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Player | undefined>;
-    map<T>(callback: (player: Player, guildId: string) => T | Promise<T>): Promise<T[]>;
-    forEach(callback: (player: Player, guildId: string) => void | Promise<void>): Promise<void>;
-    some(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
-    every(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
-    size(): Promise<number>;
-    clear(): Promise<void>;
-    entries(): AsyncIterableIterator<[string, Player]>;
+    /**
+     * Creates a player or returns one if it already exists.
+     * @param options The options to create the player with.
+     * @returns The created player.
+     */
+    create(options: PlayerOptions): Player;
+    /**
+     * Destroys a player.
+     * @param guildId The guild ID of the player to destroy.
+     * @returns A promise that resolves when the player has been destroyed.
+     */
+    destroy(guildId: string): Promise<void>;
+    /**
+     * Creates a new node or returns an existing one if it already exists.
+     * @param options - The options to create the node with.
+     * @returns The created node.
+     */
+    createNode(options: NodeOptions): Node$1;
+    /**
+     * Destroys a node if it exists. Emits a debug event if the node is found and destroyed.
+     * @param identifier - The identifier of the node to destroy.
+     * @returns {void}
+     * @emits {debug} - Emits a debug message indicating the node is being destroyed.
+     */
+    destroyNode(identifier: string): Promise<void>;
+    /**
+     * Attaches an event listener to the manager.
+     * @param event The event to listen for.
+     * @param listener The function to call when the event is emitted.
+     * @returns The manager instance for chaining.
+     */
+    on<T extends keyof ManagerEvents>(event: T, listener: (...args: ManagerEvents[T]) => void): this;
+    /**
+     * Updates the voice state of a player based on the provided data.
+     * @param data - The data containing voice state information, which can be a VoicePacket, VoiceServer, or VoiceState.
+     * @returns A promise that resolves when the voice state update is handled.
+     * @emits {debug} - Emits a debug message indicating the voice state is being updated.
+     */
+    updateVoiceState(data: VoicePacket | VoiceServer | VoiceState): Promise<void>;
+    /**
+     * Decodes an array of base64 encoded tracks and returns an array of TrackData.
+     * Emits a debug event with the tracks being decoded.
+     * @param tracks - An array of base64 encoded track strings.
+     * @returns A promise that resolves to an array of TrackData objects.
+     * @throws Will throw an error if no nodes are available or if the API request fails.
+     */
+    decodeTracks(tracks: string[]): Promise<TrackData[]>;
+    /**
+     * Decodes a base64 encoded track and returns a TrackData.
+     * @param track - The base64 encoded track string.
+     * @returns A promise that resolves to a TrackData object.
+     * @throws Will throw an error if no nodes are available or if the API request fails.
+     */
+    decodeTrack(track: string): Promise<TrackData>;
+    /**
+     * Saves player states to the JSON file.
+     * @param {string} guildId - The guild ID of the player to save
+     */
+    savePlayerState(guildId: string): Promise<void>;
+    /**
+     * Sleeps for a specified amount of time.
+     * @param ms The amount of time to sleep in milliseconds.
+     * @returns A promise that resolves after the specified amount of time.
+     */
+    private sleep;
+    /**
+     * Loads player states from the JSON file.
+     * @param nodeId The ID of the node to load player states from.
+     * @returns A promise that resolves when the player states have been loaded.
+     */
+    loadPlayerStates(nodeId: string): Promise<void>;
+    /**
+     * Returns the node to use based on the configured `useNode` and `enablePriorityMode` options.
+     * If `enablePriorityMode` is true, the node is chosen based on priority, otherwise it is chosen based on the `useNode` option.
+     * If `useNode` is "leastLoad", the node with the lowest load is chosen, if it is "leastPlayers", the node with the fewest players is chosen.
+     * If `enablePriorityMode` is false and `useNode` is not set, the node with the lowest load is chosen.
+     * @returns {Node} The node to use.
+     */
+    get useableNode(): Node$1;
+    /**
+     * Handles the shutdown of the process by saving all active players' states and optionally cleaning up inactive players.
+     * This function is called when the process is about to exit.
+     * It iterates through all players and calls {@link savePlayerState} to save their states.
+     * Optionally, it also calls {@link cleanupInactivePlayers} to remove any stale player state files.
+     * After saving and cleaning up, it exits the process.
+     */
+    handleShutdown(): Promise<void>;
+    /**
+     * Parses a YouTube title into a clean title and author.
+     * @param title - The original title of the YouTube video.
+     * @param originalAuthor - The original author of the YouTube video.
+     * @returns An object with the clean title and author.
+     */
+    private parseYouTubeTitle;
+    /**
+     * Balances brackets in a given string by ensuring all opened brackets are closed correctly.
+     * @param str - The input string that may contain unbalanced brackets.
+     * @returns A new string with balanced brackets.
+     */
+    private balanceBrackets;
+    /**
+     * Escapes a string by replacing special regex characters with their escaped counterparts.
+     * @param string - The string to escape.
+     * @returns The escaped string.
+     */
+    private escapeRegExp;
+    /**
+     * Checks if the given data is a voice update.
+     * @param data The data to check.
+     * @returns Whether the data is a voice update.
+     */
+    private isVoiceUpdate;
+    /**
+     * Determines if the provided update is a valid voice update.
+     * A valid update must contain either a token or a session_id.
+     *
+     * @param update - The voice update data to validate, which can be a VoicePacket, VoiceServer, or VoiceState.
+     * @returns {boolean} - True if the update is valid, otherwise false.
+     */
+    private isValidUpdate;
+    /**
+     * Handles a voice server update by updating the player's voice state and sending the voice state to the Lavalink node.
+     * @param player The player for which the voice state is being updated.
+     * @param update The voice server data received from Discord.
+     * @returns A promise that resolves when the voice state update is handled.
+     * @emits {debug} - Emits a debug message indicating the voice state is being updated.
+     */
+    private handleVoiceServerUpdate;
+    /**
+     * Handles a voice state update by updating the player's voice channel and session ID if provided, or by disconnecting and destroying the player if the channel ID is null.
+     * @param player The player for which the voice state is being updated.
+     * @param update The voice state data received from Discord.
+     * @emits {playerMove} - Emits a player move event if the channel ID is provided and the player is currently connected to a different voice channel.
+     * @emits {playerDisconnect} - Emits a player disconnect event if the channel ID is null.
+     */
+    private handleVoiceStateUpdate;
+    /**
+     * Gets each player's JSON file
+     * @param {string} guildId - The guild ID
+     * @returns {string} The path to the player's JSON file
+     */
+    private getPlayerFilePath;
+    /**
+     * Serializes a Player instance to avoid circular references.
+     * @param player The Player instance to serialize
+     * @returns The serialized Player instance
+     */
+    serializePlayer(player: Player): Record<string, unknown>;
+    /**
+     * Checks for players that are no longer active and deletes their saved state files.
+     * This is done to prevent stale state files from accumulating on the file system.
+     */
+    private cleanupInactivePlayers;
+    /**
+     * Returns the nodes that has the least load.
+     * The load is calculated by dividing the lavalink load by the number of cores.
+     * The result is multiplied by 100 to get a percentage.
+     * @returns {Collection<string, Node>}
+     */
+    private get leastLoadNode();
+    /**
+     * Returns the nodes that have the least amount of players.
+     * Filters out disconnected nodes and sorts the remaining nodes
+     * by the number of players in ascending order.
+     * @returns {Collection<string, Node>} A collection of nodes sorted by player count.
+     */
+    private get leastPlayersNode();
+    /**
+     * Returns a node based on priority.
+     * The nodes are sorted by priority in descending order, and then a random number
+     * between 0 and 1 is generated. The node that has a cumulative weight greater than or equal to the
+     * random number is returned.
+     * If no node has a cumulative weight greater than or equal to the random number, the node with the
+     * lowest load is returned.
+     * @returns {Node} The node to use.
+     */
+    private get priorityNode();
+    protected send(packet: GatewayVoiceStateUpdate): unknown;
+    sendPacket(packet: GatewayVoiceStateUpdate): unknown;
 }
 
 declare class Player {
@@ -1509,7 +1857,7 @@ declare class Player {
     /** The volume for the player */
     volume: number;
     /** The Node for the Player. */
-    node: Node;
+    node: Node$1;
     /** The guild ID for the player. */
     guildId: string;
     /** The voice channel for the player. */
@@ -1530,17 +1878,22 @@ declare class Player {
     isAutoplay: boolean;
     /** The number of times to try autoplay before emitting queueEnd. */
     autoplayTries: number;
-    private static _manager;
     private readonly data;
-    private volumeFadeInProgress;
     private dynamicLoopInterval;
     dynamicRepeatIntervalMs: number | null;
+    private static _manager;
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
      * @see https://docs.magmastream.com/main/introduction/getting-started
      */
     constructor(options: PlayerOptions);
+    /**
+     * Initializes the static properties of the Player class.
+     * @hidden
+     * @param manager The Manager to use.
+     */
+    static init(manager: Manager): void;
     /**
      * Set custom data.
      * @param key - The key to set the data for.
@@ -1554,12 +1907,6 @@ declare class Player {
      * @returns {T} - The data associated with the key, cast to the specified type.
      */
     get<T>(key: string): T;
-    /**
-     * Initializes the static properties of the Player class.
-     * @hidden
-     * @param manager The Manager to use.
-     */
-    static init(manager: Manager): void;
     /**
      * Same as Manager#search() but a shortcut on the player itself.
      * @param query
@@ -1571,11 +1918,10 @@ declare class Player {
      * @throws {RangeError} If no voice channel has been set.
      * @returns {void}
      */
-    connect(): void;
+    connect(): Promise<void>;
     /**
      * Disconnects the player from the voice channel.
-     * @throws {TypeError} If the player is not connected.
-     * @returns {this} - The current instance of the Player class for method chaining.
+     * @returns {this} The player instance.
      */
     disconnect(): Promise<this>;
     /**
@@ -1648,7 +1994,6 @@ declare class Player {
     /**
      * Sets the volume of the player.
      * @param {number} volume - The new volume. Must be between 0 and 1000.
-     * @param {GradualOptions} options - The options to use for the gradual change.
      * @returns {Promise<Player>} - The updated player.
      * @throws {TypeError} If the volume is not a number.
      * @throws {RangeError} If the volume is not between 0 and 1000.
@@ -1657,7 +2002,7 @@ declare class Player {
      * player.setVolume(50);
      * player.setVolume(50, { gradual: true, interval: 50, step: 5 });
      */
-    setVolume(volume: number, options?: GradualOptions): Promise<this>;
+    setVolume(volume: number): Promise<this>;
     /**
      * Sets the sponsorblock for the player. This will set the sponsorblock segments for the player to the given segments.
      * @param {SponsorBlockSegment[]} segments - The sponsorblock segments to set. Defaults to `[SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]` if not provided.
@@ -1775,87 +2120,6 @@ declare class Player {
      */
     private sleep;
 }
-interface PlayerOptions {
-    /** The guild ID the Player belongs to. */
-    guildId: string;
-    /** The text channel the Player belongs to. */
-    textChannelId: string;
-    /** The voice channel the Player belongs to. */
-    voiceChannelId?: string;
-    /** The node the Player uses. */
-    node?: string;
-    /** The initial volume the Player will use. */
-    volume?: number;
-    /** If the player should mute itself. */
-    selfMute?: boolean;
-    /** If the player should deaf itself. */
-    selfDeafen?: boolean;
-}
-interface GradualOptions {
-    /** If the change should be gradual. */
-    gradual?: boolean;
-    /** The duration of the gradual change. */
-    interval?: number;
-    /** The step of the gradual change. */
-    step?: number;
-}
-/** If track partials are set some of these will be `undefined` as they were removed. */
-interface Track {
-    /** The base64 encoded track. */
-    readonly track: string;
-    /** The artwork url of the track. */
-    readonly artworkUrl: string;
-    /** The track source name. */
-    readonly sourceName: TrackSourceName;
-    /** The title of the track. */
-    title: string;
-    /** The identifier of the track. */
-    readonly identifier: string;
-    /** The author of the track. */
-    author: string;
-    /** The duration of the track. */
-    readonly duration: number;
-    /** The ISRC of the track. */
-    readonly isrc: string;
-    /** If the track is seekable. */
-    readonly isSeekable: boolean;
-    /** If the track is a stream.. */
-    readonly isStream: boolean;
-    /** The uri of the track. */
-    readonly uri: string;
-    /** The thumbnail of the track or null if it's a unsupported source. */
-    readonly thumbnail: string | null;
-    /** The user that requested the track. */
-    requester?: User | ClientUser;
-    /** Displays the track thumbnail with optional size or null if it's a unsupported source. */
-    displayThumbnail(size?: Sizes): string;
-    /** Additional track info provided by plugins. */
-    pluginInfo: TrackPluginInfo;
-    /** Add your own data to the track. */
-    customData: Record<string, unknown>;
-}
-interface TrackPluginInfo {
-    albumName?: string;
-    albumUrl?: string;
-    artistArtworkUrl?: string;
-    artistUrl?: string;
-    isPreview?: string;
-    previewUrl?: string;
-}
-interface PlayOptions {
-    /** The position to start the track. */
-    readonly startTime?: number;
-    /** The position to end the track. */
-    readonly endTime?: number;
-    /** Whether to not replace the track if a play payload is sent. */
-    readonly noReplace?: boolean;
-}
-interface EqualizerBand {
-    /** The band number being 0 to 14. */
-    band: number;
-    /** The gain amount being -0.25 to 1.00, 0.25 being double. */
-    gain: number;
-}
 
 declare class Filters {
     distortion: distortionOptions | null;
@@ -2271,7 +2535,7 @@ declare enum AvailableFilters {
     Demon = "demon"
 }
 
-declare class Plugin {
+declare class Plugin$1 {
     name: string;
     /**
      * @param name The name of the plugin
@@ -2280,5 +2544,118 @@ declare class Plugin {
     load(manager: Manager): void;
 }
 
-export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, Filters, LoadTypes, Manager, ManagerEventTypes, Node, Player, PlayerStateEventTypes, Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
-export type { CPUStats, EqualizerBand, Exception, Extendable, FrameStats, GradualOptions, IQueue, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStore, PlayerUpdate, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, State, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent };
+declare abstract class TrackUtils {
+    static trackPartial: TrackPartial[] | null;
+    private static manager;
+    /**
+     * Initializes the TrackUtils class with the given manager.
+     * @param manager The manager instance to use.
+     * @hidden
+     */
+    static init(manager: Manager): void;
+    /**
+     * Sets the partial properties for the Track class. If a Track has some of its properties removed by the partial,
+     * it will be considered a partial Track.
+     * @param {TrackPartial} partial The array of string property names to remove from the Track class.
+     */
+    static setTrackPartial(partial: TrackPartial[]): void;
+    /**
+     * Checks if the provided argument is a valid Track.
+     * If provided an array then every element will be checked.
+     * @param trackOrTracks The Track or array of Tracks to check.
+     * @returns {boolean} Whether the provided argument is a valid Track.
+     */
+    static validate(trackOrTracks: unknown): boolean;
+    /**
+     * Builds a Track from the raw data from Lavalink and a optional requester.
+     * @param data The raw data from Lavalink to build the Track from.
+     * @param requester The user who requested the track, if any.
+     * @returns The built Track.
+     */
+    static build<T = User | ClientUser>(data: TrackData, requester?: T): Track;
+}
+declare abstract class AutoPlayUtils {
+    private static manager;
+    /**
+     * Initializes the AutoPlayUtils class with the given manager.
+     * @param manager The manager instance to use.
+     * @hidden
+     */
+    static init(manager: Manager): void;
+    /**
+     * Gets recommended tracks for the given track.
+     * @param track The track to get recommended tracks for.
+     * @returns An array of recommended tracks.
+     */
+    static getRecommendedTracks(track: Track): Promise<Track[]>;
+    /**
+     * Gets recommended tracks from Last.fm for the given track.
+     * @param track The track to get recommended tracks for.
+     * @param apiKey The API key for Last.fm.
+     * @returns An array of recommended tracks.
+     */
+    static getRecommendedTracksFromLastFm(track: Track, apiKey: string): Promise<Track[]>;
+    /**
+     * Gets recommended tracks from the given source.
+     * @param track The track to get recommended tracks for.
+     * @param platform The source to get recommended tracks from.
+     * @returns An array of recommended tracks.
+     */
+    static getRecommendedTracksFromSource(track: Track, platform: string): Promise<Track[]>;
+    static fetchSecretArray(): Promise<Buffer<ArrayBuffer>>;
+    static transformSecret(buffer: Buffer): Buffer<ArrayBuffer>;
+    static generateTotp(secretBuffer: Buffer): string;
+}
+/** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
+declare abstract class Structure {
+    /**
+     * Extends a class.
+     * @param name
+     * @param extender
+     */
+    static extend<K extends keyof Extendable, T extends Extendable[K]>(name: K, extender: (target: Extendable[K]) => T): T;
+    /**
+     * Get a structure from available structures by name.
+     * @param name
+     */
+    static get<K extends keyof Extendable>(name: K): Extendable[K];
+}
+
+/**
+ * Discord.js wrapper for Magmastream.
+ */
+declare class DiscordJSManager extends Manager {
+    readonly client: Client;
+    constructor(client: Client, options?: ManagerOptions);
+    protected send(packet: GatewayVoiceStateUpdate): void;
+}
+
+/**
+ * Eris wrapper for Magmastream.
+ */
+declare class ErisManager extends Manager {
+    readonly client: Client$1;
+    constructor(client: Client$1, options?: ManagerOptions);
+    protected send(packet: GatewayVoiceStateUpdate): void;
+}
+
+/**
+ * Detritus wrapper for Magmastream.
+ */
+declare class DetritusManager extends Manager {
+    readonly client: ClusterClient | ShardClient;
+    constructor(client: ClusterClient | ShardClient, options?: ManagerOptions);
+    protected send(packet: GatewayVoiceStateUpdate): void;
+}
+
+/**
+ * Oceanic wrapper for Magmastream.
+ */
+declare class OceanicManager extends Manager {
+    readonly client: Client$2;
+    constructor(client: Client$2, options?: ManagerOptions);
+    protected send(packet: GatewayVoiceStateUpdate): void;
+}
+
+export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, DetritusManager, DiscordJSManager, ErisManager, Filters, LoadTypes, Manager, ManagerEventTypes, Node$1 as Node, OceanicManager, Player, PlayerStateEventTypes, Plugin$1 as Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
+export type { CPUStats, DiscordPacket, EqualizerBand, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateUpdateEvent, PlayerStore, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };