magmastream 2.9.0-dev.45 → 2.9.0-dev.47

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { Collection } from '@discordjs/collection';
 import { GatewayVoiceStateUpdate } from 'discord-api-types/v10';
 import { EventEmitter } from 'events';
 import { User, ClientUser, Message, Client } from 'discord.js';
-import WebSocket, { WebSocket as WebSocket$1 } from 'ws';
+import WebSocket$1, { WebSocket } from 'ws';
 import { Redis } from 'ioredis';
 import { Client as Client$1 } from 'eris';
 import { ClusterClient, ShardClient } from 'detritus-client';
@@ -98,7 +98,8 @@ declare enum PlayerStateEventTypes {
     VolumeChange = "volumeChange",
     ChannelChange = "channelChange",
     PlayerCreate = "playerCreate",
-    PlayerDestroy = "playerDestroy"
+    PlayerDestroy = "playerDestroy",
+    FilterChange = "filterChange"
 }
 /**
  * Track Source Types Enum
@@ -266,6 +267,9 @@ declare enum AvailableFilters {
 declare class JsonQueue implements IQueue {
     readonly guildId: string;
     readonly manager: Manager;
+    /**
+     * The base path for the queue files.
+     */
     private basePath;
     /**
      * @param guildId The guild ID.
@@ -273,76 +277,74 @@ declare class JsonQueue implements IQueue {
      */
     constructor(guildId: string, manager: Manager);
     /**
-     * @returns The queue path.
+     * @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.
      */
-    private get queuePath();
+    add(track: Track | Track[], offset?: number): Promise<void>;
     /**
-     * @returns The current path.
+     * @param track The track to add.
      */
-    private get currentPath();
+    addPrevious(track: Track | Track[]): Promise<void>;
     /**
-     * @returns The previous path.
+     * Clears the queue.
      */
-    private get previousPath();
+    clear(): Promise<void>;
     /**
-     * Ensures the directory exists.
+     * Clears the previous tracks.
      */
-    private ensureDir;
+    clearPrevious(): Promise<void>;
     /**
-     * @returns The queue.
+     * Removes the first track from the queue.
      */
-    private getQueue;
+    dequeue(): Promise<Track | undefined>;
     /**
-     * @param queue The queue.
+     * @returns The total duration of the queue.
      */
-    private setQueue;
+    duration(): Promise<number>;
     /**
-     * @param filePath The file path.
-     * @returns The JSON data.
+     * Adds a track to the front of the queue.
      */
-    private readJSON;
+    enqueueFront(track: Track | Track[]): Promise<void>;
     /**
-     * @param filePath The file path.
-     * @param data The data to write.
+     * Tests whether all elements in the queue pass the test implemented by the provided function.
      */
-    private writeJSON;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
     /**
-     * @param filePath The file path.
+     * Filters the queue.
      */
-    private deleteFile;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
     /**
-     * @returns The current track.
+     * Finds the first track in the queue that satisfies the provided testing function.
      */
-    getCurrent(): Promise<Track | null>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
     /**
-     * @param track The track to set.
+     * @returns The current track.
      */
-    setCurrent(track: Track | null): Promise<void>;
+    getCurrent(): Promise<Track | null>;
     /**
      * @returns The previous tracks.
      */
     getPrevious(): Promise<Track[]>;
     /**
-     * @param track The track to add.
+     * @returns The tracks in the queue from start to end.
      */
-    addPrevious(track: Track | Track[]): Promise<void>;
+    getSlice(start?: number, end?: number): Promise<Track[]>;
     /**
-     * @param track The track to set.
+     * @returns The tracks in the queue.
      */
-    setPrevious(track: Track | Track[]): Promise<void>;
+    getTracks(): Promise<Track[]>;
     /**
-     * @returns The newest track.
+     * Maps the queue to a new array.
      */
-    popPrevious(): Promise<Track | null>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
     /**
-     * Clears the previous tracks.
+     * Modifies the queue at the specified index.
      */
-    clearPrevious(): Promise<void>;
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
     /**
-     * @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.
+     * @returns The newest track.
      */
-    add(track: Track | Track[], offset?: number): Promise<void>;
+    popPrevious(): Promise<Track | null>;
     /**
      * Removes a track from the queue.
      * @param position The position to remove the track at.
@@ -351,73 +353,75 @@ declare class JsonQueue implements IQueue {
     remove(position?: number): Promise<Track[]>;
     remove(start: number, end: number): Promise<Track[]>;
     /**
-     * Clears the queue.
-     */
-    clear(): Promise<void>;
-    /**
-     * @returns The size of the queue.
+     * Shuffles the queue by round-robin.
      */
-    size(): Promise<number>;
+    roundRobinShuffle(): Promise<void>;
     /**
-     * @returns The total size of the queue.
+     * @param track The track to set.
      */
-    totalSize(): Promise<number>;
+    setCurrent(track: Track | null): Promise<void>;
     /**
-     * @returns The total duration of the queue.
+     * @param track The track to set.
      */
-    duration(): Promise<number>;
+    setPrevious(track: Track | Track[]): Promise<void>;
     /**
      * Shuffles the queue.
      */
     shuffle(): Promise<void>;
     /**
-     * Shuffles the queue by user.
+     * @returns The size of the queue.
      */
-    userBlockShuffle(): Promise<void>;
+    size(): Promise<number>;
     /**
-     * Shuffles the queue by round-robin.
+     * Tests whether at least one element in the queue passes the test implemented by the provided function.
      */
-    roundRobinShuffle(): Promise<void>;
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
     /**
-     * Removes the first track from the queue.
+     * @returns The total size of the queue.
      */
-    dequeue(): Promise<Track | undefined>;
+    totalSize(): Promise<number>;
     /**
-     * Adds a track to the front of the queue.
+     * Shuffles the queue by user.
      */
-    enqueueFront(track: Track | Track[]): Promise<void>;
+    userBlockShuffle(): Promise<void>;
     /**
-     * @returns The tracks in the queue.
+     * @returns The current path.
      */
-    getTracks(): Promise<Track[]>;
+    private get currentPath();
     /**
-     * @returns The tracks in the queue from start to end.
+     * @param filePath The file path.
      */
-    getSlice(start?: number, end?: number): Promise<Track[]>;
+    private deleteFile;
     /**
-     * Modifies the queue at the specified index.
+     * Ensures the directory exists.
      */
-    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    private ensureDir;
     /**
-     * Maps the queue to a new array.
+     * @returns The queue.
      */
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    private getQueue;
     /**
-     * Filters the queue.
+     * @returns The previous path.
      */
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    private get previousPath();
     /**
-     * Finds the first track in the queue that satisfies the provided testing function.
+     * @returns The queue path.
      */
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    private get queuePath();
     /**
-     * Tests whether at least one element in the queue passes the test implemented by the provided function.
+     * @param filePath The file path.
+     * @returns The JSON data.
      */
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    private readJSON;
     /**
-     * Tests whether all elements in the queue pass the test implemented by the provided function.
+     * @param queue The queue.
      */
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    private setQueue;
+    /**
+     * @param filePath The file path.
+     * @param data The data to write.
+     */
+    private writeJSON;
 }
 
 /**
@@ -439,97 +443,71 @@ declare class MemoryQueue extends Array<Track> implements IQueue {
      */
     constructor(guildId: string, manager: Manager);
     /**
-     * @returns The current track.
-     */
-    getCurrent(): Promise<Track | null>;
-    /**
-     * @param track The track to set.
+     * 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.
      */
-    setCurrent(track: Track | null): Promise<void>;
+    add(track: Track | Track[], offset?: number): Promise<void>;
     /**
-     * @returns The previous tracks.
+     * Adds a track to the previous tracks.
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
      */
-    getPrevious(): Promise<Track[]>;
     addPrevious(track: Track | Track[]): Promise<void>;
     /**
-     * @param tracks The tracks to set.
-     */
-    setPrevious(tracks: Track[]): Promise<void>;
-    /**
-     * @returns The newest track.
+     * Clears the queue.
+     * This will remove all tracks from the queue and emit a state update event.
      */
-    popPrevious(): Promise<Track | null>;
+    clear(): Promise<void>;
     /**
      * Clears the previous tracks.
      */
     clearPrevious(): Promise<void>;
+    /**
+     * Removes the first element from the queue.
+     */
+    dequeue(): Promise<Track | undefined>;
     /**
      * 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).
+     * Adds the specified track or tracks to the front of the queue.
+     * @param track The track or tracks to add.
      */
-    remove(position?: number): Promise<Track[]>;
-    remove(start: number, end: number): Promise<Track[]>;
+    enqueueFront(track: Track | Track[]): Promise<void>;
     /**
-     * Clears the queue.
-     * This will remove all tracks from the queue and emit a state update event.
+     * @returns Whether all elements in the queue satisfy the provided testing function.
      */
-    clear(): Promise<void>;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
     /**
-     * Shuffles the queue.
-     * This will randomize the order of the tracks in the queue and emit a state update event.
+     * @returns A new array with all elements that pass the test implemented by the provided function.
      */
-    shuffle(): Promise<void>;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
     /**
-     * Shuffles the queue to play tracks requested by each user one block at a time.
+     * @returns The first element in the queue that satisfies the provided testing function.
      */
-    userBlockShuffle(): Promise<void>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
     /**
-     * Shuffles the queue to play tracks requested by each user one by one.
+     * @returns The current track.
      */
-    roundRobinShuffle(): Promise<void>;
+    getCurrent(): Promise<Track | null>;
     /**
-     * Removes the first element from the queue.
+     * @returns The previous tracks.
      */
-    dequeue(): Promise<Track | undefined>;
+    getPrevious(): Promise<Track[]>;
     /**
-     * Adds the specified track or tracks to the front of the queue.
-     * @param track The track or tracks to add.
+     * @returns The tracks in the queue from start to end.
      */
-    enqueueFront(track: Track | Track[]): Promise<void>;
+    getSlice(start?: number, end?: number): Promise<Track[]>;
     /**
-     * @returns A shallow copy of the queue.
+     * @returns The tracks in the queue.
      */
     getTracks(): Promise<Track[]>;
     /**
-     * @returns A shallow copy of the queue.
+     * @returns A new array with the results of calling a provided function on every element in the queue.
      */
-    getSlice(start?: number, end?: number): Promise<Track[]>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
     /**
      * Modifies the queue at the specified index.
      * @param start The index at which to start modifying the queue.
@@ -539,41 +517,71 @@ declare class MemoryQueue extends Array<Track> implements IQueue {
      */
     modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
     /**
-     * @returns A new array with the results of calling a provided function on every element in the queue.
+     * @returns The newest track.
      */
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    popPrevious(): Promise<Track | null>;
     /**
-     * @returns A new array with all elements that pass the test implemented by the provided function.
+     * 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).
      */
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
     /**
-     * @returns The first element in the queue that satisfies the provided testing function.
+     * Shuffles the queue to play tracks requested by each user one by one.
      */
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    roundRobinShuffle(): Promise<void>;
     /**
-     * @returns Whether at least one element in the queue satisfies the provided testing function.
+     * @param track The track to set.
      */
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    setCurrent(track: Track | null): Promise<void>;
     /**
-     * @returns Whether all elements in the queue satisfy the provided testing function.
+     * @param tracks The tracks to set.
      */
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
-}
-
-/**
- * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
- */
-declare class RedisQueue implements IQueue {
-    readonly guildId: string;
-    readonly manager: Manager;
+    setPrevious(tracks: Track[]): Promise<void>;
     /**
-     * The Redis instance.
+     * Shuffles the queue.
+     * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    private redis;
+    shuffle(): Promise<void>;
+    /**
+     * 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>;
+    /**
+     * @returns Whether at least one element in the queue satisfies the provided testing function.
+     */
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * 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>;
+    /**
+     * Shuffles the queue to play tracks requested by each user one block at a time.
+     */
+    userBlockShuffle(): Promise<void>;
+}
+
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+declare class RedisQueue implements IQueue {
+    readonly guildId: string;
+    readonly manager: Manager;
     /**
      * The prefix for the Redis keys.
      */
     redisPrefix: string;
+    /**
+     * The Redis instance.
+     */
+    private redis;
     /**
      * Constructs a new RedisQueue.
      * @param guildId The guild ID.
@@ -581,133 +589,151 @@ declare class RedisQueue implements IQueue {
      */
     constructor(guildId: string, manager: Manager);
     /**
-     * @returns The queue key.
+     * Adds a track or tracks 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.
      */
-    private get queueKey();
+    add(track: Track | Track[], offset?: number): Promise<void>;
     /**
-     * @returns The current key.
+     * Adds a track or tracks to the previous tracks.
+     * @param track The track or tracks to add.
      */
-    private get currentKey();
+    addPrevious(track: Track | Track[]): Promise<void>;
     /**
-     * @returns The previous key.
+     * Clears the queue.
      */
-    private get previousKey();
+    clear(): Promise<void>;
     /**
-     * Helper to serialize/deserialize Track
+     * Clears the previous tracks.
      */
-    private serialize;
+    clearPrevious(): Promise<void>;
     /**
-     * Helper to serialize/deserialize Track
+     * Removes the first track from the queue.
      */
-    private deserialize;
+    dequeue(): Promise<Track | undefined>;
     /**
-     * @returns The current track.
+     * @returns The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
      */
-    getCurrent(): Promise<Track | null>;
+    duration(): Promise<number>;
     /**
-     * @param track The track to set.
+     * Adds a track to the front of the queue.
+     * @param track The track or tracks to add.
      */
-    setCurrent(track: Track | null): Promise<void>;
+    enqueueFront(track: Track | Track[]): Promise<void>;
     /**
-     * @returns The previous tracks.
+     * Whether all tracks in the queue match the specified condition.
+     * @param callback The condition to match.
+     * @returns Whether all tracks in the queue match the specified condition.
      */
-    getPrevious(): Promise<Track[]>;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
     /**
-     * @param track The track to add.
+     * Filters the tracks in the queue.
+     * @param callback The condition to match.
+     * @returns The tracks that match the condition.
      */
-    addPrevious(track: Track | Track[]): Promise<void>;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
     /**
-     * @param track The track to set.
+     * Finds the first track in the queue that matches the specified condition.
+     * @param callback The condition to match.
+     * @returns The first track that matches the condition.
      */
-    setPrevious(track: Track | Track[]): Promise<void>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
     /**
-     * @returns The newest track.
+     * @returns The current track.
      */
-    popPrevious(): Promise<Track | null>;
+    getCurrent(): Promise<Track | null>;
     /**
-     * Clears the previous tracks.
+     * @returns The previous tracks.
      */
-    clearPrevious(): Promise<void>;
+    getPrevious(): Promise<Track[]>;
     /**
-     * @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.
+     * @returns The tracks in the queue from the start to the end.
      */
-    add(track: Track | Track[], offset?: number): Promise<void>;
+    getSlice(start?: number, end?: number): Promise<Track[]>;
     /**
-     * @param position The position to remove the track at.
-     * @param end The end position to remove the track at.
+     * @returns The tracks in the queue.
      */
-    remove(position?: number): Promise<Track[]>;
-    remove(start: number, end: number): Promise<Track[]>;
+    getTracks(): Promise<Track[]>;
     /**
-     * Clears the queue.
+     * Maps the tracks in the queue.
+     * @returns The tracks in the queue after the specified index.
      */
-    clear(): Promise<void>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
     /**
-     * @returns The size of the queue.
+     * Modifies the queue at the specified index.
+     * @param start The start index.
+     * @param deleteCount The number of tracks to delete.
+     * @param items The tracks to insert.
+     * @returns The removed tracks.
      */
-    size(): Promise<number>;
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
     /**
-     * @returns The total size of tracks in the queue including the current track.
+     * Removes the newest track.
+     * @returns The newest track.
      */
-    totalSize(): Promise<number>;
+    popPrevious(): Promise<Track | null>;
     /**
-     * @returns The total duration of the queue in milliseconds.
-     * This includes the duration of the currently playing track.
+     * Removes the track at the specified index.
+     * @param position The position to remove the track at.
+     * @param end The end position to remove the track at.
      */
-    duration(): Promise<number>;
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
     /**
-     * Shuffles the queue.
+     * Shuffles the queue round-robin style.
      */
-    shuffle(): Promise<void>;
+    roundRobinShuffle(): Promise<void>;
     /**
-     * Shuffles the queue, but keeps the tracks of the same user together.
+     * Sets the current track.
+     * @param track The track to set.
      */
-    userBlockShuffle(): Promise<void>;
+    setCurrent(track: Track | null): Promise<void>;
     /**
-     * Shuffles the queue round-robin style.
+     * Sets the previous track(s).
+     * @param track The track to set.
      */
-    roundRobinShuffle(): Promise<void>;
+    setPrevious(track: Track | Track[]): Promise<void>;
     /**
-     * Removes the first track from the queue.
+     * Shuffles the queue.
      */
-    dequeue(): Promise<Track | undefined>;
+    shuffle(): Promise<void>;
     /**
-     * Adds a track to the front of the queue.
+     * @returns The size of the queue.
      */
-    enqueueFront(track: Track | Track[]): Promise<void>;
+    size(): Promise<number>;
     /**
-     * @returns The tracks in the queue.
+     * @returns Whether any tracks in the queue match the specified condition.
      */
-    getTracks(): Promise<Track[]>;
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
     /**
-     * @returns The tracks in the queue from the start to the end.
+     * @returns The total size of tracks in the queue including the current track.
      */
-    getSlice(start?: number, end?: number): Promise<Track[]>;
+    totalSize(): Promise<number>;
     /**
-     * Modifies the queue at the specified index.
+     * Shuffles the queue, but keeps the tracks of the same user together.
      */
-    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    userBlockShuffle(): Promise<void>;
     /**
-     * @returns The tracks in the queue after the specified index.
+     * @returns The current key.
      */
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    private get currentKey();
     /**
-     * @returns The tracks in the queue that match the specified condition.
+     * Deserializes a track from a string.
      */
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    private deserialize;
     /**
-     * @returns The first track in the queue that matches the specified condition.
+     * @returns The previous key.
      */
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    private get previousKey();
     /**
-     * @returns Whether any tracks in the queue match the specified condition.
+     * @returns The queue key.
      */
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    private get queueKey();
     /**
-     * @returns Whether all tracks in the queue match the specified condition.
+     * Helper to serialize/deserialize Track
      */
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    private serialize;
 }
 
 /**
@@ -960,6 +986,9 @@ type PlayerStateUpdateEvent = {
 } | {
     changeType: PlayerStateEventTypes.RepeatChange;
     details: RepeatChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.FilterChange;
+    details: FilterChangeEvent;
 };
 /**
  * Autoplay Change Event
@@ -979,6 +1008,10 @@ interface ConnectionChangeEvent {
     previousConnection: boolean | null;
     currentConnection: boolean | null;
 }
+interface FilterChangeEvent {
+    type: "filter";
+    action: "change";
+}
 /**
  * Repeat Change Event
  */
@@ -1914,1058 +1947,1059 @@ type LyricsEvent = LyricsFoundEvent | LyricsNotFoundEvent | LyricsLineEvent;
  */
 type LyricsEventType = "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
 
-/** Handles the requests sent to the Lavalink REST API. */
-declare class Rest {
-    /** The Node that this Rest instance is connected to. */
-    private node;
-    /** The ID of the current session. */
-    private sessionId;
-    /** The password for the Node. */
-    private readonly password;
-    /** The URL of the Node. */
-    private readonly url;
-    /** The Manager instance. */
+declare class Player {
+    options: PlayerOptions;
+    /** The Queue for the Player. */
+    queue: IQueue;
+    /** The filters applied to the audio. */
+    filters: Filters;
+    /** Whether the queue repeats the track. */
+    trackRepeat: boolean;
+    /** Whether the queue repeats the queue. */
+    queueRepeat: boolean;
+    /**Whether the queue repeats and shuffles after each song. */
+    dynamicRepeat: boolean;
+    /** The time the player is in the track. */
+    position: number;
+    /** Whether the player is playing. */
+    playing: boolean;
+    /** Whether the player is paused. */
+    paused: boolean;
+    /** The volume for the player */
+    volume: number;
+    /** The Node for the Player. */
+    node: Node;
+    /** The guild ID for the player. */
+    guildId: string;
+    /** The voice channel for the player. */
+    voiceChannelId: string | null;
+    /** The text channel for the player. */
+    textChannelId: string | null;
+    /**The now playing message. */
+    nowPlayingMessage?: Message;
+    /** The current state of the player. */
+    state: StateTypes;
+    /** The equalizer bands array. */
+    bands: number[];
+    /** The voice state object from Discord. */
+    voiceState: VoiceState;
+    /** The Manager. */
     manager: Manager;
-    /** Whether the node is a NodeLink. */
-    isNodeLink: boolean;
-    constructor(node: Node, manager: Manager);
+    /** The autoplay state of the player. */
+    isAutoplay: boolean;
+    /** The number of times to try autoplay before emitting queueEnd. */
+    autoplayTries: number;
+    /** The cluster ID for the player. */
+    clusterId: number;
+    private readonly data;
+    private dynamicLoopInterval;
+    dynamicRepeatIntervalMs: number | null;
+    private static _manager;
+    /** Should only be used when the node is a NodeLink */
+    protected voiceReceiverWsClient: WebSocket | null;
+    protected isConnectToVoiceReceiver: boolean;
+    protected voiceReceiverReconnectTimeout: NodeJS.Timeout | null;
+    protected voiceReceiverAttempt: number;
+    protected voiceReceiverReconnectTries: number;
     /**
-     * Sets the session ID.
-     * This method is used to set the session ID after a resume operation is done.
-     * @param {string} sessionId The session ID to set.
-     * @returns {string} Returns the set session ID.
+     * Creates a new player, returns one if it already exists.
+     * @param options The player options.
+     * @see https://docs.magmastream.com/main/introduction/getting-started
      */
-    setSessionId(sessionId: string): string;
+    constructor(options: PlayerOptions);
     /**
-     * Retrieves all the players that are currently running on the node.
-     * @returns {Promise<unknown>} Returns the result of the GET request.
+     * Initializes the static properties of the Player class.
+     * @hidden
+     * @param manager The Manager to use.
      */
-    getAllPlayers(): Promise<unknown>;
+    static init(manager: Manager): void;
     /**
-     * Sends a PATCH request to update player related data.
-     * @param {RestPlayOptions} options The options to update the player with.
-     * @returns {Promise<unknown>} Returns the result of the PATCH request.
-     */
-    updatePlayer(options: RestPlayOptions): Promise<unknown>;
-    /**
-     * Sends a DELETE request to the server to destroy the player.
-     * @param {string} guildId The guild ID of the player to destroy.
-     * @returns {Promise<unknown>} Returns the result of the DELETE request.
-     */
-    destroyPlayer(guildId: string): Promise<unknown>;
-    /**
-     * Updates the session status for resuming.
-     * This method sends a PATCH request to update the session's resuming status and timeout.
-     *
-     * @param {boolean} resuming - Indicates whether the session should be set to resuming.
-     * @param {number} timeout - The timeout duration for the session resume.
-     * @returns {Promise<unknown>} The result of the PATCH request.
-     */
-    updateSession(resuming: boolean, timeout: number): Promise<unknown>;
-    /**
-     * Sends a request to the specified endpoint and returns the response data.
-     * @param {string} method The HTTP method to use for the request.
-     * @param {string} endpoint The endpoint to send the request to.
-     * @param {unknown} [body] The data to send in the request body.
-     * @returns {Promise<unknown>} The response data of the request.
-     */
-    private request;
-    /**
-     * Sends a GET request to the specified endpoint and returns the response data.
-     * @param {string} endpoint The endpoint to send the GET request to.
-     * @returns {Promise<unknown>} The response data of the GET request.
-     */
-    get(endpoint: string): Promise<unknown>;
-    /**
-     * Sends a PATCH request to the specified endpoint and returns the response data.
-     * @param {string} endpoint The endpoint to send the PATCH request to.
-     * @param {unknown} body The data to send in the request body.
-     * @returns {Promise<unknown>} The response data of the PATCH request.
-     */
-    patch(endpoint: string, body: unknown): Promise<unknown>;
-    /**
-     * Sends a POST request to the specified endpoint and returns the response data.
-     * @param {string} endpoint The endpoint to send the POST request to.
-     * @param {unknown} body The data to send in the request body.
-     * @returns {Promise<unknown>} The response data of the POST request.
+     * Set custom data.
+     * @param key - The key to set the data for.
+     * @param value - The value to set the data to.
      */
-    post(endpoint: string, body: unknown): Promise<unknown>;
+    set(key: string, value: unknown): void;
     /**
-     * Sends a PUT request to the specified endpoint and returns the response data.
-     * @param {string} endpoint The endpoint to send the PUT request to.
-     * @param {unknown} body The data to send in the request body.
-     * @returns {Promise<unknown>} The response data of the PUT request.
+     * Retrieves custom data associated with a given key.
+     * @template T - The expected type of the data.
+     * @param {string} key - The key to retrieve the data for.
+     * @returns {T} - The data associated with the key, cast to the specified type.
      */
-    put(endpoint: string, body: unknown): Promise<unknown>;
+    get<T>(key: string): T;
     /**
-     * Sends a DELETE request to the specified endpoint.
-     * @param {string} endpoint - The endpoint to send the DELETE request to.
-     * @returns {Promise<unknown>} The response data of the DELETE request.
+     * Same as Manager#search() but a shortcut on the player itself.
+     * @param query
+     * @param requester
      */
-    delete(endpoint: string): Promise<unknown>;
-}
-
-declare class Node {
-    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;
-    /** Whether the node is a NodeLink. */
-    isNodeLink: boolean;
-    private reconnectTimeout?;
-    private reconnectAttempts;
-    private redisPrefix?;
-    private sessionIdsFilePath?;
-    private sessionIdsMap;
+    search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
     /**
-     * Creates an instance of Node.
-     * @param manager - The manager for the node.
-     * @param options - The options for the node.
+     * Connects the player to the voice channel.
+     * @throws {RangeError} If no voice channel has been set.
+     * @returns {void}
      */
-    constructor(manager: Manager, options: NodeOptions);
+    connect(): void;
     /**
-     * Checks if the Node is currently connected.
-     * This method returns true if the Node has an active WebSocket connection, indicating it is ready to receive and process commands.
+     * Disconnects the player from the voice channel.
+     * @returns {this} The player instance.
      */
-    get connected(): boolean;
-    /** Returns the full address for this node, including the host and port. */
-    get address(): string;
+    disconnect(): Promise<this>;
     /**
-     * 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.
+     * Destroys the player and clears the queue.
+     * @param {boolean} disconnect - Whether to disconnect the player from the voice channel.
+     * @returns {Promise<boolean>} - Whether the player was successfully destroyed.
+     * @emits {PlayerDestroy} - Emitted when the player is destroyed.
+     * @emits {PlayerStateUpdate} - Emitted when the player state is updated.
      */
-    createSessionIdsFile(): void;
+    destroy(disconnect?: boolean): Promise<boolean>;
     /**
-     * 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.
+     * Sets the player voice channel.
+     * @param {string} channel - The new voice channel ID.
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the channel parameter is not a string.
      */
-    loadSessionIds(): Promise<void>;
+    setVoiceChannelId(channel: string): this;
     /**
-     * Updates the session ID in the sessionIds.json file.
+     * Sets the player text channel.
      *
-     * This method is called after the session ID has been updated, and it
-     * writes the new session ID to the sessionIds.json file.
+     * This method updates the text channel associated with the player. It also
+     * emits a player state update event indicating the change in the channel.
      *
-     * @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.
+     * @param {string} channel - The new text channel ID.
+     * @returns {this} - The player instance for method chaining.
+     * @throws {TypeError} If the channel parameter is not a string.
      */
-    updateSessionId(): Promise<void>;
+    setTextChannelId(channel: string): this;
     /**
-     * Connects to the Node.
+     * Sets the now playing message.
      *
-     * @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.
+     * @param message - The message of the now playing message.
+     * @returns The now playing message.
      */
-    connect(): Promise<void>;
+    setNowPlayingMessage<T = Message>(message: T): Message;
     /**
-     * Destroys the node and cleans up associated resources.
+     * Plays the next track.
      *
-     * 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.
+     * If a track is provided, it will be played. Otherwise, the next track in the queue will be played.
+     * If the queue is not empty, but the current track has not finished yet, it will be replaced with the provided track.
      *
-     * @returns {Promise<void>} A promise that resolves when the node and its resources have been destroyed.
+     * @param {object} [optionsOrTrack] - The track to play or the options to play with.
+     * @param {object} [playOptions] - The options to play with.
+     *
+     * @returns {Promise<void>}
      */
-    destroy(): Promise<void>;
+    play(): Promise<Player>;
+    play(track: Track): Promise<Player>;
+    play(options: PlayOptions): Promise<Player>;
+    play(track: Track, options: PlayOptions): Promise<Player>;
     /**
-     * Attempts to reconnect to the node if the connection is lost.
+     * Sets the autoplay-state of the player.
      *
-     * 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.
+     * Autoplay is a feature that makes the player play a recommended
+     * track when the current track ends.
      *
-     * @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.
+     * @param {boolean} autoplayState - Whether or not autoplay should be enabled.
+     * @param {object} botUser - The user-object that should be used as the bot-user.
+     * @param {number} [tries=3] - The number of times the player should try to find a
+     * recommended track if the first one doesn't work.
+     * @returns {this} - The player instance.
      */
-    private reconnect;
+    setAutoplay<T = unknown>(autoplayState: boolean, botUser?: T, tries?: number): this;
     /**
-     * Upgrades the node to a NodeLink.
-     *
-     * @param request - The incoming message.
+     * Gets recommended tracks and returns an array of tracks.
+     * @param {Track} track - The track to find recommendations for.
+     * @returns {Promise<Track[]>} - Array of recommended tracks.
      */
-    private upgrade;
+    getRecommendedTracks(track: Track): 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.
+     * Sets the volume of the player.
+     * @param {number} volume - The new volume. Must be between 0 and 1000.
+     * @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.
+     * @emits {PlayerStateUpdate} - Emitted when the volume is changed.
+     * @example
+     * player.setVolume(50);
+     * player.setVolume(50, { gradual: true, interval: 50, step: 5 });
      */
-    protected open(): void;
+    setVolume(volume: number): Promise<this>;
     /**
-     * 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.
+     * 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.
+     * @returns {Promise<void>} The promise is resolved when the operation is complete.
      */
-    protected close(code: number, reason: string): Promise<void>;
+    setSponsorBlock(segments?: SponsorBlockSegment[]): 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.
+     * Gets the sponsorblock for the player.
+     * @returns {Promise<SponsorBlockSegment[]>} The sponsorblock segments.
      */
-    protected error(error: Error): void;
+    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
     /**
-     * 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
+     * Deletes the sponsorblock for the player. This will remove all sponsorblock segments that have been set for the player.
+     * @returns {Promise<void>}
      */
-    protected message(d: Buffer | string): Promise<void>;
+    deleteSponsorBlock(): 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
+     * Sets the track repeat mode.
+     * When track repeat is enabled, the current track will replay after it ends.
+     * Disables queueRepeat and dynamicRepeat modes if enabled.
+     *
+     * @param repeat - A boolean indicating whether to enable track repeat.
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the repeat parameter is not a boolean.
      */
-    protected trackStart(player: Player, track: Track, payload: TrackStartEvent): void;
+    setTrackRepeat(repeat: boolean): this;
     /**
-     * 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
+     * Sets the queue repeat.
+     * @param repeat Whether to repeat the queue or not
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the repeat parameter is not a boolean
      */
-    trackEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
+    setQueueRepeat(repeat: boolean): this;
     /**
-     * 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
+     * Sets the queue to repeat and shuffles the queue after each song.
+     * @param repeat "true" or "false".
+     * @param ms After how many milliseconds to trigger dynamic repeat.
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the repeat parameter is not a boolean.
+     * @throws {RangeError} If the queue size is less than or equal to 1.
      */
-    private handleAutoplay;
+    setDynamicRepeat(repeat: boolean, ms: number): Promise<this>;
     /**
-     * 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
+     * Restarts the currently playing track from the beginning.
+     * If there is no track playing, it will play the next track in the queue.
+     * @returns {Promise<Player>} The current instance of the Player class for method chaining.
      */
-    private handleFailedTrack;
+    restart(): Promise<Player>;
     /**
-     * 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
+     * Stops the player and optionally removes tracks from the queue.
+     * @param {number} [amount] The amount of tracks to remove from the queue. If not provided, removes the current track if it exists.
+     * @returns {Promise<this>} - The player instance.
+     * @throws {RangeError} If the amount is greater than the queue length.
      */
-    private handleRepeatedTrack;
+    stop(amount?: number): Promise<this>;
     /**
-     * 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
+     * Skips the current track.
+     * @returns {this} - The player instance.
+     * @throws {Error} If there are no tracks in the queue.
+     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
      */
-    private playNextTrack;
+    pause(pause: boolean): Promise<this>;
     /**
-     * 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.
+     * Skips to the previous track in the queue.
+     * @returns {this} - The player instance.
+     * @throws {Error} If there are no previous tracks in the queue.
+     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
      */
-    queueEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
+    previous(): Promise<this>;
     /**
-     * Fetches the lyrics of a track from the Lavalink node.
-     *
-     * If the node is a NodeLink, it will use the `NodeLinkGetLyrics` method to fetch the lyrics.
-     *
-     * Requires the `lavalyrics-plugin` to be present in the Lavalink node.
-     * Requires the `lavasrc-plugin` or `java-lyrics-plugin` to be present in the Lavalink node.
-     *
-     * @param {Track} track - The track to fetch the lyrics for.
-     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @param {string} [language="en"] - The language of the lyrics.
-     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
+     * Seeks to a given position in the currently playing track.
+     * @param position - The position in milliseconds to seek to.
+     * @returns {this} - The player instance.
+     * @throws {Error} If the position is invalid.
+     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
      */
-    getLyrics(track: Track, skipTrackSource?: boolean, language?: string): Promise<Lyrics | NodeLinkGetLyrics>;
+    seek(position: number): Promise<this>;
     /**
-     * Subscribes to lyrics for a player.
-     * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
-     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @returns {Promise<unknown>} A promise that resolves when the subscription is complete.
-     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     * Returns the current repeat state of the player.
+     * @param player The player to get the repeat state from.
+     * @returns The repeat state of the player, or null if it is not repeating.
      */
-    lyricsSubscribe(guildId: string, skipTrackSource?: boolean): Promise<unknown>;
+    private getRepeatState;
     /**
-     * Unsubscribes from lyrics for a player.
-     * @param {string} guildId - The ID of the guild to unsubscribe from lyrics for.
-     * @returns {Promise<unknown>} A promise that resolves when the unsubscription is complete.
-     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     * Automatically moves the player to a usable node.
+     * @returns {Promise<Player | void>} - The player instance or void if not moved.
      */
-    lyricsUnsubscribe(guildId: string): Promise<unknown>;
+    autoMoveNode(): Promise<Player | void>;
     /**
-     * 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
+     * Moves the player to another node.
+     * @param {string} identifier - The identifier of the node to move to.
+     * @returns {Promise<Player>} - The player instance after being moved.
      */
-    protected trackStuck(player: Player, track: Track, payload: TrackStuckEvent): Promise<void>;
+    moveNode(identifier: string): Promise<Player>;
     /**
-     * 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
+     * Transfers the player to a new server. If the player already exists on the new server
+     * and force is false, this method will return the existing player. Otherwise, a new player
+     * will be created and the current player will be destroyed.
+     * @param {PlayerOptions} newOptions - The new options for the player.
+     * @param {boolean} force - Whether to force the creation of a new player.
+     * @returns {Promise<Player>} - The new player instance.
      */
-    protected trackError(player: Player, track: Track, payload: TrackExceptionEvent): Promise<void>;
+    switchGuild(newOptions: PlayerOptions, force?: boolean): Promise<Player>;
     /**
-     * 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.
+     * Retrieves the current lyrics for the playing track.
+     * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.
+     * @returns {Promise<Lyrics>} - The lyrics of the current track.
+     * @throws {RangeError} - If the 'lavalyrics-plugin' is not available on the Lavalink node.
      */
-    protected socketClosed(player: Player, payload: WebSocketClosedEvent): void;
+    getCurrentLyrics(skipTrackSource?: boolean): Promise<Lyrics>;
     /**
-     * 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.
+     * Sets up the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is set up.
+     * @throws {Error} - If the node is not a NodeLink.
      */
-    private sponsorBlockSegmentLoaded;
+    setupVoiceReceiver(): Promise<void>;
     /**
-     * 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.
+     * Removes the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is removed.
+     * @throws {Error} - If the node is not a NodeLink.
      */
-    private sponsorBlockSegmentSkipped;
+    removeVoiceReceiver(): Promise<void>;
     /**
-     * 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.
+     * Closes the voice receiver for the player.
+     * @param {number} code - The code to close the voice receiver with.
+     * @param {string} reason - The reason to close the voice receiver with.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is closed.
      */
-    private sponsorBlockChaptersLoaded;
+    private closeVoiceReceiver;
     /**
-     * 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.
+     * Reconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is reconnected.
      */
-    private sponsorBlockChapterStarted;
+    private reconnectVoiceReceiver;
     /**
-     * Emitted when lyrics for a track are found.
-     * The payload of the event will contain the lyrics.
-     * @param {Player} player - The player associated with the lyrics.
-     * @param {Track} track - The track associated with the lyrics.
-     * @param {LyricsFoundEvent} payload - The event payload containing additional data about the lyrics found event.
+     * Disconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is disconnected.
      */
-    private lyricsFound;
+    private disconnectVoiceReceiver;
     /**
-     * Emitted when lyrics for a track are not found.
-     * The payload of the event will contain the track.
-     * @param {Player} player - The player associated with the lyrics.
-     * @param {Track} track - The track associated with the lyrics.
-     * @param {LyricsNotFoundEvent} payload - The event payload containing additional data about the lyrics not found event.
+     * Opens the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is opened.
      */
-    private lyricsNotFound;
+    private openVoiceReceiver;
     /**
-     * Emitted when a line of lyrics for a track is received.
-     * The payload of the event will contain the lyrics line.
-     * @param {Player} player - The player associated with the lyrics line.
-     * @param {Track} track - The track associated with the lyrics line.
-     * @param {LyricsLineEvent} payload - The event payload containing additional data about the lyrics line event.
+     * Handles a voice receiver message.
+     * @param {string} payload - The payload to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
      */
-    private lyricsLine;
+    private onVoiceReceiverMessage;
     /**
-     * Fetches Lavalink node information.
-     * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.
+     * Handles a voice receiver error.
+     * @param {Error} error - The error to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver error is handled.
      */
-    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[]>;
+    private onVoiceReceiverError;
+}
+
+/** Handles the requests sent to the Lavalink REST API. */
+declare class Rest {
+    /** The Node that this Rest instance is connected to. */
+    private node;
+    /** The ID of the current session. */
+    private sessionId;
+    /** The password for the Node. */
+    private readonly password;
+    /** The URL of the Node. */
+    private readonly url;
+    /** The Manager instance. */
+    manager: Manager;
+    /** Whether the node is a NodeLink. */
+    isNodeLink: boolean;
+    constructor(node: Node, manager: Manager);
     /**
-     * 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]);
-     * ```
+     * Sets the session ID.
+     * This method is used to set the session ID after a resume operation is done.
+     * @param {string} sessionId The session ID to set.
+     * @returns {string} Returns the set session ID.
      */
-    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
+    setSessionId(sessionId: string): string;
     /**
-     * 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.
+     * Retrieves all the players that are currently running on the node.
+     * @returns {Promise<unknown>} Returns the result of the GET request.
      */
-    deleteSponsorBlock(player: Player): Promise<void>;
+    getAllPlayers(): Promise<unknown>;
     /**
-     * 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
+     * Sends a PATCH request to update player related data.
+     * @param {RestPlayOptions} options The options to update the player with.
+     * @returns {Promise<unknown>} Returns the result of the PATCH request.
      */
-    private createReadmeFile;
-}
-
-/**
- * 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>;
-    /** The options that were set. */
-    readonly options: ManagerOptions;
-    initiated: boolean;
-    redis?: Redis;
-    private _send;
-    private loadedPlugins;
+    updatePlayer(options: RestPlayOptions): Promise<unknown>;
     /**
-     * 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.
+     * Sends a DELETE request to the server to destroy the player.
+     * @param {string} guildId The guild ID of the player to destroy.
+     * @returns {Promise<unknown>} Returns the result of the DELETE request.
      */
-    constructor(options: ManagerOptions);
+    destroyPlayer(guildId: string): Promise<unknown>;
     /**
-     * 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.
+     * Updates the session status for resuming.
+     * This method sends a PATCH request to update the session's resuming status and timeout.
+     *
+     * @param {boolean} resuming - Indicates whether the session should be set to resuming.
+     * @param {number} timeout - The timeout duration for the session resume.
+     * @returns {Promise<unknown>} The result of the PATCH request.
      */
-    init(options?: ManagerInitOptions): Promise<this>;
+    updateSession(resuming: boolean, timeout: number): Promise<unknown>;
     /**
-     * Searches the enabled sources based off the URL or the `source` property.
-     * @param query
-     * @param requester
-     * @returns The search result.
+     * Sends a request to the specified endpoint and returns the response data.
+     * @param {string} method The HTTP method to use for the request.
+     * @param {string} endpoint The endpoint to send the request to.
+     * @param {unknown} [body] The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the request.
      */
-    search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
+    private request;
     /**
-     * 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.
+     * Sends a GET request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the GET request to.
+     * @returns {Promise<unknown>} The response data of the GET request.
      */
-    getPlayer(guildId: string): Player | undefined;
+    get(endpoint: string): Promise<unknown>;
     /**
-     * Creates a player or returns one if it already exists.
-     * @param options The options to create the player with.
-     * @returns The created player.
+     * Sends a PATCH request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the PATCH request to.
+     * @param {unknown} body The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the PATCH request.
      */
-    create(options: PlayerOptions): Player;
+    patch(endpoint: string, body: unknown): Promise<unknown>;
     /**
-     * Destroys a player.
-     * @param guildId The guild ID of the player to destroy.
-     * @returns A promise that resolves when the player has been destroyed.
+     * Sends a POST request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the POST request to.
+     * @param {unknown} body The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the POST request.
      */
-    destroy(guildId: string): Promise<void>;
+    post(endpoint: string, body: unknown): Promise<unknown>;
     /**
-     * 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.
+     * Sends a PUT request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the PUT request to.
+     * @param {unknown} body The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the PUT request.
      */
-    createNode(options: NodeOptions): Node;
+    put(endpoint: string, body: unknown): Promise<unknown>;
     /**
-     * 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.
+     * Sends a DELETE request to the specified endpoint.
+     * @param {string} endpoint - The endpoint to send the DELETE request to.
+     * @returns {Promise<unknown>} The response data of the DELETE request.
      */
-    destroyNode(identifier: string): Promise<void>;
+    delete(endpoint: string): Promise<unknown>;
+}
+
+declare class Node {
+    manager: Manager;
+    options: NodeOptions;
+    /** The socket for the node. */
+    socket: WebSocket$1 | 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;
+    /** Whether the node is a NodeLink. */
+    isNodeLink: boolean;
+    private reconnectTimeout?;
+    private reconnectAttempts;
+    private redisPrefix?;
+    private sessionIdsFilePath?;
+    private sessionIdsMap;
     /**
-     * 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.
+     * Creates an instance of Node.
+     * @param manager - The manager for the node.
+     * @param options - The options for the node.
      */
-    on<T extends keyof ManagerEvents>(event: T, listener: (...args: ManagerEvents[T]) => void): this;
+    constructor(manager: Manager, options: NodeOptions);
     /**
-     * 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.
+     * Checks if the Node is currently connected.
+     * This method returns true if the Node has an active WebSocket connection, indicating it is ready to receive and process commands.
      */
-    updateVoiceState(data: VoicePacket | VoiceServer | VoiceState): Promise<void>;
+    get connected(): boolean;
+    /** Returns the full address for this node, including the host and port. */
+    get address(): string;
     /**
-     * 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.
+     * 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.
      */
-    decodeTracks(tracks: string[]): Promise<TrackData[]>;
+    createSessionIdsFile(): void;
     /**
-     * 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.
+     * 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.
      */
-    decodeTrack(track: string): Promise<TrackData>;
+    loadSessionIds(): Promise<void>;
     /**
-     * Saves player states.
-     * @param {string} guildId - The guild ID of the player to save
+     * 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.
      */
-    savePlayerState(guildId: string): Promise<void>;
+    updateSessionId(): 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.
+     * 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.
      */
-    private sleep;
+    connect(): Promise<void>;
     /**
-     * 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.
+     * 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.
      */
-    loadPlayerStates(nodeId: string): Promise<void>;
+    destroy(): 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.
+     * 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.
      */
-    get useableNode(): Node;
+    private reconnect;
     /**
-     * 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.
+     * Upgrades the node to a NodeLink.
+     *
+     * @param request - The incoming message.
      */
-    handleShutdown(): Promise<void>;
+    private upgrade;
     /**
-     * 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.
+     * 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.
      */
-    private parseYouTubeTitle;
+    protected open(): void;
     /**
-     * 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.
+     * 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.
      */
-    private balanceBrackets;
+    protected close(code: number, reason: string): Promise<void>;
     /**
-     * Escapes a string by replacing special regex characters with their escaped counterparts.
-     * @param string - The string to escape.
-     * @returns The escaped string.
+     * 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.
      */
-    private escapeRegExp;
+    protected error(error: Error): void;
     /**
-     * Checks if the given data is a voice update.
-     * @param data The data to check.
-     * @returns Whether the data is a voice update.
+     * 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
      */
-    private isVoiceUpdate;
+    protected message(d: Buffer | string): Promise<void>;
     /**
-     * Determines if the provided update is a valid voice update.
-     * A valid update must contain either a token or a session_id.
+     * 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
+     */
+    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 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.
+     * @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 isValidUpdate;
+    private handleFailedTrack;
     /**
-     * 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.
+     * 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 handleVoiceServerUpdate;
+    private handleRepeatedTrack;
     /**
-     * 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.
+     * 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 handleVoiceStateUpdate;
+    private playNextTrack;
     /**
-     * Cleans up inactive players by removing their state files from the file system.
-     * This is done to prevent stale state files from accumulating on the file system.
+     * 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.
      */
-    cleanupInactivePlayers(): Promise<void>;
+    queueEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
     /**
-     * Cleans up an inactive player by removing its state data.
-     * This is done to prevent stale state data from accumulating.
-     * @param guildId The guild ID of the player to clean up.
+     * Fetches the lyrics of a track from the Lavalink node.
+     *
+     * If the node is a NodeLink, it will use the `NodeLinkGetLyrics` method to fetch the lyrics.
+     *
+     * Requires the `lavalyrics-plugin` to be present in the Lavalink node.
+     * Requires the `lavasrc-plugin` or `java-lyrics-plugin` to be present in the Lavalink node.
+     *
+     * @param {Track} track - The track to fetch the lyrics for.
+     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
+     * @param {string} [language="en"] - The language of the lyrics.
+     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
-    cleanupInactivePlayer(guildId: string): Promise<void>;
+    getLyrics(track: Track, skipTrackSource?: boolean, language?: string): Promise<Lyrics | NodeLinkGetLyrics>;
     /**
-     * Loads the enabled plugins.
+     * Subscribes to lyrics for a player.
+     * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
+     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
+     * @returns {Promise<unknown>} A promise that resolves when the subscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
      */
-    private loadPlugins;
+    lyricsSubscribe(guildId: string, skipTrackSource?: boolean): Promise<unknown>;
     /**
-     * Unloads the enabled plugins.
+     * Unsubscribes from lyrics for a player.
+     * @param {string} guildId - The ID of the guild to unsubscribe from lyrics for.
+     * @returns {Promise<unknown>} A promise that resolves when the unsubscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
      */
-    private unloadPlugins;
+    lyricsUnsubscribe(guildId: string): Promise<unknown>;
     /**
-     * Clears all player states from the file system.
-     * This is done to prevent stale state files from accumulating on the file system.
+     * 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
      */
-    private clearAllStoredPlayers;
+    protected trackStuck(player: Player, track: Track, payload: TrackStuckEvent): Promise<void>;
     /**
-     * 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>}
+     * 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
      */
-    private get leastLoadNode();
+    protected trackError(player: Player, track: Track, payload: TrackExceptionEvent): Promise<void>;
     /**
-     * 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.
+     * 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.
      */
-    private get leastPlayersNode();
+    protected socketClosed(player: Player, payload: WebSocketClosedEvent): void;
     /**
-     * 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.
+     * 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 get priorityNode();
-    protected send(packet: GatewayVoiceStateUpdate): unknown;
-    sendPacket(packet: GatewayVoiceStateUpdate): unknown;
-}
-
-declare class Player {
-    options: PlayerOptions;
-    /** The Queue for the Player. */
-    queue: IQueue;
-    /** The filters applied to the audio. */
-    filters: Filters;
-    /** Whether the queue repeats the track. */
-    trackRepeat: boolean;
-    /** Whether the queue repeats the queue. */
-    queueRepeat: boolean;
-    /**Whether the queue repeats and shuffles after each song. */
-    dynamicRepeat: boolean;
-    /** The time the player is in the track. */
-    position: number;
-    /** Whether the player is playing. */
-    playing: boolean;
-    /** Whether the player is paused. */
-    paused: boolean;
-    /** The volume for the player */
-    volume: number;
-    /** The Node for the Player. */
-    node: Node;
-    /** The guild ID for the player. */
-    guildId: string;
-    /** The voice channel for the player. */
-    voiceChannelId: string | null;
-    /** The text channel for the player. */
-    textChannelId: string | null;
-    /**The now playing message. */
-    nowPlayingMessage?: Message;
-    /** The current state of the player. */
-    state: StateTypes;
-    /** The equalizer bands array. */
-    bands: number[];
-    /** The voice state object from Discord. */
-    voiceState: VoiceState;
-    /** The Manager. */
-    manager: Manager;
-    /** The autoplay state of the player. */
-    isAutoplay: boolean;
-    /** The number of times to try autoplay before emitting queueEnd. */
-    autoplayTries: number;
-    /** The cluster ID for the player. */
-    clusterId: number;
-    private readonly data;
-    private dynamicLoopInterval;
-    dynamicRepeatIntervalMs: number | null;
-    private static _manager;
-    /** Should only be used when the node is a NodeLink */
-    protected voiceReceiverWsClient: WebSocket$1 | null;
-    protected isConnectToVoiceReceiver: boolean;
-    protected voiceReceiverReconnectTimeout: NodeJS.Timeout | null;
-    protected voiceReceiverAttempt: number;
-    protected voiceReceiverReconnectTries: number;
+    private sponsorBlockSegmentLoaded;
     /**
-     * Creates a new player, returns one if it already exists.
-     * @param options The player options.
-     * @see https://docs.magmastream.com/main/introduction/getting-started
+     * 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.
      */
-    constructor(options: PlayerOptions);
+    private sponsorBlockSegmentSkipped;
     /**
-     * Initializes the static properties of the Player class.
-     * @hidden
-     * @param manager The Manager to use.
+     * 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.
      */
-    static init(manager: Manager): void;
+    private sponsorBlockChaptersLoaded;
     /**
-     * Set custom data.
-     * @param key - The key to set the data for.
-     * @param value - The value to set the data to.
+     * 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.
      */
-    set(key: string, value: unknown): void;
+    private sponsorBlockChapterStarted;
     /**
-     * Retrieves custom data associated with a given key.
-     * @template T - The expected type of the data.
-     * @param {string} key - The key to retrieve the data for.
-     * @returns {T} - The data associated with the key, cast to the specified type.
+     * Emitted when lyrics for a track are found.
+     * The payload of the event will contain the lyrics.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsFoundEvent} payload - The event payload containing additional data about the lyrics found event.
      */
-    get<T>(key: string): T;
+    private lyricsFound;
     /**
-     * Same as Manager#search() but a shortcut on the player itself.
-     * @param query
-     * @param requester
+     * Emitted when lyrics for a track are not found.
+     * The payload of the event will contain the track.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsNotFoundEvent} payload - The event payload containing additional data about the lyrics not found event.
      */
-    search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
+    private lyricsNotFound;
     /**
-     * Connects the player to the voice channel.
-     * @throws {RangeError} If no voice channel has been set.
-     * @returns {void}
+     * Emitted when a line of lyrics for a track is received.
+     * The payload of the event will contain the lyrics line.
+     * @param {Player} player - The player associated with the lyrics line.
+     * @param {Track} track - The track associated with the lyrics line.
+     * @param {LyricsLineEvent} payload - The event payload containing additional data about the lyrics line event.
      */
-    connect(): Promise<void>;
+    private lyricsLine;
     /**
-     * Disconnects the player from the voice channel.
-     * @returns {this} The player instance.
+     * Fetches Lavalink node information.
+     * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.
      */
-    disconnect(): Promise<this>;
+    fetchInfo(): Promise<LavalinkInfo>;
     /**
-     * Destroys the player and clears the queue.
-     * @param {boolean} disconnect - Whether to disconnect the player from the voice channel.
-     * @returns {Promise<boolean>} - Whether the player was successfully destroyed.
-     * @emits {PlayerDestroy} - Emitted when the player is destroyed.
-     * @emits {PlayerStateUpdate} - Emitted when the player state is updated.
+     * 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.
      */
-    destroy(disconnect?: boolean): Promise<boolean>;
+    getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
     /**
-     * Sets the player voice channel.
-     * @param {string} channel - The new voice channel ID.
-     * @returns {this} - The player instance.
-     * @throws {TypeError} If the channel parameter is not a string.
+     * 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]);
+     * ```
      */
-    setVoiceChannelId(channel: string): this;
+    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
     /**
-     * Sets the player text channel.
-     *
-     * This method updates the text channel associated with the player. It also
-     * emits a player state update event indicating the change in the channel.
-     *
-     * @param {string} channel - The new text channel ID.
-     * @returns {this} - The player instance for method chaining.
-     * @throws {TypeError} If the channel parameter is not a string.
+     * 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.
      */
-    setTextChannelId(channel: string): this;
+    deleteSponsorBlock(player: Player): Promise<void>;
     /**
-     * Sets the now playing message.
-     *
-     * @param message - The message of the now playing message.
-     * @returns The now playing message.
+     * 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
      */
-    setNowPlayingMessage<T = Message>(message: T): Message;
+    private createReadmeFile;
+}
+
+/**
+ * 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>;
+    /** The options that were set. */
+    readonly options: ManagerOptions;
+    initiated: boolean;
+    redis?: Redis;
+    private _send;
+    private loadedPlugins;
     /**
-     * Plays the next track.
-     *
-     * If a track is provided, it will be played. Otherwise, the next track in the queue will be played.
-     * If the queue is not empty, but the current track has not finished yet, it will be replaced with the provided track.
-     *
-     * @param {object} [optionsOrTrack] - The track to play or the options to play with.
-     * @param {object} [playOptions] - The options to play with.
-     *
-     * @returns {Promise<void>}
+     * 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.
      */
-    play(): Promise<Player>;
-    play(track: Track): Promise<Player>;
-    play(options: PlayOptions): Promise<Player>;
-    play(track: Track, options: PlayOptions): Promise<Player>;
+    constructor(options: ManagerOptions);
     /**
-     * Sets the autoplay-state of the player.
-     *
-     * Autoplay is a feature that makes the player play a recommended
-     * track when the current track ends.
-     *
-     * @param {boolean} autoplayState - Whether or not autoplay should be enabled.
-     * @param {object} botUser - The user-object that should be used as the bot-user.
-     * @param {number} [tries=3] - The number of times the player should try to find a
-     * recommended track if the first one doesn't work.
-     * @returns {this} - The player instance.
+     * 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): Promise<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;
+    /**
+     * Creates a player or returns one if it already exists.
+     * @param options The options to create the player with.
+     * @returns The created player.
      */
-    setAutoplay<T = unknown>(autoplayState: boolean, botUser?: T, tries?: number): this;
+    create(options: PlayerOptions): Player;
     /**
-     * Gets recommended tracks and returns an array of tracks.
-     * @param {Track} track - The track to find recommendations for.
-     * @returns {Promise<Track[]>} - Array of recommended tracks.
+     * Destroys a player.
+     * @param guildId The guild ID of the player to destroy.
+     * @returns A promise that resolves when the player has been destroyed.
      */
-    getRecommendedTracks(track: Track): Promise<Track[]>;
+    destroy(guildId: string): Promise<void>;
     /**
-     * Sets the volume of the player.
-     * @param {number} volume - The new volume. Must be between 0 and 1000.
-     * @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.
-     * @emits {PlayerStateUpdate} - Emitted when the volume is changed.
-     * @example
-     * player.setVolume(50);
-     * player.setVolume(50, { gradual: true, interval: 50, step: 5 });
+     * 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.
      */
-    setVolume(volume: number): Promise<this>;
+    createNode(options: NodeOptions): Node;
     /**
-     * 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.
-     * @returns {Promise<void>} The promise is resolved when the operation is complete.
+     * 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.
      */
-    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    destroyNode(identifier: string): Promise<void>;
     /**
-     * Gets the sponsorblock for the player.
-     * @returns {Promise<SponsorBlockSegment[]>} The sponsorblock segments.
+     * 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.
      */
-    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    on<T extends keyof ManagerEvents>(event: T, listener: (...args: ManagerEvents[T]) => void): this;
     /**
-     * Deletes the sponsorblock for the player. This will remove all sponsorblock segments that have been set for the player.
-     * @returns {Promise<void>}
+     * 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.
      */
-    deleteSponsorBlock(): Promise<void>;
+    updateVoiceState(data: VoicePacket | VoiceServer | VoiceState): Promise<void>;
     /**
-     * Sets the track repeat mode.
-     * When track repeat is enabled, the current track will replay after it ends.
-     * Disables queueRepeat and dynamicRepeat modes if enabled.
-     *
-     * @param repeat - A boolean indicating whether to enable track repeat.
-     * @returns {this} - The player instance.
-     * @throws {TypeError} If the repeat parameter is not a boolean.
+     * 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.
      */
-    setTrackRepeat(repeat: boolean): this;
+    decodeTracks(tracks: string[]): Promise<TrackData[]>;
     /**
-     * Sets the queue repeat.
-     * @param repeat Whether to repeat the queue or not
-     * @returns {this} - The player instance.
-     * @throws {TypeError} If the repeat parameter is not a boolean
+     * 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.
      */
-    setQueueRepeat(repeat: boolean): this;
+    decodeTrack(track: string): Promise<TrackData>;
     /**
-     * Sets the queue to repeat and shuffles the queue after each song.
-     * @param repeat "true" or "false".
-     * @param ms After how many milliseconds to trigger dynamic repeat.
-     * @returns {this} - The player instance.
-     * @throws {TypeError} If the repeat parameter is not a boolean.
-     * @throws {RangeError} If the queue size is less than or equal to 1.
+     * Saves player states.
+     * @param {string} guildId - The guild ID of the player to save
      */
-    setDynamicRepeat(repeat: boolean, ms: number): Promise<this>;
+    savePlayerState(guildId: string): Promise<void>;
     /**
-     * Restarts the currently playing track from the beginning.
-     * If there is no track playing, it will play the next track in the queue.
-     * @returns {Promise<Player>} The current instance of the Player class for method chaining.
+     * 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.
      */
-    restart(): Promise<Player>;
+    private sleep;
     /**
-     * Stops the player and optionally removes tracks from the queue.
-     * @param {number} [amount] The amount of tracks to remove from the queue. If not provided, removes the current track if it exists.
-     * @returns {Promise<this>} - The player instance.
-     * @throws {RangeError} If the amount is greater than the queue length.
+     * 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.
      */
-    stop(amount?: number): Promise<this>;
+    loadPlayerStates(nodeId: string): Promise<void>;
     /**
-     * Skips the current track.
-     * @returns {this} - The player instance.
-     * @throws {Error} If there are no tracks in the queue.
-     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
+     * 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.
      */
-    pause(pause: boolean): Promise<this>;
+    get useableNode(): Node;
     /**
-     * Skips to the previous track in the queue.
-     * @returns {this} - The player instance.
-     * @throws {Error} If there are no previous tracks in the queue.
-     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
+     * 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.
      */
-    previous(): Promise<this>;
+    handleShutdown(): Promise<void>;
     /**
-     * Seeks to a given position in the currently playing track.
-     * @param position - The position in milliseconds to seek to.
-     * @returns {this} - The player instance.
-     * @throws {Error} If the position is invalid.
-     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
+     * 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.
      */
-    seek(position: number): Promise<this>;
+    private parseYouTubeTitle;
     /**
-     * Returns the current repeat state of the player.
-     * @param player The player to get the repeat state from.
-     * @returns The repeat state of the player, or null if it is not repeating.
+     * 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 getRepeatState;
+    private balanceBrackets;
     /**
-     * Automatically moves the player to a usable node.
-     * @returns {Promise<Player | void>} - The player instance or void if not moved.
+     * Escapes a string by replacing special regex characters with their escaped counterparts.
+     * @param string - The string to escape.
+     * @returns The escaped string.
      */
-    autoMoveNode(): Promise<Player | void>;
+    private escapeRegExp;
     /**
-     * Moves the player to another node.
-     * @param {string} identifier - The identifier of the node to move to.
-     * @returns {Promise<Player>} - The player instance after being moved.
+     * Checks if the given data is a voice update.
+     * @param data The data to check.
+     * @returns Whether the data is a voice update.
      */
-    moveNode(identifier: string): Promise<Player>;
+    private isVoiceUpdate;
     /**
-     * Transfers the player to a new server. If the player already exists on the new server
-     * and force is false, this method will return the existing player. Otherwise, a new player
-     * will be created and the current player will be destroyed.
-     * @param {PlayerOptions} newOptions - The new options for the player.
-     * @param {boolean} force - Whether to force the creation of a new player.
-     * @returns {Promise<Player>} - The new player instance.
+     * 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.
      */
-    switchGuild(newOptions: PlayerOptions, force?: boolean): Promise<Player>;
+    private isValidUpdate;
     /**
-     * Retrieves the current lyrics for the playing track.
-     * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.
-     * @returns {Promise<Lyrics>} - The lyrics of the current track.
-     * @throws {RangeError} - If the 'lavalyrics-plugin' is not available on the Lavalink node.
+     * 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.
      */
-    getCurrentLyrics(skipTrackSource?: boolean): Promise<Lyrics>;
+    private handleVoiceServerUpdate;
     /**
-     * Sets up the voice receiver for the player.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver is set up.
-     * @throws {Error} - If the node is not a NodeLink.
+     * 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.
      */
-    setupVoiceReceiver(): Promise<void>;
+    private handleVoiceStateUpdate;
     /**
-     * Removes the voice receiver for the player.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver is removed.
-     * @throws {Error} - If the node is not a NodeLink.
+     * Cleans up inactive players by removing their state files from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
      */
-    removeVoiceReceiver(): Promise<void>;
+    cleanupInactivePlayers(): Promise<void>;
     /**
-     * Closes the voice receiver for the player.
-     * @param {number} code - The code to close the voice receiver with.
-     * @param {string} reason - The reason to close the voice receiver with.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver is closed.
+     * Cleans up an inactive player by removing its state data.
+     * This is done to prevent stale state data from accumulating.
+     * @param guildId The guild ID of the player to clean up.
      */
-    private closeVoiceReceiver;
+    cleanupInactivePlayer(guildId: string): Promise<void>;
     /**
-     * Reconnects the voice receiver for the player.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver is reconnected.
+     * Loads the enabled plugins.
      */
-    private reconnectVoiceReceiver;
+    private loadPlugins;
     /**
-     * Disconnects the voice receiver for the player.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver is disconnected.
+     * Unloads the enabled plugins.
      */
-    private disconnectVoiceReceiver;
+    private unloadPlugins;
     /**
-     * Opens the voice receiver for the player.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver is opened.
+     * Clears all player states from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
      */
-    private openVoiceReceiver;
+    private clearAllStoredPlayers;
     /**
-     * Handles a voice receiver message.
-     * @param {string} payload - The payload to handle.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
+     * 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 onVoiceReceiverMessage;
+    private get leastLoadNode();
     /**
-     * Handles a voice receiver error.
-     * @param {Error} error - The error to handle.
-     * @returns {Promise<void>} - A promise that resolves when the voice receiver error is handled.
+     * 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 onVoiceReceiverError;
+    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 Filters {
     distortion: DistortionOptions | null;
     equalizer: Band[];
     karaoke: KaraokeOptions | null;
+    manager: Manager;
     player: Player;
     rotation: RotationOptions | null;
     timescale: TimescaleOptions | null;
@@ -2974,7 +3008,7 @@ declare class Filters {
     volume: number;
     bassBoostlevel: number;
     filtersStatus: Record<AvailableFilters, boolean>;
-    constructor(player: Player);
+    constructor(player: Player, manager: Manager);
     /**
      * Updates the player's audio filters.
      *
@@ -2999,6 +3033,7 @@ declare class Filters {
      * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
      */
     private applyFilter;
+    private emitPlayersTasteUpdate;
     /**
      * Sets the status of a specific filter.
      *