hoshimi 0.3.1 → 0.3.5

package/dist/index.d.mts

@@ -648,2697 +648,2828 @@ interface EnabledDSPXPluginFilters {
 }
 
 /**
- * Class representing a LyricsManager.
- * @class LyricsManager
+ * Class representing a storage manager.
+ * @abstract
+ * @class StorageManager
+ * @example
+ * ```ts
+ * class MyStorageManager extends StorageManager {};
+ *
+ * const storage = new MyStorageManager();
+ * storage.set("key", "value");
+ *
+ * const value = await storage.get("key");
+ * console.log(value); // "value"
+ * ```
  */
-declare class LyricsManager {
+declare abstract class StorageAdapter<T extends QueueJson = QueueJson> {
     /**
-     * The node instance.
-     * @type {NodeStructure}
-     * @readonly
+     *
+     * Get the value using the key.
+     * @param {string} key The key to get the value from.
+     * @returns {Awaitable<T | undefined>} The value of the key.
+     * @example
+     * ```ts
+     * const value = await storage.get("key");
+     * console.log(value); // "value"
+     * ```
      */
-    readonly node: NodeStructure;
+    abstract get(key: string): Awaitable<T | undefined>;
     /**
-     * Create a new LyricsManager instance.
-     * @param {NodeStructure} node The node instance.
+     *
+     * Set the value using the key.
+     * @param {string} key The key to set the value to.
+     * @param {unknown} value The value to set.
+     * @returns {Awaitable<void>} Did you know this can be async?
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * const lyricsManager = new LyricsManager(node);
+     * await storage.set("key", "value");
      * ```
      */
-    constructor(node: NodeStructure);
+    abstract set(key: string, value: T): Awaitable<void>;
     /**
      *
-     * Get the current lyrics for the current track.
-     * @param {boolean} skipSource Whether to skip the track source or not.
-     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+     * Delete the value using the key.
+     * @param {string} key The key to delete the value from.
+     * @returns {Awaitable<boolean>} Returns true if the key was deleted.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const lyrics = await player.lyricsManager.current();
+     * const success = await storage.delete("key");
+     * console.log(success); // true
      * ```
      */
-    current(guildId: string, skipSource?: boolean): Promise<LyricsResult | null>;
+    abstract delete(key: string): Awaitable<boolean>;
     /**
-     *
-     * Get the lyrics for a specific track.
-     * @param {Track} track The track to get the lyrics for.
-     * @param {boolean} skipSource Whether to skip the track source or not.
-     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+     * Clear the storage.
+     * @returns {Awaitable<void>} Scary, right?
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * const lyrics = await node.lyricsManager.get(track);
+     * await storage.clear();
      * ```
      */
-    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    abstract clear(): Awaitable<void>;
+    /**
+     * Check if the storage has the key.
+     * @param {string} key The key to check.
+     * @returns {Awaitable<boolean>} Return true if the key exists.
+     * @example
+     * ```ts
+     * const exists = await storage.has("key");
+     * console.log(exists); // true
+     * ```
+     */
+    abstract has(key: string): Awaitable<boolean>;
     /**
      *
-     * Subscribe to the lyrics for a specific guild.
-     * @param {string} guildId The guild id to subscribe to.
-     * @param {boolean} skipSource Whether to skip the track source or not.
-     * @returns {Promise<void>} Let's start the sing session!
+     * Parse the value.
+     * @param {unknown} value The value to parse.
+     * @returns {T} The parsed value.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * await node.lyricsManager.subscribe("guildId");
+     * const parsed = await storage.parse<{ key: string }>("{'key':'value'}");
+     * console.log(parsed); // { key: "value" }
      * ```
      */
-    subscribe(guildId: string, skipSource?: boolean): Promise<void>;
+    abstract parse(value: unknown): Awaitable<T>;
     /**
      *
-     * Unsubscribe from the lyrics for a specific guild.
-     * @param {string} guildId The guild id to unsubscribe from.
-     * @returns {Promise<void>} Let's stop the sing session!
+     * Stringify the value.
+     * @param {unknown} value The value to stringify.
+     * @returns {R} The stringified value.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * await node.lyricsManager.unsubscribe("guildId");
+     * const stringified = await storage.stringify({ key: "value" });
+     * console.log(stringified); // "{'key':'value'}"
      * ```
      */
-    unsubscribe(guildId: string): Promise<void>;
+    abstract stringify<R = string>(value: unknown): Awaitable<R>;
 }
 
 /**
- * Represents a collection that extends the built-in Map class.
- * @template K The type of the keys in the collection.
- * @template V The type of the values in the collection.
+ * The queue options.
  */
-declare class Collection<K, V> extends Map<K, V> {
+interface HoshimiQueueOptions {
     /**
-     * Removes elements from the collection based on a filter function.
-     * @param fn The filter function that determines which elements to remove.
-     * @param thisArg The value to use as `this` when executing the filter function.
-     * @returns The number of elements removed from the collection.
-     * @example
-     * const collection = new Collection<number, string>();
-     * collection.set(1, 'one');
-     * collection.set(2, 'two');
-     * collection.set(3, 'three');
-     * const removedCount = collection.sweep((value, key) => key % 2 === 0);
-     * console.log(removedCount); // Output: 1
-     * console.log(collection.size); // Output: 2
+     * The maximum amount of tracks that can be saved in the queue.
+     * @type {number}
+     * @default 25
      */
-    sweep(fn: (value: V, key: K, collection: this) => unknown): number;
+    maxHistory?: number;
     /**
-     * Creates a new array with the results of calling a provided function on every element in the collection.
-     * @param fn The function that produces an element of the new array.
-     * @param thisArg The value to use as `this` when executing the map function.
-     * @returns A new array with the results of calling the provided function on every element in the collection.
-     * @example
-     * const collection = new Collection<number, string>();
-     * collection.set(1, 'one');
-     * collection.set(2, 'two');
-     * collection.set(3, 'three');
-     * const mappedArray = collection.map((value, key) => `${key}: ${value}`);
-     * console.log(mappedArray); // Output: ['1: one', '2: two', '3: three']
+     *
+     * The function to use for autoplay.
+     * @param {Player} player The player.
+     * @param {HoshimiTrack | null} lastTrack The last track played.
      */
-    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    autoplayFn?(player: PlayerStructure, lastTrack: HoshimiTrack | null): Awaitable<void>;
     /**
-     * Creates a new array with all elements that pass the test implemented by the provided function.
-     * @param fn The function to test each element of the collection.
-     * @param thisArg The value to use as `this` when executing the filter function.
-     * @returns A new array with the elements that pass the test.
-     * @example
-     * const collection = new Collection<number, string>();
-     * collection.set(1, 'one');
-     * collection.set(2, 'two');
-     * collection.set(3, 'three');
-     * const filteredArray = collection.filter((value, key) => key % 2 === 0);
-     * console.log(filteredArray); // Output: ['two']
+     * Enable the auto play for the queue. (By default, only supports `youtube` and `spotify`, add more with your own function)
+     * @type {boolean}
+     * @default false
      */
-    filter(fn: (value: V, key: K, collection: this) => boolean): V[];
+    autoPlay?: boolean;
     /**
-     * Returns the value of the first element in the collection that satisfies the provided testing function.
-     * @param fn The function to test each element of the collection.
-     * @returns The value of the first element that passes the test. `undefined` if no element passes the test.
-     * @example
-     * const collection = new Collection<number, number>();
-     * collection.set(1, 1);
-     * collection.set(2, 2);
-     * collection.set(3, 3);
-     * const firstEvenValue = collection.find(value => value % 2 === 0);
-     * console.log(firstEvenValue); // Output: 2
+     * The storage manager to use for the queue.
+     * @type {StorageAdapter}
+     * @default {MemoryAdapter}
      */
-    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+    storage?: StorageAdapter;
 }
-
 /**
- * Class representing a node manager.
- * @class NodeManager
+ * The queue json.
  */
-declare class NodeManager {
+interface QueueJson {
     /**
-     * The manager for the node.
-     * @type {Hoshimi}
-     * @readonly
+     * The tracks of the queue.
+     * @type {HoshimiTrack[]}
      */
-    readonly manager: Hoshimi;
+    tracks: HoshimiTrack[];
     /**
-     * The nodes for the manager.
-     * @type {Collection<string, Node>}
-     * @readonly
+     * The previous tracks of the queue.
+     * @type {Track[]}
      */
-    readonly nodes: Collection<string, NodeStructure>;
+    history: Track[];
     /**
-     *
-     * The constructor for the node manager.
-     * @param {Hoshimi} manager The manager for the node.
-     * @example
-     * ```ts
-     * const manager = new Hoshimi();
-     * const nodeManager = new NodeManager(manager);
-     *
-     * console.log(nodeManager.nodes.size); // 0
-     * ```
+     * The current track of the queue.
+     * @type {Track | null}
      */
-    constructor(manager: Hoshimi);
+    current: Track | null;
+}
+
+/**
+ * Partial Lavalink track type.
+ */
+type PartialLavalinkTrack = Partial<Nullable<LavalinkTrack>>;
+/**
+ * The base options for playing a track.
+ */
+interface BasePlayOptions {
     /**
-     *
-     * Delete the node.
-     * @param {NodeIdentifier} node The node or node id to delete.
-     * @returns {boolean} If the node was deleted.
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) manager.nodeManager.delete(node.id); // true if the node was deleted
-     * ```
+     * The position to start the track.
+     * @type {number | undefined}
      */
-    delete(node: NodeIdentifier): boolean;
+    position?: number;
     /**
-     *
-     * Get the node by id.
-     * @param {NodeIdentifier} node The node or node id to get.
-     * @returns {NodeStructure | undefined} The node or undefined if not found.
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) {
-     * 	console.log(node.id); // node1
-     * } else {
-     * 	console.log("Node not found");
-     * }
-     * ```
+     * The position to end the track.
+     * @type {number | undefined}
      */
-    get(node: NodeIdentifier): NodeStructure | undefined;
+    endTime?: number;
     /**
-     *
-     * Create a new node.
-     * @param {NodeOptions} options The options for the node.
-     * @returns {NodeStructure} The created node.
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.create({
-     * 	host: "localhost",
-     * 	port: 2333,
-     * 	password: "password",
-     * 	secure: false,
-     * });
-     *
-     * console.log(node.id); // localhost:2333
-     */
-    create(options: NodeOptions): NodeStructure;
-    /**
-     *
-     * Destroy a node.
-     * @param {NodeIdentifier} node The node or node id to destroy.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.destroy();
-     * ```
-     */
-    destroy(node: NodeIdentifier): void;
-    /**
-     *
-     * Reconnect a node.
-     * @param {NodeIdentifier} node The node or node id to reconnect.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.reconnect();
-     * ```
-     */
-    reconnect(node: NodeIdentifier): void;
-    /**
-     *
-     * Disconnect a node.
-     * @param {NodeIdentifier} node The node or node id to disconnect.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.disconnect();
-     * ```
+     * The pause state of the player.
+     * @type {boolean | undefined}
      */
-    disconnect(node: NodeIdentifier): void;
+    paused?: boolean;
     /**
-     *
-     * Connect a node.
-     * @param {NodeIdentifier} node The node or node id to connect.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.connect();
-     * ```
+     * The volume of the player.
+     * @type {number | undefined}
      */
-    connect(node: NodeIdentifier): void;
+    volume?: number;
     /**
-     *
-     * Get the least used node.
-     * @returns {NodeStructure} The least used node.
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.getLeastUsed();
-     * if (node) {
-     * 	console.log(node.id); // node1
-     * 	console.log(node.penalties); // the penalties of the node
-     * 	console.log(node.state); // the state of the node
-     * }
-     * ```
+     * The filters for the player.
+     * @type {Partial<FilterSettings> | undefined}
      */
-    getLeastUsed(sortType?: NodeSortTypes): NodeStructure;
+    filters?: Partial<FilterSettings>;
     /**
-     *
-     * Reconnect the nodes.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.reconnectAll();
-     * ```
+     * The voice settings for the player.
+     * @type {LavalinkPlayerVoice | undefined}
      */
-    reconnectAll(): void;
+    voice?: LavalinkPlayerVoice;
+}
+/**
+ * The types of loop modes.
+ */
+declare enum LoopMode {
     /**
-     * Disconnect the nodes.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.disconnectAll();
-     * ```
+     * Loop mode for repeating the current track.
      */
-    disconnectAll(): void;
+    Track = 1,
     /**
-     * Connect the nodes.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.connect();
-     * ```
+     * Loop mode for repeating the queue.
      */
-    connectAll(): void;
+    Queue = 2,
     /**
-     * Destroy the nodes.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.destroy();
-     * ```
+     * Loop mode for repeating nothing.
      */
-    destroyAll(): void;
+    Off = 3
 }
-
 /**
- * The methods for http requests
+ * The types of player events.
  */
-declare enum HttpMethods {
+declare enum PlayerEventType {
     /**
-     * The GET method requests a representation of the specified resource. Requests using GET should only retrieve data.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET
-     * @type {string}
+     * Event type for when a track starts.
      */
-    Get = "GET",
+    TrackStart = "TrackStartEvent",
     /**
-     * The POST method is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST
-     * @type {string}
+     * Event type for when a track ends.
      */
-    Post = "POST",
+    TrackEnd = "TrackEndEvent",
     /**
-     * The PUT method replaces all current representations of the target resource with the request payload.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT
-     * @type {string}
+     * Event type for when a track encounters an exception.
      */
-    Put = "PUT",
+    TrackException = "TrackExceptionEvent",
     /**
-     * The PATCH method is used to apply partial modifications to a resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH
-     * @type {string}
+     * Event type for when a track gets stuck.
      */
-    Patch = "PATCH",
+    TrackStuck = "TrackStuckEvent",
     /**
-     * The DELETE method deletes the specified resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE
-     * @type {string}
+     * Event type for when lyrics are found.
      */
-    Delete = "DELETE",
+    LyricsFound = "LyricsFoundEvent",
     /**
-     * The HEAD method asks for a response identical to that of a GET request, but without the response body.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD
-     * @type {string}
+     * Event type for when lyrics are not found.
      */
-    Head = "HEAD"
-}
-declare enum RestPathType {
+    LyricsNotFound = "LyricsNotFoundEvent",
     /**
-     * The raw path of the request.
-     * @type {string}
+     * Event type for when a lyrics line is sent.
      */
-    Raw = "/",
+    LyricsLine = "LyricsLineEvent",
     /**
-     * The versioned path v4 of the request.
-     * @type {string}
+     * Event type for when the WebSocket connection is closed.
      */
-    V4 = "/v4"
+    WebsocketClosed = "WebSocketClosedEvent"
 }
 /**
- * The status codes for the REST.
- * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+ * The reasons a track can end.
  */
-declare enum HttpStatusCodes {
+declare enum TrackEndReason {
     /**
-     * The request has succeeded.
-     * @type {number}
+     * The track ended normally.
      */
-    OK = 200,
+    Finished = "finished",
     /**
-     * The request has been fulfilled and resulted in a new resource being created.
-     * @type {number}
+     * The track fails to load.
      */
-    Created = 201,
+    LoadFailed = "loadFailed",
     /**
-     * The request has been accepted for processing, but the processing has not been completed.
-     * @type {number}
+     * The track was stopped.
      */
-    Accepted = 202,
+    Stopped = "stopped",
     /**
-     * The server successfully processed the request, but is not returning any content.
-     * @type {number}
+     * The track was replaced.
      */
-    NoContent = 204,
+    Replaced = "replaced",
     /**
-     * The resource has been moved permanently to a new URI.
-     * @type {number}
+     * The track was cleaned up.
      */
-    MovedPermanently = 301,
+    Cleanup = "cleanup"
+}
+/**
+ * The options for automatic player error handling.
+ */
+interface ErrorPlayerActions {
     /**
-     * The requested resource has been found at a different URI.
-     * @type {number}
+     * Whether to automatically destroy the player on error.
+     * @type {boolean | undefined}
+     * @default false
      */
-    Found = 302,
+    autoDestroy?: boolean;
     /**
-     * The resource has not been modified since the last request.
-     * @type {number}
+     * Whether to automatically skip the track on error.
+     * @type {boolean | undefined}
+     * @default false
      */
-    NotModified = 304,
+    autoSkip?: boolean;
     /**
-     * The request cannot be processed due to bad syntax.
-     * @type {number}
+     * Whether to automatically stop the player on error.
+     * @type {boolean | undefined}
+     * @default false
      */
-    BadRequest = 400,
+    autoStop?: boolean;
+}
+/**
+ * The options for error actions.
+ */
+interface DisconnectPlayerActions extends Pick<ErrorPlayerActions, "autoDestroy"> {
     /**
-     * The request requires user authentication.
-     * @type {number}
+     * Whether to automatically reconnect on disconnect.
+     * @type {boolean | undefined}
+     * @default false
      */
-    Unauthorized = 401,
+    autoReconnect?: boolean;
     /**
-     * The request was valid, but the server is refusing action.
-     * @type {number}
+     * Whether to automatically add tracks back to the queue on disconnect.
+     * @type {boolean | undefined}
+     * @default false
      */
-    Forbidden = 403,
+    autoQueue?: boolean;
+}
+/**
+ * The Hoshimi player options.
+ */
+interface HoshimiPlayerOptions {
     /**
-     * The server cannot find the requested resource.
-     * @type {number}
+     *
+     * The function to use to get the requester data.
+     * @param {TrackRequester} requester The requester of the track.
      */
-    NotFound = 404,
+    requesterFn?<T extends TrackRequester = TrackRequester>(requester: TrackRequester): Awaitable<T>;
     /**
-     * The request method is known by the server but has been disabled and cannot be used.
-     * @type {number}
+     * The options for handling errors.
+     * @type {ErrorPlayerActions | undefined}
      */
-    MethodNotAllowed = 405,
+    onError?: ErrorPlayerActions;
     /**
-     * The server timed out waiting for the request.
-     * @type {number}
+     * The options for handling disconnects.
+     * @type {DisconnectPlayerActions | undefined}
      */
-    RequestTimeout = 408,
+    onDisconnect?: DisconnectPlayerActions;
+}
+/**
+ * The base interface for player events.
+ */
+interface PlayerEvent {
     /**
-     * The request could not be completed due to a conflict with the current state of the resource.
-     * @type {number}
-     */
-    Conflict = 409,
-    /**
-     * The requested resource is no longer available and will not be available again.
-     * @type {number}
-     */
-    Gone = 410,
-    /**
-     * The user has sent too many requests in a given amount of time.
-     * @type {number}
-     */
-    TooManyRequests = 429,
-    /**
-     * A generic error message, given when no more specific message is suitable.
-     * @type {number}
-     */
-    InternalServerError = 500,
-    /**
-     * The server does not recognize the request method or lacks the ability to fulfill it.
-     * @type {number}
+     * The operation code for the event.
+     * @type {OpCodes.Event}
      */
-    NotImplemented = 501,
+    op: OpCodes.Event;
     /**
-     * The server was acting as a gateway and received an invalid response.
-     * @type {number}
+     * The guild ID associated with the event.
+     * @type {string}
      */
-    BadGateway = 502,
+    guildId: string;
+}
+/**
+ * The event for when a track starts playing.
+ */
+interface TrackStartEvent extends PlayerEvent {
     /**
-     * The server is currently unavailable (overloaded or down).
-     * @type {number}
+     * The type of the event.
+     * @type {PlayerEventType.TrackStart}
      */
-    ServiceUnavailable = 503,
+    type: PlayerEventType.TrackStart;
     /**
-     * The server did not receive a timely response from an upstream server.
-     * @type {number}
+     * The track that started playing.
+     * @type {LavalinkTrack}
      */
-    GatewayTimeout = 504
+    track: LavalinkTrack;
 }
 /**
- * The options for the REST.
+ * The event for when a track ends.
  */
-interface RestOptions {
+interface TrackEndEvent extends PlayerEvent {
     /**
-     * The endpoint for the REST.
-     * @type {string}
+     * The type of the event.
+     * @type {PlayerEventType.TrackEnd}
      */
-    endpoint: `/${string}`;
+    type: PlayerEventType.TrackEnd;
     /**
-     * The method for the REST.
-     * @type {HttpMethods}
+     * The track that ended.
+     * @type {LavalinkTrack}
      */
-    method?: HttpMethods;
+    track: LavalinkTrack;
     /**
-     * The headers for the REST.
-     * @type {Record<string, string>}
+     * The reason the track ended.
+     * @type {TrackEndReason}
      */
-    headers?: Record<string, string>;
+    reason: TrackEndReason;
+}
+/**
+ * The event for when a track gets stuck.
+ */
+interface TrackStuckEvent extends PlayerEvent {
     /**
-     * The body for the REST.
-     * @type {Record<string, unknown> | string | undefined}
+     * The type of the event.
+     * @type {PlayerEventType.TrackStuck}
      */
-    body?: Record<string, unknown> | string;
+    type: PlayerEventType.TrackStuck;
     /**
-     * The query parameters for the REST.
-     * @type {Record<string, string>}
+     * The track that got stuck.
+     * @type {LavalinkTrack}
      */
-    params?: Record<string, string>;
+    track: LavalinkTrack;
     /**
-     * The path type for the REST.
-     * @type {RestPathType}
+     * The threshold in milliseconds.
+     * @type {number}
      */
-    pathType?: RestPathType;
+    thresholdMs: number;
 }
 /**
- * The fetch options for the request.
+ * The event for when a track encounters an exception.
  */
-interface FetchOptions extends Omit<RestOptions, "endpoint" | "body"> {
+interface TrackExceptionEvent extends PlayerEvent {
     /**
-     * The signal for the request.
+     * The type of the event.
+     * @type {PlayerEventType.TrackException}
      */
-    signal: AbortSignal;
+    type: PlayerEventType.TrackException;
     /**
-     * The stringified body for the request.
+     * The exception that occurred.
+     * @type {Exception}
      */
-    body?: string;
+    exception: Exception;
 }
 /**
- * The error for the REST.
+ * The event for when the WebSocket connection is closed.
  */
-interface LavalinkRestError {
+interface WebSocketClosedEvent extends PlayerEvent {
     /**
-     * The timestamp for the REST.
-     * @type {number}
+     * The type of the event.
+     * @type {PlayerEventType.WebsocketClosed}
      */
-    timestamp: number;
+    type: PlayerEventType.WebsocketClosed;
     /**
-     * The status for the REST.
+     * The close code.
      * @type {number}
      */
-    status: number;
+    code: number;
     /**
-     * The error for the REST.
-     * @type {string}
+     * Whether the connection was closed by the remote.
+     * @type {boolean}
      */
-    error: string;
+    byRemote: boolean;
     /**
-     * The trace for the REST.
+     * The reason for the closure.
      * @type {string}
      */
-    trace?: string;
+    reason: string;
+}
+/**
+ * The event for when lyrics are found.
+ */
+interface LyricsFoundEvent extends PlayerEvent {
     /**
-     * The message for the REST.
-     * @type {string}
+     * The type of the event.
+     * @type {PlayerEventType.LyricsFound}
      */
-    message: string;
+    type: PlayerEventType.LyricsFound;
     /**
-     * The path for the REST.
+     * The guild id associated with the event.
      * @type {string}
      */
-    path: string;
+    guildId: string;
+    /**
+     * The lyrics result of the event.
+     * @type {LyricsResult}
+     */
+    lyrics: LyricsResult;
 }
 /**
- * The player response from the Lavalink REST API.
+ * The event for when lyrics are not found.
  */
-interface LavalinkPlayer {
+interface LyricsNotFoundEvent extends PlayerEvent {
     /**
-     * The guild ID associated with the player.
+     * The type of the event.
+     * @type {PlayerEventType.LyricsNotFound}
+     */
+    type: PlayerEventType.LyricsNotFound;
+    /**
+     * The guild id associated with the event.
      * @type {string}
      */
     guildId: string;
+}
+/**
+ * The event for when a lyrics line is sent.
+ */
+interface LyricsLineEvent extends PlayerEvent {
     /**
-     * The track currently being played.
-     * @type {LavalinkTrack}
+     * The type of the event.
+     * @type {PlayerEventType.LyricsLine}
      */
-    track?: LavalinkTrack;
+    type: PlayerEventType.LyricsLine;
     /**
-     * The volume of the player.
+     * The guild id associated with the event.
+     * @type {string}
+     */
+    guildId: string;
+    /**
+     * The line index of the lyrics line.
      * @type {number}
      */
-    volume: number;
+    lineIndex: number;
     /**
-     * Whether the player is paused.
+     * The lyrics line of the event.
+     * @type {LyricsLine}
+     */
+    line: LyricsLine;
+    /**
+     * Returns if the line was skipped.
      * @type {boolean}
      */
-    paused: boolean;
+    skipped: boolean;
+}
+/**
+ * The update for the player state.
+ */
+interface PlayerUpdate {
     /**
-     * The voice connection details.
-     * @type {LavalinkPlayerVoice}
+     * The operation code for the update.
+     * @type {OpCodes.PlayerUpdate}
      */
-    voice: LavalinkPlayerVoice;
+    op: OpCodes.PlayerUpdate;
     /**
-     * The filter options applied to the player.
-     * @type {FilterSettings}
+     * The guild ID associated with the update.
+     * @type {string}
      */
-    filters: FilterSettings;
+    guildId: string;
     /**
      * The state of the player.
-     * @type {LavalinkPlayerState}
+     * @type {PlayerUpdateState}
      */
-    state: LavalinkPlayerState;
+    state: PlayerUpdateState;
 }
-/**
- * The state of the player.
- */
-interface LavalinkPlayerState {
+interface PlayerUpdateState {
     /**
-     * The time since the connection was established.
-     * @type {number}
+     * Whether the player is connected.
+     * @type {boolean}
      */
-    time: number;
+    connected: boolean;
     /**
-     * The position of the current track in milliseconds.
+     * The position of the track.
      * @type {number}
      */
     position: number;
     /**
-     * Whether the player is connected to the voice channel.
-     * @type {boolean}
+     * The time of the update.
+     * @type {number}
      */
-    connected: boolean;
+    time: number;
     /**
-     * The ping to the voice server in milliseconds.
+     * The ping of the player.
      * @type {number}
      */
     ping: number;
 }
 /**
- * The options to update the player.
+ * The options for the player.
  */
-interface UpdatePlayerInfo {
+interface PlayerOptions {
     /**
-     * The guild id associated with the player.
+     * Guild id of the player.
      * @type {string}
      */
     guildId: string;
     /**
-     * The options to update the player.
-     * @type {LavalinkPlayOptions}
+     * Voice channel id of the player.
+     * @type {string}
      */
-    playerOptions: LavalinkPlayOptions;
+    voiceId: string;
     /**
-     * Whether to replace the current track.
+     * Volume of the player.
+     * @type {number | undefined}
+     * @default 100
+     */
+    volume?: number;
+    /**
+     * Set if the player should be deafened.
      * @type {boolean | undefined}
-     * @default false
+     * @default true
      */
-    noReplace?: boolean;
-}
-/**
- * The updated session of the current session.
- */
-interface LavalinkSession {
+    selfDeaf?: boolean;
     /**
-     * Whather the session is resuming.
-     * @type {boolean}
+     * Set if the player should be muted.
+     * @type {boolean | undefined}
+     * @default false
      */
-    resuming: boolean;
+    selfMute?: boolean;
     /**
-     * The timeout for the session.
-     * @type {number}
+     * Text channel id of the player.
+     * @type {string | undefined}
      */
-    timeout: number;
+    textId?: string;
+    /**
+     * Lavalink node of the player.
+     * @type {NodeIdentifier}
+     */
+    node?: NodeIdentifier;
 }
 /**
- * The rest options.
+ * The options for playing a track with Lavalink.
  */
-interface HoshimiRestOptions {
+interface LavalinkPlayOptions extends BasePlayOptions {
     /**
-     * The amount of time to wait for the player to resume. (in milliseconds)
-     * @type {number}
-     * @default 10000
+     * Track to play.
+     * @type {PartialLavalinkTrack | undefined}
      */
-    resumeTimeout?: number;
+    track?: PartialLavalinkTrack;
 }
 /**
- * The methods for decoding base64 encoded tracks.
+ * The options for playing a track.
  */
-interface DecodeMethods {
+interface PlayOptions extends BasePlayOptions {
     /**
-     *
-     * Decodes a single base64 encoded track.
-     * @param {string} track The base64 encoded track.
-     * @param {TrackRequester} requester The requester of the track.
-     * @return {Promise<Track>} The decoded track.
-     * @example
-     * ```ts
-     * const node = player.node;
-     * const track = await node.decode.single("base64EncodedTrack");
-     * console.log(track.info.title); // Track Title
-     * ```
+     * Whether to replace the current track.
+     * @type {boolean | undefined}
+     * @default false
      */
-    single(track: string, requester: TrackRequester): Promise<Track>;
+    noReplace?: boolean;
     /**
-     * Decodes multiple base64 encoded tracks.
-     * @param {string[]} tracks The base64 encoded tracks.
-     * @param {TrackRequester} requester The requester of the tracks.
-     * @return {Promise<Track[]>} The decoded tracks.
-     * @example
-     * ```ts
-     * const node = player.node;
-     * const tracks = await node.decode.multiple(["base64EncodedTrack1", "base64EncodedTrack2"]);
-     * console.log(tracks[0].info.title); // Track Title 1
-     * console.log(tracks[1].info.title); // Track Title 2
-     * ```
+     * Track to play.
+     * @type {Track | UnresolvedTrack | undefined}
      */
-    multiple(tracks: string[], requester: TrackRequester): Promise<Track[]>;
+    track?: Track | UnresolvedTrack;
 }
-/**
- * The session of the node.
- */
-type NullableLavalinkSession = PickNullable<LavalinkSession, "timeout">;
-
-/**
- * Class representing the REST for the node.
- * @class Rest
- */
-declare class Rest {
+interface PlayerVoice {
     /**
-     * The URL for the REST.
+     * The voice server token.
      * @type {string}
      */
-    readonly url: string;
+    token: string;
     /**
-     * The version for the REST.
+     * The voice server endpoint.
      * @type {string}
      */
-    readonly version: string;
+    endpoint: string;
     /**
-     * The timeout for the REST.
-     * @type {number}
+     * The voice server session id.
+     * @type {string}
      */
-    readonly restTimeout: number;
+    sessionId: string;
     /**
-     * The user agent for the REST.
-     * @type {UserAgent}
+     * The voice server guild id.
+     * @type {string | undefined}
      */
-    readonly userAgent: UserAgent;
+    connected?: boolean;
     /**
-     * The node for the REST.
-     * @type {Node}
+     * The voice server ping.
+     * @type {number | undefined}
      */
-    readonly node: NodeStructure;
+    ping?: number;
+}
+/**
+ * The JSON representation of the player.
+ */
+interface PlayerJson {
     /**
-     *
-     * Create a new REST.
-     * @param {NodeStructure} node The node for the REST.
-     * @example
-     * ```ts
-     * const node = new Node({
-     * 	host: "localhost",
-     * 	port: 2333,
-     * 	password: "youshallnotpass",
-     * 	secure: false,
-     * });
-     *
-     * const rest = new Rest(node);
-     * console.log(rest.restUrl); // http://localhost:2333/v4
-     * ```
+     * The guild id of the player.
+     * @type {string}
      */
-    constructor(node: NodeStructure);
+    guildId: string;
     /**
-     * The REST URL to make requests.
-     * @type {string}
+     * The volume of the player.
+     * @type {number}
      */
-    get restUrl(): string;
+    volume: number;
     /**
-     * The session id of the node.
-     * @type {string}
+     * The self deaf state of the player.
+     * @type {boolean}
      */
-    get sessionId(): string;
+    selfDeaf: boolean;
     /**
-     *
-     * Make a request to the node.
-     * @param {RestOptions} options The options to make the request.
-     * @returns {Promise<T | null>} The response from the node.
+     * The self mute state of the player.
+     * @type {boolean}
      */
-    request<T>(options: RestOptions): Promise<T | null>;
+    selfMute: boolean;
     /**
-     *
-     * Update the player data.
-     * @param {Partial<UpdatePlayerInfo>} data The player data to update.
-     * @returns {LavalinkPlayer | null} The updated player data.
-     * @example
-     * ```ts
-     * const player = await node.rest.updatePlayer({
-     * 	guildId: "guildId",
-     * 	noReplace: true,
-     * 	playerOptions: {
-     * 		paused: false,
-     * 		track: { encoded: "encoded track" },
-     * 	},
-     * });
-     *
-     * console.log(player); // The updated lavalink player data
-     * ```
+     * The voice settings for the player.
+     * @type {LavalinkPlayerVoice}
      */
-    updatePlayer(data: Partial<UpdatePlayerInfo>): Promise<LavalinkPlayer | null>;
+    voice: Nullable<LavalinkPlayerVoice>;
     /**
-     *
-     * Stop the track in player for the guild.
-     * @param {string} guildId the guild id to stop the player
-     * @returns {Promise<LavalinkPlayer | null>} The updated player data.
-     * @example
-     * ```ts
-     * const player = await node.rest.stopPlayer("guildId");
-     * if (player) console.log(player); // The lavalink player
-     * ```
+     * The loop mode of the player.
+     * @type {LoopMode}
      */
-    stopPlayer(guildId: string): Promise<LavalinkPlayer | null>;
+    loop: LoopMode;
     /**
-     *
-     * Destroy the player for the guild.
-     * @param {string} guildId The guild id to destroy the player.
-     * @returns {Promise<void>} The updated player data.
-     * @example
-     * ```ts
-     * await node.rest.destroyPlayer("guildId");
-     * ```
-     * @example
+     * The options for the player.
+     * @type {boolean}
      */
-    destroyPlayer(guildId: string): Promise<void>;
+    options: PlayerOptions;
     /**
-     *
-     * Update the session for the node
-     * @param {boolean} resuming Enable resuming for the session.
-     * @param {number | null} timeout The timeout for the session.
-     * @returns {Promise<LavalinkSession | null>} The updated session data.
-     * @example
-     * ```ts
-     * const session = await node.rest.updateSession(true, 10000);
-     * if (session) console.log(session); // The lavalink session data
-     * ```
+     * The paused state of the player.
+     * @type {boolean}
      */
-    updateSession(resuming: boolean, timeout?: number | null): Promise<LavalinkSession | null>;
-}
-
-/**
- * Class representing the DSPX Plugin filters for a player.
- * @class DSPXPluginFilter
- */
-declare class DSPXPluginFilter {
+    paused: boolean;
     /**
-     * The filter manager instance.
-     * @type {FilterManagerStructure}
-     * @readonly
+     * The playing state of the player.
+     * @type {boolean}
      */
-    readonly manager: FilterManagerStructure;
+    playing: boolean;
     /**
-     * Create a new DSPXPluginFilter instance.
-     * @param {FilterManagerStructure} manager The filter manager instance.
+     * The voice channel id of the player.
+     * @type {string}
      */
-    constructor(manager: FilterManagerStructure);
+    voiceId?: string;
     /**
-     *
-     * Set the low-pass filter with the given settings.
-     * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXLowPass] The settings for the low-pass filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * The text channel id of the player.
+     * @type {string | undefined}
      */
-    setLowPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
+    textId?: string;
     /**
-     *
-     * Set the high-pass filter with the given settings.
-     * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXHighPass] The settings for the high-pass filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * The last position received from Lavalink.
+     * @type {number}
      */
-    setHighPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
+    lastPosition: number;
     /**
-     *
-     * Set the normalization filter with the given settings.
-     * @param {NormalizationSettings} [settings=DefaultFilter.DSPXNormalization] The settings for the normalization filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * The timestamp when the last position change update happened.
+     * @type {number | null}
      */
-    setNormalization(settings?: Partial<NormalizationSettings>): Promise<this>;
+    lastPositionUpdate: number | null;
     /**
-     *
-     * Set the echo filter with the given settings.
-     * @param {EchoSettings} [settings=DefaultFilter.DSPXEcho] The settings for the echo filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * The current calculated position of the player.
+     * @type {number}
      */
-    setEcho(settings?: Partial<EchoSettings>): Promise<this>;
-}
-
-type NonLengthEchoSettings = Omit$1<EchoSettings, "echoLength">;
-/**
- * Class representing Lavalink plugin filters.
- * @class LavalinkPluginFilter
- */
-declare class LavalinkPluginFilter {
+    position: number;
     /**
-     * The filter manager instance.
-     * @type {FilterManagerStructure}
-     * @private
-     * @readonly
+     * The timestamp when the player was created.
+     * @type {number}
      */
-    private readonly manager;
+    createdTimestamp: number;
     /**
-     * Creates an instance of LavalinkPluginFilter.
-     * @param {FilterManagerStructure} filters - The filter manager instance.
+     * The ping of the player.
+     * @type {number}
      */
-    constructor(filters: FilterManagerStructure);
+    ping: number;
     /**
-     *
-     * Set the echo filter with the given settings.
-     * @param {Omit<EchoSettings, "echoLength">} [settings=DefaultFilter.PluginEcho] The settings for the echo filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * The queue of the player.
+     * @type {QueueJson}
      */
-    setEcho(settings?: Partial<NonLengthEchoSettings>): Promise<this>;
+    queue: QueueJson;
     /**
-     *
-     * Set the reverb filter with the given settings.
-     * @param {Partial<LavalinkFilterPluginReverbSettings>} [settings=DefaultFilter.PluginReverb] The settings for the reverb filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * The node of the player.
+     * @type {NodeJson}
      */
-    setReverb(settings?: Partial<LavalinkFilterPluginReverbSettings>): Promise<this>;
+    node: NodeJson;
+    /**
+     * The filter settings of the player.
+     * @type {FilterSettings}
+     */
+    filters: FilterSettings;
 }
-
 /**
- * Class representing a filter manager for a player.
- * @class FilterManager
+ * The lyrics methods for the player.
  */
-declare class FilterManager {
+interface LyricsMethods {
     /**
-     * The player this filter manager belongs to.
-     * @type {PlayerStructure}
-     * @public
-     * @readonly
+     *
+     * Get the current lyrics for the current track.
+     * @param {boolean} [skipSource=false] Whether to skip the source or not.
+     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * const lyrics = await player.lyricsManager.current();
+     * ```
      */
-    readonly player: PlayerStructure;
+    current(skipSource?: boolean): Promise<LyricsResult | null>;
     /**
-     * The bands applied to the player.
-     * @type {EQBandSettings[]}
-     * @readonly
+     *
+     * Get the lyrics for a specific track.
+     * @param {Track} track The track to get the lyrics for.
+     * @param {boolean} [skipSource=false] Whether to skip the source or not.
+     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * const track = player.queue.current;
+     * const lyrics = await player.lyrics.get(track);
+     * ```
      */
-    readonly bands: EQBandSettings[];
+    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
     /**
-     * The current filter settings applied to the player.
-     * @type {FilterSettings}
-     * @public
+     *
+     * Subscribe to the lyrics for a specific guild.
+     * @param {boolean} [skipSource=false] Whether to skip the source or not.
+     * @returns {Promise<void>} Let's start the sing session!
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * await player.lyrics.subscribe();
+     * ```
      */
-    data: FilterSettings;
+    subscribe(skipSource?: boolean): Promise<void>;
     /**
-     * The enabled filters for the player.
-     * @type {EnabledPlayerFilters}
+     *
+     * Unsubscribe from the lyrics for a specific guild.
+     * @returns {Promise<void>} Let's stop the sing session!
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * await player.lyrics.unsubscribe();
+     * ```
      */
-    filters: EnabledPlayerFilters;
+    unsubscribe(): Promise<void>;
+}
+/**
+ * The voice channel update options.
+ */
+type VoiceChannelUpdate = Pick<PlayerOptions, "selfDeaf" | "voiceId" | "selfMute">;
+/**
+ * The voice settings for the player.
+ */
+type LavalinkPlayerVoice = Omit<PlayerVoice, "connected" | "ping">;
+
+/**
+ * Class representing a LyricsManager.
+ * @class LyricsManager
+ */
+declare class LyricsManager {
     /**
-     * The lavalink plugin filters manager.
-     * @type {LavalinkPluginFilter}
+     * The node instance.
+     * @type {NodeStructure}
      * @readonly
      */
-    readonly plugin: LavalinkPluginFilter;
+    readonly node: NodeStructure;
     /**
-     * The DSPX plugin filters manager.
-     * @type {DSPXPluginFilter}
-     * @readonly
+     * Create a new LyricsManager instance.
+     * @param {NodeStructure} node The node instance.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("nodeId");
+     * const lyricsManager = new LyricsManager(node);
+     * ```
      */
-    readonly dspx: DSPXPluginFilter;
+    constructor(node: NodeStructure);
     /**
      *
-     * Creates a new filter manager.
-     * @param {PlayerStructure} player The player this filter manager belongs to.
-     */
-    constructor(player: PlayerStructure);
-    /**
-     * Resets all filters to their default values.
-     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
+     * Get the current lyrics for the current track.
+     * @param {boolean} skipSource Whether to skip the track source or not.
+     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * const lyrics = await player.lyricsManager.current();
+     * ```
      */
-    reset(): Promise<this>;
+    current(guildId: string, skipSource?: boolean): Promise<LyricsResult | null>;
     /**
      *
-     * Applies the current filters to the player.
-     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
-     */
-    apply(): Promise<this>;
-    /**
-     * Checks if the current filters are active.
-     * @param {TimescaleSettings} timescale The timescale settings to check against.
-     * @returns {void} Nothing!
+     * Get the lyrics for a specific track.
+     * @param {Track} track The track to get the lyrics for.
+     * @param {boolean} skipSource Whether to skip the track source or not.
+     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("nodeId");
+     * const lyrics = await node.lyricsManager.get(track);
+     * ```
      */
-    check(timescale?: TimescaleSettings): void;
+    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
     /**
      *
-     * Checks if a specific filter is active.
-     * @param {FilterType} filter The filter type to check.
-     * @returns {boolean} True if the filter is active, false otherwise.
+     * Subscribe to the lyrics for a specific guild.
+     * @param {string} guildId The guild id to subscribe to.
+     * @param {boolean} skipSource Whether to skip the track source or not.
+     * @returns {Promise<void>} Let's start the sing session!
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("nodeId");
+     * await node.lyricsManager.subscribe("guildId");
+     * ```
      */
-    has(filter: FilterType): boolean;
+    subscribe(guildId: string, skipSource?: boolean): Promise<void>;
     /**
      *
-     * Sets the volume for the player.
-     * @param {number} volume The volume level to set (between 0 and 5).
-     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * Unsubscribe from the lyrics for a specific guild.
+     * @param {string} guildId The guild id to unsubscribe from.
+     * @returns {Promise<void>} Let's stop the sing session!
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("nodeId");
+     * await node.lyricsManager.unsubscribe("guildId");
+     * ```
      */
-    setVolume(volume: number): Promise<this>;
+    unsubscribe(guildId: string): Promise<void>;
+}
+
+/**
+ * Represents a collection that extends the built-in Map class.
+ * @template K The type of the keys in the collection.
+ * @template V The type of the values in the collection.
+ */
+declare class Collection<K, V> extends Map<K, V> {
     /**
-     * Sets the audio output for the player.
-     * @param {AudioOutput} output The audio output to set.
-     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * Removes elements from the collection based on a filter function.
+     * @param fn The filter function that determines which elements to remove.
+     * @param thisArg The value to use as `this` when executing the filter function.
+     * @returns The number of elements removed from the collection.
+     * @example
+     * const collection = new Collection<number, string>();
+     * collection.set(1, 'one');
+     * collection.set(2, 'two');
+     * collection.set(3, 'three');
+     * const removedCount = collection.sweep((value, key) => key % 2 === 0);
+     * console.log(removedCount); // Output: 1
+     * console.log(collection.size); // Output: 2
      */
-    setAudioOutput(output: AudioOutput): Promise<this>;
+    sweep(fn: (value: V, key: K, collection: this) => unknown): number;
     /**
-     *
-     * Sets the speed for the player.
-     * @param {number} speed The speed to set (default is 1).
-     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * Creates a new array with the results of calling a provided function on every element in the collection.
+     * @param fn The function that produces an element of the new array.
+     * @param thisArg The value to use as `this` when executing the map function.
+     * @returns A new array with the results of calling the provided function on every element in the collection.
+     * @example
+     * const collection = new Collection<number, string>();
+     * collection.set(1, 'one');
+     * collection.set(2, 'two');
+     * collection.set(3, 'three');
+     * const mappedArray = collection.map((value, key) => `${key}: ${value}`);
+     * console.log(mappedArray); // Output: ['1: one', '2: two', '3: three']
      */
-    setSpeed(speed?: number): Promise<this>;
+    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
     /**
-     *
-     * Sets the rate for the player.
-     * @param {number} rate The rate to set (default is 1).
-     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * Creates a new array with all elements that pass the test implemented by the provided function.
+     * @param fn The function to test each element of the collection.
+     * @param thisArg The value to use as `this` when executing the filter function.
+     * @returns A new array with the elements that pass the test.
+     * @example
+     * const collection = new Collection<number, string>();
+     * collection.set(1, 'one');
+     * collection.set(2, 'two');
+     * collection.set(3, 'three');
+     * const filteredArray = collection.filter((value, key) => key % 2 === 0);
+     * console.log(filteredArray); // Output: ['two']
      */
-    setRate(rate?: number): Promise<this>;
+    filter(fn: (value: V, key: K, collection: this) => boolean): V[];
+    /**
+     * Returns the value of the first element in the collection that satisfies the provided testing function.
+     * @param fn The function to test each element of the collection.
+     * @returns The value of the first element that passes the test. `undefined` if no element passes the test.
+     * @example
+     * const collection = new Collection<number, number>();
+     * collection.set(1, 1);
+     * collection.set(2, 2);
+     * collection.set(3, 3);
+     * const firstEvenValue = collection.find(value => value % 2 === 0);
+     * console.log(firstEvenValue); // Output: 2
+     */
+    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+}
+
+/**
+ * Class representing a node manager.
+ * @class NodeManager
+ */
+declare class NodeManager {
+    /**
+     * The manager for the node.
+     * @type {Hoshimi}
+     * @readonly
+     */
+    readonly manager: Hoshimi;
+    /**
+     * The nodes for the manager.
+     * @type {Collection<string, Node>}
+     * @readonly
+     */
+    readonly nodes: Collection<string, NodeStructure>;
     /**
      *
-     * Sets the pitch for the player.
-     * @param {number} pitch The pitch
-     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * The constructor for the node manager.
+     * @param {Hoshimi} manager The manager for the node.
+     * @example
+     * ```ts
+     * const manager = new Hoshimi();
+     * const nodeManager = new NodeManager(manager);
+     *
+     * console.log(nodeManager.nodes.size); // 0
+     * ```
      */
-    setPitch(pitch?: number): Promise<this>;
+    constructor(manager: Hoshimi);
     /**
      *
-     * Sets the EQ bands for the player.
-     * @param {RestOrArray<EQBandSettings>} bands The EQ band settings to set.
-     * @returns {Promise<this>} A promise that resolves to the instance of the manager.
+     * Delete the node.
+     * @param {NodeIdentifier} node The node or node id to delete.
+     * @returns {boolean} If the node was deleted.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) manager.nodeManager.delete(node.id); // true if the node was deleted
+     * ```
      */
-    setEQBand(...bands: RestOrArray<EQBandSettings>): Promise<this>;
+    delete(node: NodeIdentifier): boolean;
     /**
      *
-     * Clears all EQ bands for the player.
-     * @returns {Promise<this>} A promise that resolves to the instance of the manager.
+     * Get the node by id.
+     * @param {NodeIdentifier} node The node or node id to get.
+     * @returns {NodeStructure | undefined} The node or undefined if not found.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) {
+     * 	console.log(node.id); // node1
+     * } else {
+     * 	console.log("Node not found");
+     * }
+     * ```
      */
-    clearEQBands(): Promise<this>;
+    get(node: NodeIdentifier): NodeStructure | undefined;
     /**
      *
-     * Set the vibrato filter with the given settings.
-     * @param {TremoloSettings} [settings=DefaultFilterPreset.Vibrato] The settings for the vibrato filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * Create a new node.
+     * @param {NodeOptions} options The options for the node.
+     * @returns {NodeStructure} The created node.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.create({
+     * 	host: "localhost",
+     * 	port: 2333,
+     * 	password: "password",
+     * 	secure: false,
+     * });
+     *
+     * console.log(node.id); // localhost:2333
      */
-    setVibrato(settings?: Partial<TremoloSettings>): Promise<this>;
+    create(options: NodeOptions): NodeStructure;
     /**
      *
-     * Set the tremolo filter with the given settings.
-     * @param {TremoloSettings} [settings=DefaultFilterPreset.Tremolo] The settings for the tremolo filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * Destroy a node.
+     * @param {NodeIdentifier} node The node or node id to destroy.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.destroy();
+     * ```
      */
-    setTremolo(settings?: Partial<TremoloSettings>): Promise<this>;
+    destroy(node: NodeIdentifier): void;
     /**
      *
-     * Set the low-pass filter with the given settings.
-     * @param {LowPassSettings} [settings=DefaultFilterPreset.Lowpass] The settings for the low-pass filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * Reconnect a node.
+     * @param {NodeIdentifier} node The node or node id to reconnect.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.reconnect();
+     * ```
      */
-    setLowPass(settings?: Partial<LowPassSettings>): Promise<this>;
+    reconnect(node: NodeIdentifier): void;
     /**
-     * Set the nightcore filter with the given settings.
-     * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Nightcore] The settings for the nightcore filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     *
+     * Disconnect a node.
+     * @param {NodeIdentifier} node The node or node id to disconnect.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.disconnect();
+     * ```
      */
-    setNightcore(settings?: Partial<TimescaleSettings>): Promise<this>;
+    disconnect(node: NodeIdentifier): void;
     /**
      *
-     * Set the vaporwave filter with the given settings.
-     * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Vaporwave] The settings for the vaporwave filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * Connect a node.
+     * @param {NodeIdentifier} node The node or node id to connect.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.connect();
+     * ```
      */
-    setVaporwave(settings?: Partial<TimescaleSettings>): Promise<this>;
+    connect(node: NodeIdentifier): void;
     /**
      *
-     * Set the karaoke filter with the given settings.
-     * @param {KaraokeSettings} [settings=DefaultFilterPreset.Karaoke] The settings for the karaoke filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * Get the least used node.
+     * @returns {NodeStructure} The least used node.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.getLeastUsed();
+     * if (node) {
+     * 	console.log(node.id); // node1
+     * 	console.log(node.penalties); // the penalties of the node
+     * 	console.log(node.state); // the state of the node
+     * }
+     * ```
      */
-    setKaraoke(settings?: Partial<KaraokeSettings>): Promise<this>;
+    getLeastUsed(sortType?: NodeSortTypes): NodeStructure;
     /**
      *
-     * Set the distortion filter with the given settings.
-     * @param {Partial<DistortionSettings>} [settings=DefaultFilterPreset.Distortion] The settings for the distortion filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * Reconnect the nodes.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.reconnectAll();
+     * ```
      */
-    setDistortion(settings?: Partial<DistortionSettings>): Promise<this>;
+    reconnectAll(): void;
     /**
-     * Set the timescale filter with the given settings.
-     * @param {Partial<TimescaleSettings>} settings The timescale settings to set.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * Disconnect the nodes.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.disconnectAll();
+     * ```
      */
-    setTimescale(settings: Partial<TimescaleSettings>): Promise<this>;
+    disconnectAll(): void;
+    /**
+     * Connect the nodes.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.connect();
+     * ```
+     */
+    connectAll(): void;
+    /**
+     * Destroy the nodes.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.destroy();
+     * ```
+     */
+    destroyAll(): void;
 }
 
 /**
- * Type representing the customizable player storage.
- */
-type StorageKeys = keyof CustomizablePlayerStorage | (string & {});
-/**
- * Type representing the customizable player storage values.
- */
-type StorageValues<V extends StorageKeys = StorageKeys> = V extends keyof CustomizablePlayerStorage ? CustomizablePlayerStorage[V] : unknown;
-/**
- * Class representing a player storage.
- * @class PlayerStorage
+ * The methods for http requests
  */
-declare class PlayerStorage<K extends StorageKeys = StorageKeys, V extends StorageValues<K> = StorageValues<K>> {
+declare enum HttpMethods {
     /**
-     *
-     * Get the value for a key in the storage.
-     * @param {K} key The key to get the value for.
-     * @returns {V | undefined} The value for the key, or undefined if it doesn't exist.
+     * The GET method requests a representation of the specified resource. Requests using GET should only retrieve data.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET
+     * @type {string}
      */
-    get<K extends StorageKeys, V extends StorageValues<K>>(key: K): V | undefined;
+    Get = "GET",
     /**
-     * Set the value for a key in the storage.
-     * @param {K} key The key to set the value for.
-     * @param {V} value The value to set for the key.
+     * The POST method is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST
+     * @type {string}
      */
-    set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): void;
+    Post = "POST",
     /**
-     * Check if the storage has a key.
-     * @param {K} key The key to check for.
-     * @returns {boolean} True if the storage has the key, false otherwise.
+     * The PUT method replaces all current representations of the target resource with the request payload.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT
+     * @type {string}
      */
-    has(key: K): boolean;
+    Put = "PUT",
     /**
-     * Delete a key from the storage.
-     * @param {K} key The key to delete.
-     * @returns {boolean} True if the key was deleted, false otherwise.
+     * The PATCH method is used to apply partial modifications to a resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH
+     * @type {string}
      */
-    delete(key: K): boolean;
+    Patch = "PATCH",
     /**
-     * Get all keys in the storage.
-     * @returns {K[]} The keys in the storage.
-     */
-    keys<K extends StorageKeys[]>(): K[];
-    /**
-     * Get all values in the storage.
-     * @returns {V[]} The values in the storage.
-     */
-    values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): V[];
-    /**
-     * Get all entries in the storage.
-     * @returns {[K, V][]} The entries in the storage.
+     * The DELETE method deletes the specified resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE
+     * @type {string}
      */
-    entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): [K, V][];
+    Delete = "DELETE",
     /**
-     *
-     * Get all key-value pairs in the storage.
-     * @returns {Record<K[number], V>} An object containing all key-value pairs in the storage, excluding internal keys.
+     * The HEAD method asks for a response identical to that of a GET request, but without the response body.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD
+     * @type {string}
      */
-    all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Record<K[number], V>;
+    Head = "HEAD"
+}
+declare enum RestPathType {
     /**
-     * Clear the storage.
+     * The raw path of the request.
+     * @type {string}
      */
-    clear(): void;
+    Raw = "/",
     /**
-     * Get the size of the storage.
-     * @returns {number} The number of entries in the storage.
+     * The versioned path v4 of the request.
+     * @type {string}
      */
-    get size(): number;
+    V4 = "/v4"
 }
-
 /**
- * Class representing a Hoshimi player.
- * @class Player
+ * The status codes for the REST.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
  */
-declare class Player {
+declare enum HttpStatusCodes {
     /**
-     * The data for the player.
-     * @type {PlayerStorage}
-     * @readonly
+     * The request has succeeded.
+     * @type {number}
      */
-    readonly data: PlayerStorage;
+    OK = 200,
     /**
-     * The options for the player.
-     * @type {PlayerOptions}
-     * @readonly
+     * The request has been fulfilled and resulted in a new resource being created.
+     * @type {number}
      */
-    readonly options: PlayerOptions;
+    Created = 201,
     /**
-     * The manager for the player.
-     * @type {Hoshimi}
-     * @readonly
+     * The request has been accepted for processing, but the processing has not been completed.
+     * @type {number}
      */
-    readonly manager: Hoshimi;
+    Accepted = 202,
     /**
-     * The queue for the player.
-     * @type {Queue}
-     * @readonly
+     * The server successfully processed the request, but is not returning any content.
+     * @type {number}
      */
-    readonly queue: QueueStructure;
+    NoContent = 204,
     /**
-     * The filter manager for the player.
-     * @type {FilterManager}
-     * @readonly
+     * The resource has been moved permanently to a new URI.
+     * @type {number}
      */
-    readonly filterManager: FilterManager;
+    MovedPermanently = 301,
     /**
-     * The node for the player.
-     * @type {NodeStructure}
+     * The requested resource has been found at a different URI.
+     * @type {number}
      */
-    node: NodeStructure;
+    Found = 302,
     /**
-     * Check if the player is self deafened.
-     * @type {boolean}
+     * The resource has not been modified since the last request.
+     * @type {number}
      */
-    selfDeaf: boolean;
+    NotModified = 304,
     /**
-     * Check if the player is self muted.
-     * @type {boolean}
+     * The request cannot be processed due to bad syntax.
+     * @type {number}
      */
-    selfMute: boolean;
+    BadRequest = 400,
     /**
-     * Loop mode of the player.
-     * @type {LoopMode}
-     * @default LoopMode.Off
+     * The request requires user authentication.
+     * @type {number}
      */
-    loop: LoopMode;
+    Unauthorized = 401,
     /**
-     * Check if the player is playing.
-     * @type {boolean}
-     * @default false
+     * The request was valid, but the server is refusing action.
+     * @type {number}
      */
-    playing: boolean;
+    Forbidden = 403,
     /**
-     * Check if the player is paused.
-     * @type {boolean}
-     * @default false
+     * The server cannot find the requested resource.
+     * @type {number}
      */
-    paused: boolean;
+    NotFound = 404,
     /**
-     * Check if the player is connected.
-     * @type {boolean}
-     * @default false
+     * The request method is known by the server but has been disabled and cannot be used.
+     * @type {number}
      */
-    connected: boolean;
+    MethodNotAllowed = 405,
     /**
-     * Volume of the player.
+     * The server timed out waiting for the request.
      * @type {number}
-     * @default 100
      */
-    volume: number;
+    RequestTimeout = 408,
     /**
-     * Guild ig of the player.
-     * @type {string}
+     * The request could not be completed due to a conflict with the current state of the resource.
+     * @type {number}
      */
-    guildId: string;
+    Conflict = 409,
     /**
-     * Voice channel idof the player.
-     * @type {string | undefined}
+     * The requested resource is no longer available and will not be available again.
+     * @type {number}
      */
-    voiceId: string | undefined;
+    Gone = 410,
     /**
-     * Text channel id of the player.
-     * @type {string | undefined}
+     * The user has sent too many requests in a given amount of time.
+     * @type {number}
      */
-    textId: string | undefined;
+    TooManyRequests = 429,
     /**
-     * The ping of the player.
+     * A generic error message, given when no more specific message is suitable.
      * @type {number}
      */
-    ping: number;
+    InternalServerError = 500,
     /**
-     * The timestamp when the player was created.
+     * The server does not recognize the request method or lacks the ability to fulfill it.
      * @type {number}
      */
-    createdTimestamp: number;
+    NotImplemented = 501,
     /**
-     * The position of the player.
+     * The server was acting as a gateway and received an invalid response.
      * @type {number}
      */
-    position: number;
+    BadGateway = 502,
     /**
-     * The voice connection details.
-     * @type {PlayerVoice}
+     * The server is currently unavailable (overloaded or down).
+     * @type {number}
      */
-    voice: Nullable<LavalinkPlayerVoice>;
+    ServiceUnavailable = 503,
     /**
-     *
-     * Create a new player.
-     * @param {Hoshimi} manager The manager for the player.
-     * @param {PlayOptions} options The options for the player.
-     * @example
-     * ```ts
-     * const player = new Player(manager, {
-     * 	guildId: "guildId",
-     * 	voiceId: "voiceId",
-     * 	textId: "textId",
-     * 	selfDeaf: true,
-     * 	selfMute: false,
-     * 	volume: 100,
-     * });
-     *
-     * console.log(player.guildId); // guildId
-     * console.log(player.voiceId); // voiceId
-     * console.log(player.textId); // textId
+     * The server did not receive a timely response from an upstream server.
+     * @type {number}
      */
-    constructor(manager: Hoshimi, options: PlayerOptions);
+    GatewayTimeout = 504
+}
+/**
+ * The options for the REST.
+ */
+interface RestOptions {
     /**
-     * The lyrics methods for the player.
-     * @type {LyricsMethods}
-     * @readonly
+     * The endpoint for the REST.
+     * @type {string}
      */
-    readonly lyrics: LyricsMethods;
+    endpoint: `/${string}`;
     /**
-     *
-     * Search for a track or playlist.
-     * @param {SearchOptions} options The options for the search.
-     * @returns {Promise<QueryResult>} The search result.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const result = await player.search({
-     * 	query: "track name",
-     * 	engine: SearchEngine.Youtube,
-     * 	requester: {},
-     * });
-     *
-     * console.log(result) // the search result
-     * ```
+     * The method for the REST.
+     * @type {HttpMethods}
      */
-    search(options: SearchOptions): Promise<QueryResult>;
+    method?: HttpMethods;
     /**
-     *
-     * Play the next track in the queue.
-     * @param {number} [to=0] The amount of tracks to skip.
-     * @param {boolean} [throwError=true] Whether to throw an error if there are no tracks to skip.
-     * @returns {Promise<void>}
-     * @throws {PlayerError} If there are no tracks to skip.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.skip(2); // skip 2 tracks
-     * player.skip(); // skip 1 track
-     * ```
+     * The headers for the REST.
+     * @type {Record<string, string>}
      */
-    skip(to?: number, throwError?: boolean): Promise<void>;
+    headers?: Record<string, string>;
     /**
-     *
-     * Seek to a specific position in the current track.
-     * @param {number} position The position to seek to in milliseconds.
-     * @returns {Promise<void>}
-     * @throws {PlayerError} If the position is invalid.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.seek(30000); // seek to 30 seconds
-     * ```
+     * The body for the REST.
+     * @type {Record<string, unknown> | string | undefined}
      */
-    seek(position: number): Promise<void>;
+    body?: Record<string, unknown> | string;
     /**
-     *
-     * Disconnect the player from the voice channel.
-     * @returns {Promise<this>} The player instance.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.disconnect();
-     * ```
-     */
-    disconnect(): Promise<this>;
+     * The query parameters for the REST.
+     * @type {Record<string, string>}
+     */
+    params?: Record<string, string>;
     /**
-     *
-     * Destroy and disconnect the player.
-     * @param {DestroyReasons} [reason] The reason for destroying the player.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.destroy(DestroyReasons.Stop);
-     * ```
+     * The path type for the REST.
+     * @type {RestPathType}
      */
-    destroy(reason?: DestroyReasons): Promise<boolean>;
+    pathType?: RestPathType;
+}
+/**
+ * The fetch options for the request.
+ */
+interface FetchOptions extends Omit<RestOptions, "endpoint" | "body"> {
     /**
-     *
-     * Play a track in the player.
-     * @param {Partial<PlayOptions>} [options] The options to play the track.
-     * @returns {Promise<void>}
-     * @throws {PlayerError} If there are no tracks to play.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     *
-     * player.play({
-     * 	track: track,
-     * 	noReplace: true,
-     * });
-     * ```
+     * The signal for the request.
      */
-    play(options?: Partial<PlayOptions>): Promise<void>;
+    signal: AbortSignal;
     /**
-     * Connect the player to the voice channel.
-     * @returns {Promise<this>} The player instance.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.connect();
-     * ```
+     * The stringified body for the request.
      */
-    connect(): Promise<this>;
+    body?: string;
+}
+/**
+ * The error for the REST.
+ */
+interface LavalinkRestError {
     /**
-     *
-     * Stop the player from playing.
-     * @param {boolean} [destroy=true] Whether to destroy the player or not.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.stop();
-     * ```
+     * The timestamp for the REST.
+     * @type {number}
      */
-    stop(destroy?: boolean): Promise<void>;
+    timestamp: number;
     /**
-     *
-     * Pause or resume the player.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.setPaused();
-     * ```
+     * The status for the REST.
+     * @type {number}
      */
-    setPaused(paused?: boolean): Promise<boolean>;
+    status: number;
     /**
-     *
-     * Set the volume of the player.
-     * @param {number} volume The volume to set.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.setVolume(50); // set the volume to 50%
-     * ```
+     * The error for the REST.
+     * @type {string}
      */
-    setVolume(volume: number): Promise<void>;
+    error: string;
     /**
-     *
-     * Set the loop mode of the player.
-     * @param {LoopMode} mode The loop mode to set.
-     * @throws {PlayerError} If the loop mode is invalid.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.setLoop(LoopMode.Track);
-     * ```
+     * The trace for the REST.
+     * @type {string}
      */
-    setLoop(mode: LoopMode): this;
+    trace?: string;
     /**
-     * Set the voice of the player.
-     * @param {Partial<VoiceChannelUpdate>} voice The voice state to set.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.setVoice({ voiceId: "newVoiceId" });
-     * ```
+     * The message for the REST.
+     * @type {string}
      */
-    setVoice(voice: Partial<VoiceChannelUpdate>): Promise<void>;
+    message: string;
     /**
-     *
-     * Change the node the player is connected to.
-     * @param {NodeIdentifier} node The node to change to.
-     * @returns {Promise<void>} A promise that resolves when the node has been changed.
-     * @throws {PlayerError} If the target node is not found, not connected, or missing source managers.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.move("newNodeId");
-     * ```
+     * The path for the REST.
+     * @type {string}
      */
-    move(node: NodeIdentifier): Promise<void>;
+    path: string;
+}
+/**
+ * The player response from the Lavalink REST API.
+ */
+interface LavalinkPlayer {
     /**
-     * Update the player with new data.
-     * @param {NonGuildUpdatePlayerInfo} data The data to update the player with.
-     * @returns {Promise<LavalinkPlayer | null>} The updated player data.
+     * The guild ID associated with the player.
+     * @type {string}
      */
-    updatePlayer(data: NonGuildUpdatePlayerInfo): Promise<LavalinkPlayer | null>;
+    guildId: string;
     /**
-     *
-     * Return the player as a json object.
-     * @returns {PlayerJson}
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const json = player.toJSON();
-     * console.log(json); // the player as a json object
-     * ```
+     * The track currently being played.
+     * @type {LavalinkTrack}
      */
-    toJSON(): PlayerJson;
+    track?: LavalinkTrack;
+    /**
+     * The volume of the player.
+     * @type {number}
+     */
+    volume: number;
+    /**
+     * Whether the player is paused.
+     * @type {boolean}
+     */
+    paused: boolean;
+    /**
+     * The voice connection details.
+     * @type {LavalinkPlayerVoice}
+     */
+    voice: LavalinkPlayerVoice;
+    /**
+     * The filter options applied to the player.
+     * @type {FilterSettings}
+     */
+    filters: FilterSettings;
+    /**
+     * The state of the player.
+     * @type {LavalinkPlayerState}
+     */
+    state: LavalinkPlayerState;
 }
 /**
- * Type representing the update player information without guildId.
+ * The state of the player.
  */
-type NonGuildUpdatePlayerInfo = Omit<UpdatePlayerInfo, "guildId">;
+interface LavalinkPlayerState {
+    /**
+     * The time since the connection was established.
+     * @type {number}
+     */
+    time: number;
+    /**
+     * The position of the current track in milliseconds.
+     * @type {number}
+     */
+    position: number;
+    /**
+     * Whether the player is connected to the voice channel.
+     * @type {boolean}
+     */
+    connected: boolean;
+    /**
+     * The ping to the voice server in milliseconds.
+     * @type {number}
+     */
+    ping: number;
+}
 /**
- * Interface representing the customizable player storage.
+ * The options to update the player.
  */
-interface CustomizablePlayerStorage {
+interface UpdatePlayerInfo {
+    /**
+     * The guild id associated with the player.
+     * @type {string}
+     */
+    guildId: string;
+    /**
+     * The options to update the player.
+     * @type {LavalinkPlayOptions}
+     */
+    playerOptions: LavalinkPlayOptions;
+    /**
+     * Whether to replace the current track.
+     * @type {boolean | undefined}
+     * @default false
+     */
+    noReplace?: boolean;
 }
-
 /**
- * Class representing a storage manager.
- * @abstract
- * @class StorageManager
- * @example
- * ```ts
- * class MyStorageManager extends StorageManager {};
- *
- * const storage = new MyStorageManager();
- * storage.set("key", "value");
- *
- * const value = await storage.get("key");
- * console.log(value); // "value"
- * ```
+ * The updated session of the current session.
  */
-declare abstract class StorageAdapter<T extends QueueJson = QueueJson> {
+interface LavalinkSession {
+    /**
+     * Whather the session is resuming.
+     * @type {boolean}
+     */
+    resuming: boolean;
+    /**
+     * The timeout for the session.
+     * @type {number}
+     */
+    timeout: number;
+}
+/**
+ * The rest options.
+ */
+interface HoshimiRestOptions {
+    /**
+     * The amount of time to wait for the player to resume. (in milliseconds)
+     * @type {number}
+     * @default 10000
+     */
+    resumeTimeout?: number;
+}
+/**
+ * The methods for decoding base64 encoded tracks.
+ */
+interface DecodeMethods {
     /**
      *
-     * Get the value using the key.
-     * @param {string} key The key to get the value from.
-     * @returns {Awaitable<T | undefined>} The value of the key.
+     * Decodes a single base64 encoded track.
+     * @param {string} track The base64 encoded track.
+     * @param {TrackRequester} requester The requester of the track.
+     * @return {Promise<Track>} The decoded track.
      * @example
      * ```ts
-     * const value = await storage.get("key");
-     * console.log(value); // "value"
+     * const node = player.node;
+     * const track = await node.decode.single("base64EncodedTrack");
+     * console.log(track.info.title); // Track Title
      * ```
      */
-    abstract get(key: string): Awaitable<T | undefined>;
+    single(track: string, requester: TrackRequester): Promise<Track>;
     /**
-     *
-     * Set the value using the key.
-     * @param {string} key The key to set the value to.
-     * @param {unknown} value The value to set.
-     * @returns {Awaitable<void>} Did you know this can be async?
+     * Decodes multiple base64 encoded tracks.
+     * @param {string[]} tracks The base64 encoded tracks.
+     * @param {TrackRequester} requester The requester of the tracks.
+     * @return {Promise<Track[]>} The decoded tracks.
      * @example
      * ```ts
-     * await storage.set("key", "value");
+     * const node = player.node;
+     * const tracks = await node.decode.multiple(["base64EncodedTrack1", "base64EncodedTrack2"]);
+     * console.log(tracks[0].info.title); // Track Title 1
+     * console.log(tracks[1].info.title); // Track Title 2
      * ```
      */
-    abstract set(key: string, value: T): Awaitable<void>;
+    multiple(tracks: string[], requester: TrackRequester): Promise<Track[]>;
+}
+/**
+ * The session of the node.
+ */
+type NullableLavalinkSession = PickNullable<LavalinkSession, "timeout">;
+
+/**
+ * Class representing the REST for the node.
+ * @class Rest
+ */
+declare class Rest {
+    /**
+     * The URL for the REST.
+     * @type {string}
+     */
+    readonly url: string;
+    /**
+     * The version for the REST.
+     * @type {string}
+     */
+    readonly version: string;
+    /**
+     * The timeout for the REST.
+     * @type {number}
+     */
+    readonly restTimeout: number;
+    /**
+     * The user agent for the REST.
+     * @type {UserAgent}
+     */
+    readonly userAgent: UserAgent;
+    /**
+     * The node for the REST.
+     * @type {Node}
+     */
+    readonly node: NodeStructure;
     /**
      *
-     * Delete the value using the key.
-     * @param {string} key The key to delete the value from.
-     * @returns {Awaitable<boolean>} Returns true if the key was deleted.
+     * Create a new REST.
+     * @param {NodeStructure} node The node for the REST.
      * @example
      * ```ts
-     * const success = await storage.delete("key");
-     * console.log(success); // true
+     * const node = new Node({
+     * 	host: "localhost",
+     * 	port: 2333,
+     * 	password: "youshallnotpass",
+     * 	secure: false,
+     * });
+     *
+     * const rest = new Rest(node);
+     * console.log(rest.restUrl); // http://localhost:2333/v4
      * ```
      */
-    abstract delete(key: string): Awaitable<boolean>;
+    constructor(node: NodeStructure);
     /**
-     * Clear the storage.
-     * @returns {Awaitable<void>} Scary, right?
+     * The REST URL to make requests.
+     * @type {string}
+     */
+    get restUrl(): string;
+    /**
+     * The session id of the node.
+     * @type {string}
+     */
+    get sessionId(): string;
+    /**
+     *
+     * Make a request to the node.
+     * @param {RestOptions} options The options to make the request.
+     * @returns {Promise<T | null>} The response from the node.
+     */
+    request<T>(options: RestOptions): Promise<T | null>;
+    /**
+     *
+     * Update the player data.
+     * @param {Partial<UpdatePlayerInfo>} data The player data to update.
+     * @returns {LavalinkPlayer | null} The updated player data.
      * @example
      * ```ts
-     * await storage.clear();
+     * const player = await node.rest.updatePlayer({
+     * 	guildId: "guildId",
+     * 	noReplace: true,
+     * 	playerOptions: {
+     * 		paused: false,
+     * 		track: { encoded: "encoded track" },
+     * 	},
+     * });
+     *
+     * console.log(player); // The updated lavalink player data
      * ```
      */
-    abstract clear(): Awaitable<void>;
+    updatePlayer(data: Partial<UpdatePlayerInfo>): Promise<LavalinkPlayer | null>;
     /**
-     * Check if the storage has the key.
-     * @param {string} key The key to check.
-     * @returns {Awaitable<boolean>} Return true if the key exists.
+     *
+     * Stop the track in player for the guild.
+     * @param {string} guildId the guild id to stop the player
+     * @returns {Promise<LavalinkPlayer | null>} The updated player data.
      * @example
      * ```ts
-     * const exists = await storage.has("key");
-     * console.log(exists); // true
+     * const player = await node.rest.stopPlayer("guildId");
+     * if (player) console.log(player); // The lavalink player
      * ```
      */
-    abstract has(key: string): Awaitable<boolean>;
+    stopPlayer(guildId: string): Promise<LavalinkPlayer | null>;
     /**
      *
-     * Parse the value.
-     * @param {unknown} value The value to parse.
-     * @returns {T} The parsed value.
+     * Destroy the player for the guild.
+     * @param {string} guildId The guild id to destroy the player.
+     * @returns {Promise<void>} The updated player data.
      * @example
      * ```ts
-     * const parsed = await storage.parse<{ key: string }>("{'key':'value'}");
-     * console.log(parsed); // { key: "value" }
+     * await node.rest.destroyPlayer("guildId");
      * ```
+     * @example
      */
-    abstract parse(value: unknown): Awaitable<T>;
+    destroyPlayer(guildId: string): Promise<void>;
     /**
      *
-     * Stringify the value.
-     * @param {unknown} value The value to stringify.
-     * @returns {R} The stringified value.
+     * Update the session for the node
+     * @param {boolean} resuming Enable resuming for the session.
+     * @param {number | null} timeout The timeout for the session.
+     * @returns {Promise<LavalinkSession | null>} The updated session data.
      * @example
      * ```ts
-     * const stringified = await storage.stringify({ key: "value" });
-     * console.log(stringified); // "{'key':'value'}"
+     * const session = await node.rest.updateSession(true, 10000);
+     * if (session) console.log(session); // The lavalink session data
      * ```
      */
-    abstract stringify<R = string>(value: unknown): Awaitable<R>;
+    updateSession(resuming: boolean, timeout?: number | null): Promise<LavalinkSession | null>;
 }
 
 /**
- * The queue options.
+ * Class representing the DSPX Plugin filters for a player.
+ * @class DSPXPluginFilter
  */
-interface HoshimiQueueOptions {
-    /**
-     * The maximum amount of tracks that can be saved in the queue.
-     * @type {number}
-     * @default 25
-     */
-    maxPreviousTracks?: number;
+declare class DSPXPluginFilter {
     /**
-     *
-     * The function to use for autoplay.
-     * @param {Player} player The player.
-     * @param {HoshimiTrack | null} lastTrack The last track played.
+     * The filter manager instance.
+     * @type {FilterManagerStructure}
+     * @readonly
      */
-    autoplayFn?(player: PlayerStructure, lastTrack: HoshimiTrack | null): Awaitable<void>;
+    readonly manager: FilterManagerStructure;
     /**
-     * Enable the auto play for the queue. (By default, only supports `youtube` and `spotify`, add more with your own function)
-     * @type {boolean}
-     * @default false
+     * Create a new DSPXPluginFilter instance.
+     * @param {FilterManagerStructure} manager The filter manager instance.
      */
-    autoPlay?: boolean;
+    constructor(manager: FilterManagerStructure);
     /**
-     * The storage manager to use for the queue.
-     * @type {StorageAdapter}
-     * @default {MemoryAdapter}
+     *
+     * Set the low-pass filter with the given settings.
+     * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXLowPass] The settings for the low-pass filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    storage?: StorageAdapter;
-}
-/**
- * The queue json.
- */
-interface QueueJson {
+    setLowPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
     /**
-     * The tracks of the queue.
-     * @type {HoshimiTrack[]}
+     *
+     * Set the high-pass filter with the given settings.
+     * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXHighPass] The settings for the high-pass filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    tracks: HoshimiTrack[];
+    setHighPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
     /**
-     * The previous tracks of the queue.
-     * @type {Track[]}
+     *
+     * Set the normalization filter with the given settings.
+     * @param {NormalizationSettings} [settings=DefaultFilter.DSPXNormalization] The settings for the normalization filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    history: Track[];
+    setNormalization(settings?: Partial<NormalizationSettings>): Promise<this>;
     /**
-     * The current track of the queue.
-     * @type {Track | null}
+     *
+     * Set the echo filter with the given settings.
+     * @param {EchoSettings} [settings=DefaultFilter.DSPXEcho] The settings for the echo filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    current: Track | null;
+    setEcho(settings?: Partial<EchoSettings>): Promise<this>;
 }
 
+type NonLengthEchoSettings = Omit$1<EchoSettings, "echoLength">;
 /**
- * Class representing the queue utils.
- * @class QueueUtils
+ * Class representing Lavalink plugin filters.
+ * @class LavalinkPluginFilter
  */
-declare class QueueUtils {
+declare class LavalinkPluginFilter {
     /**
-     *
-     * Constructor of the queue utils.
-     * @param {QueueStructure} queue The queue instance.
+     * The filter manager instance.
+     * @type {FilterManagerStructure}
+     * @private
+     * @readonly
      */
-    constructor(queue: QueueStructure);
+    private readonly manager;
     /**
-     *
-     * Save the queue.
-     * @returns {Awaitable<void>}
-     * @example
-     * ```ts
-     * await player.queue.utils.save();
-     * ```
+     * Creates an instance of LavalinkPluginFilter.
+     * @param {FilterManagerStructure} filters - The filter manager instance.
      */
-    save(): Awaitable<void>;
+    constructor(filters: FilterManagerStructure);
     /**
      *
-     * Destroy the queue.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * await player.queue.utils.destroy();
-     * ```
+     * Set the echo filter with the given settings.
+     * @param {Omit<EchoSettings, "echoLength">} [settings=DefaultFilter.PluginEcho] The settings for the echo filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    destroy(): Awaitable<boolean>;
+    setEcho(settings?: Partial<NonLengthEchoSettings>): Promise<this>;
     /**
      *
-     * Sync the queue.
-     * @returns {Awaitable<void>}
-     * @example
-     * ```ts
-     * await player.queue.utils.sync();
-     * ```
+     * Set the reverb filter with the given settings.
+     * @param {Partial<LavalinkFilterPluginReverbSettings>} [settings=DefaultFilter.PluginReverb] The settings for the reverb filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    sync(override?: boolean, syncCurrent?: boolean): Promise<void>;
+    setReverb(settings?: Partial<LavalinkFilterPluginReverbSettings>): Promise<this>;
 }
 
 /**
- * Class representing a queue.
- * @class Queue
+ * Class representing a filter manager for a player.
+ * @class FilterManager
  */
-declare class Queue {
+declare class FilterManager {
     /**
-     * Tracks of the queue.
-     * @type {HoshimiTrack[]}
+     * The player this filter manager belongs to.
+     * @type {PlayerStructure}
+     * @public
+     * @readonly
      */
-    tracks: HoshimiTrack[];
+    readonly player: PlayerStructure;
     /**
-     * Previous tracks of the queue.
-     * @type {Track[]}
+     * The bands applied to the player.
+     * @type {EQBandSettings[]}
+     * @readonly
      */
-    history: Track[];
+    readonly bands: EQBandSettings[];
     /**
-     * Current track of the queue.
-     * @type {Track | null}
+     * The current filter settings applied to the player.
+     * @type {FilterSettings}
+     * @public
      */
-    current: Track | null;
+    data: FilterSettings;
     /**
-     * The player instance.
-     * @type {PlayerStructure}
+     * The enabled filters for the player.
+     * @type {EnabledPlayerFilters}
      */
-    readonly player: PlayerStructure;
+    filters: EnabledPlayerFilters;
     /**
-     * The queue utils instance.
-     * @type {QueueUtils}
+     * The lavalink plugin filters manager.
+     * @type {LavalinkPluginFilter}
      * @readonly
      */
-    readonly utils: QueueUtils;
-    /**
-     *
-     * Constructor of the queue.
-     * @param {PlayerStructure} player Player instance.
-     * @example
-     * ```ts
-     * const player = new Player();
-     * const queue = new Queue(player);
-     *
-     * console.log(queue.size); // 0
-     * queue.add(track);
-     * console.log(queue.size); // 1
-     * ```
-     */
-    constructor(player: PlayerStructure);
+    readonly plugin: LavalinkPluginFilter;
     /**
-     * Get the track size of the queue.
-     * @type {number}
-     * @returns {number} The track size of the queue.
+     * The DSPX plugin filters manager.
+     * @type {DSPXPluginFilter}
      * @readonly
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.size); // 0
-     * queue.add(track);
-     *
-     * console.log(queue.size); // 1
-     * queue.add([track1, track2]);
-     *
-     * console.log(queue.size); // 3
-     * queue.shift();
-     * console.log(queue.size); // 2
-     *
-     * queue.clear();
-     * console.log(queue.size); // 0
-     * ```
      */
-    get size(): number;
+    readonly dspx: DSPXPluginFilter;
     /**
-     * Get the total track size of the queue (Includes the current track).
-     * @type {number}
-     * @returns {number} The total track size of the queue.
-     * @readonly
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.totalSize); // 0
-     * queue.add(track);
-     *
-     * console.log(queue.totalSize); // 1
-     * queue.add([track1, track2]);
      *
-     * console.log(queue.totalSize); // 3
-     * queue.shift();
-     * console.log(queue.totalSize); // 2
-     *
-     * queue.clear();
-     * console.log(queue.totalSize); // 0
-     * ```
+     * Creates a new filter manager.
+     * @param {PlayerStructure} player The player this filter manager belongs to.
      */
-    get totalSize(): number;
+    constructor(player: PlayerStructure);
     /**
-     *
-     * Check if the queue is empty.
-     * @type {boolean}
-     * @returns {boolean} True if the queue is empty.
-     * @readonly
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.isEmpty()); // true
-     * queue.add(track);
-     *
-     * console.log(queue.isEmpty()); // false
-     * queue.clear();
-     *
-     * console.log(queue.isEmpty()); // true
-     * ```
+     * Resets all filters to their default values.
+     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
      */
-    isEmpty(): boolean;
+    reset(): Promise<this>;
     /**
      *
-     * Get the previous track of the queue.
-     * @param {boolean} [remove=false] Whether to remove the track from the previous queue.
-     * @returns {Track | null} The previous track of the queue.
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.previous()); // null
-     * queue.add(track);
-     * queue.add(track2);
-     *
-     * console.log(queue.previous()); // track
-     * console.log(queue.previous(true)); // track and remove it from the previous tracks
-     * ```
+     * Applies the current filters to the player.
+     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
      */
-    previous(remove?: boolean): Track | null;
+    apply(): Promise<this>;
     /**
-     *
-     * Add a track or tracks to the queue.
-     * @param {Track | Track[]} track The track or tracks to add.
-     * @param {number} [position] The position to add the track or tracks.
-     * @returns {this} The queue instance.
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.size); // 0
-     *
-     * queue.add(track);
-     * console.log(queue.size); // 1
-     *
-     * queue.add([track1, track2]);
-     * console.log(queue.size); // 3
-     *
-     * queue.add(track3, 1);
-     * console.log(queue.size); // 4
-     * console.log(queue.tracks); // [track1, track3, track2, track]
-     * ```
+     * Checks if the current filters are active.
+     * @param {TimescaleSettings} timescale The timescale settings to check against.
+     * @returns {void} Nothing!
      */
-    add(track: HoshimiTrack | HoshimiTrack[], position?: number): this;
+    check(timescale?: TimescaleSettings): void;
     /**
      *
-     * Get the first track of the queue.
-     * @returns {HoshimiTrack | null} The first track of the queue.
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.shift()); // null
-     * queue.add(track);
-     *
-     * console.log(queue.shift()); // track
-     * queue.add(track2);
-     * ```
+     * Checks if a specific filter is active.
+     * @param {FilterType} filter The filter type to check.
+     * @returns {boolean} True if the filter is active, false otherwise.
      */
-    shift(): HoshimiTrack | null;
+    has(filter: FilterType): boolean;
     /**
      *
-     * Add tracks to the beginning of the queue.
-     * @param {Track[]} tracks The tracks to add.
-     * @returns {this} The queue instance.
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.size); // 0
-     * queue.unshift(track);
-     *
-     * console.log(queue.size); // 1
-     * queue.unshift([track1, track2]);
-     *
-     * console.log(queue.size); // 3
-     * console.log(queue.tracks); // [track1, track2, track]
-     * ```
+     * Sets the volume for the player.
+     * @param {number} volume The volume level to set (between 0 and 5).
+     * @returns {Promise<this>} A promise that resolves to the player instance.
      */
-    unshift(...tracks: Track[]): this;
+    setVolume(volume: number): Promise<this>;
     /**
-     *
-     * Shuffle the queue.
-     * @returns {this} The queue instance.
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.size); // 0
-     * queue.add(track);
-     * queue.add([track1, track2]);
-     *
-     * console.log(queue.size); // 3
-     * console.log(queue.tracks); // [track, track1, track2]
-     *
-     * queue.shuffle();
-     * console.log(queue.tracks); // [track2, track, track1]
-     * ```
+     * Sets the audio output for the player.
+     * @param {AudioOutput} output The audio output to set.
+     * @returns {Promise<this>} A promise that resolves to the player instance.
      */
-    shuffle(): this;
+    setAudioOutput(output: AudioOutput): Promise<this>;
     /**
      *
-     * Clear the queue.
-     * @returns {this} The queue instance.
-     * @example
-     * ```ts
-     * const queue = player.queue;
-     *
-     * console.log(queue.size); // 0
-     * queue.add(track);
-     * queue.add([track1, track2]);
+     * Sets the speed for the player.
+     * @param {number} speed The speed to set (default is 1).
+     * @returns {Promise<this>} A promise that resolves to the player instance.
+     */
+    setSpeed(speed?: number): Promise<this>;
+    /**
      *
-     * console.log(queue.size); // 3
-     * queue.clear();
-     * console.log(queue.size); // 0
-     * ```
+     * Sets the rate for the player.
+     * @param {number} rate The rate to set (default is 1).
+     * @returns {Promise<this>} A promise that resolves to the player instance.
      */
-    clear(): this;
+    setRate(rate?: number): Promise<this>;
     /**
      *
-     * Move a track to a specific position in the queue.
-     * @param {Track} track The track to move.
-     * @param {number} to The position to move.
-     * @returns {this} The queue instance.
+     * Sets the pitch for the player.
+     * @param {number} pitch The pitch
+     * @returns {Promise<this>} A promise that resolves to the player instance.
      */
-    move(track: Track, to: number): this;
+    setPitch(pitch?: number): Promise<this>;
     /**
      *
-     * Delete tracks from the queue.
-     * @param {number} start The start index.
-     * @param {number} deleteCount The number of tracks to delete.
-     * @param {Track | Track[]} [tracks] The tracks to add.
-     * @returns {this} The queue instance.
+     * Sets the EQ bands for the player.
+     * @param {RestOrArray<EQBandSettings>} bands The EQ band settings to set.
+     * @returns {Promise<this>} A promise that resolves to the instance of the manager.
      */
-    splice(start: number, deleteCount: number, tracks?: HoshimiTrack | HoshimiTrack[]): this;
+    setEQBand(...bands: RestOrArray<EQBandSettings>): Promise<this>;
     /**
      *
-     * Convert the queue to a JSON object.
-     * @returns {QueueJson} The queue JSON object.
+     * Clears all EQ bands for the player.
+     * @returns {Promise<this>} A promise that resolves to the instance of the manager.
      */
-    toJSON(): QueueJson;
-}
-
-/**
- * The structure for the Player class.
- */
-type PlayerStructure = InferCustomStructure<Player, "Player">;
-/**
- * The structure for the Rest class.
- */
-type RestStructure = InferCustomStructure<Rest, "Rest">;
-/**
- * The structure for the Node class.
- */
-type NodeStructure = InferCustomStructure<Node, "Node">;
-/**
- * The structure for the Queue class.
- */
-type QueueStructure = InferCustomStructure<Queue, "Queue">;
-/**
- * The structure for the LyricsManager class.
- */
-type LyricsManagerStructure = InferCustomStructure<LyricsManager, "LyricsManager">;
-/**
- * The structure for the NodeManager class.
- */
-type NodeManagerStructure = InferCustomStructure<NodeManager, "NodeManager">;
-/**
- * The structure for the FilterManager class.
- */
-type FilterManagerStructure = InferCustomStructure<FilterManager, "FilterManager">;
-/**
- * The structures of the Hoshimi classes.
- */
-declare const Structures: {
-    Player(manager: Hoshimi, options: PlayerOptions): PlayerStructure;
-    Rest(node: Node): RestStructure;
-    Node(nodeManager: NodeManager, options: NodeOptions): NodeStructure;
-    Queue(player: Player): QueueStructure;
-    LyricsManager(node: Node): LyricsManagerStructure;
-    NodeManager(manager: Hoshimi): NodeManagerStructure;
-    FilterManager(player: Player): FilterManagerStructure;
-};
-/**
- * Infers the custom structure for a given class.
- */
-type InferCustomStructure<T, N extends string> = CustomizableStructures extends Record<N, infer P> ? P : T;
-
-/**
- * Class representing a Hoshimi track.
- * @class Track
- * @implements {LavalinkTrack}
- */
-declare class Track implements LavalinkTrack {
+    clearEQBands(): Promise<this>;
     /**
-     * The base64 encoded track.
-     * @type {string}
+     *
+     * Set the vibrato filter with the given settings.
+     * @param {TremoloSettings} [settings=DefaultFilterPreset.Vibrato] The settings for the vibrato filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    readonly encoded: string;
+    setVibrato(settings?: Partial<TremoloSettings>): Promise<this>;
     /**
-     * The track info.
-     * @type {TrackInfo}
+     *
+     * Set the tremolo filter with the given settings.
+     * @param {TremoloSettings} [settings=DefaultFilterPreset.Tremolo] The settings for the tremolo filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    readonly info: TrackInfo;
+    setTremolo(settings?: Partial<TremoloSettings>): Promise<this>;
     /**
-     * The plugin info of the track.
-     * @type {PluginInfo}
+     *
+     * Set the low-pass filter with the given settings.
+     * @param {LowPassSettings} [settings=DefaultFilterPreset.Lowpass] The settings for the low-pass filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    readonly pluginInfo: PluginInfo;
+    setLowPass(settings?: Partial<LowPassSettings>): Promise<this>;
     /**
-     * The track user data.
-     * @type {Record<string, unknown>}
+     * Set the nightcore filter with the given settings.
+     * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Nightcore] The settings for the nightcore filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    userData: Record<string, unknown>;
+    setNightcore(settings?: Partial<TimescaleSettings>): Promise<this>;
     /**
-     * The requester of the track.
-     * @type {TrackRequester}
+     *
+     * Set the vaporwave filter with the given settings.
+     * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Vaporwave] The settings for the vaporwave filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    requester: TrackRequester;
+    setVaporwave(settings?: Partial<TimescaleSettings>): Promise<this>;
     /**
-     * The constructor for the track.
-     * @param {LavalinkTrack} track The track to construct the track from.
-     * @param {TrackRequester} requester The requester of the track.
-     * @example
-     * ```ts
-     * const track = new Track({
-     * 	encoded: "base64",
-     * 	info: {
-     * 		title: "Track Title",
-     * 		uri: "https://example.com",
-     * 		duration: 300000,
-     * 	},
-     * 	// the rest of the track info
-     * }, requester);
      *
-     * console.log(track.encoded); // the track encoded in base64
-     * ```
+     * Set the karaoke filter with the given settings.
+     * @param {KaraokeSettings} [settings=DefaultFilterPreset.Karaoke] The settings for the karaoke filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    constructor(track: LavalinkTrack | null, requester?: TrackRequester);
+    setKaraoke(settings?: Partial<KaraokeSettings>): Promise<this>;
     /**
      *
-     * Get the hyperlink of the track.
-     * @param {boolean} [embedable=true] Whether the hyperlink should be embedable or not.
-     * @returns {string} The hyperlink of the track.
-     * @example
-     * ```ts
-     * const track = queue.current;
-     * console.log(track.toHyperlink()); // [Track Title](https://example.com)
-     * console.log(track.toHyperlink(false)); // [Track Title](<https://example.com>)
-     * ```
+     * Set the distortion filter with the given settings.
+     * @param {Partial<DistortionSettings>} [settings=DefaultFilterPreset.Distortion] The settings for the distortion filter.
+     * @returns {Promise<this>} The instance of the filter manager.
      */
-    toHyperlink(embedable?: boolean): string;
+    setDistortion(settings?: Partial<DistortionSettings>): Promise<this>;
+    /**
+     * Set the timescale filter with the given settings.
+     * @param {Partial<TimescaleSettings>} settings The timescale settings to set.
+     * @returns {Promise<this>} The instance of the filter manager.
+     */
+    setTimescale(settings: Partial<TimescaleSettings>): Promise<this>;
+    /**
+     * Convert the filter settings to a JSON object.
+     * @returns {FilterSettings} The filter settings as a JSON object.
+     */
+    toJSON(): FilterSettings;
 }
+
 /**
- * Class representing an unresolved track.
- * @class UnresolvedTrack
- * @implements {UnresolvedLavalinkTrack}
+ * Type representing the customizable player storage.
  */
-declare class UnresolvedTrack implements UnresolvedLavalinkTrack {
+type StorageKeys = keyof CustomizablePlayerStorage | (string & {});
+/**
+ * Type representing the customizable player storage values.
+ */
+type StorageValues<V extends StorageKeys = StorageKeys> = V extends keyof CustomizablePlayerStorage ? CustomizablePlayerStorage[V] : unknown;
+/**
+ * Class representing a player storage.
+ * @class PlayerStorage
+ */
+declare class PlayerStorage<K extends StorageKeys = StorageKeys, V extends StorageValues<K> = StorageValues<K>> {
     /**
-     * The base64 encoded track.
-     * @type {string | undefined}
+     *
+     * Get the value for a key in the storage.
+     * @param {K} key The key to get the value for.
+     * @returns {V | undefined} The value for the key, or undefined if it doesn't exist.
      */
-    readonly encoded?: string;
+    get<K extends StorageKeys, V extends StorageValues<K>>(key: K): V | undefined;
     /**
-     * The track info.
-     * @type {UnresolvedTrackInfo}
+     * Set the value for a key in the storage.
+     * @param {K} key The key to set the value for.
+     * @param {V} value The value to set for the key.
      */
-    readonly info: UnresolvedTrackInfo;
+    set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): void;
     /**
-     * The plugin info of the track.
-     * @type {Partial<PluginInfo>}
+     * Check if the storage has a key.
+     * @param {K} key The key to check for.
+     * @returns {boolean} True if the storage has the key, false otherwise.
      */
-    readonly pluginInfo?: Partial<PluginInfo>;
+    has(key: K): boolean;
     /**
-     * The track user data.
-     * @type {Record<string, unknown> | undefined}
+     * Delete a key from the storage.
+     * @param {K} key The key to delete.
+     * @returns {boolean} True if the key was deleted, false otherwise.
      */
-    userData?: Record<string, unknown>;
+    delete(key: K): boolean;
     /**
-     * The requester of the track.
-     * @type {TrackRequester | undefined}
+     * Get all keys in the storage.
+     * @returns {K[]} The keys in the storage.
      */
-    requester: TrackRequester;
+    keys<K extends StorageKeys[]>(): K[];
     /**
-     * The constructor for the track.
-     * @param {UnresolvedLavalinkTrack} track The track to construct the track from.
-     * @param {TrackRequester} requester The requester of the track.
-     * @example
-     * ```ts
-     * const track = new UnresolvedTrack({
-     * 	encoded: "base64",
-     * 	info: {
-     * 		title: "Track Title",
-     * 	},
-     * 	// the rest of the track info
-     * }, requester);
-     *
-     * console.log(track.encoded); // the track encoded in base64
-     * ```
+     * Get all values in the storage.
+     * @returns {V[]} The values in the storage.
      */
-    constructor(track: UnresolvedLavalinkTrack, requester: TrackRequester);
+    values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): V[];
     /**
-     * Resolves the track to a playable track.
-     * @param {PlayerStructure} player The player to resolve the track for.
-     * @returns {Promise<Track>} The resolved track.
-     * @throws {ResolveError} If the track cannot be resolved.
+     * Get all entries in the storage.
+     * @returns {[K, V][]} The entries in the storage.
      */
-    resolve(player: PlayerStructure): Promise<Track>;
-}
-/**
- * Type representing a Hoshimi track, which can be either a resolved or unresolved track.
- */
-type HoshimiTrack = Track | UnresolvedTrack;
-/**
- * Interface representing an extendable track.
- */
-interface CustomizableTrack {
+    entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): [K, V][];
+    /**
+     *
+     * Get all key-value pairs in the storage.
+     * @returns {Record<K[number], V>} An object containing all key-value pairs in the storage, excluding internal keys.
+     */
+    all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Record<K[number], V>;
+    /**
+     * Clear the storage.
+     */
+    clear(): void;
+    /**
+     * Get the size of the storage.
+     * @returns {number} The number of entries in the storage.
+     */
+    get size(): number;
 }
-/**
- * The requester of the track.
- */
-type TrackRequester = Inferable<CustomizableTrack, "requester">;
 
 /**
- * Partial Lavalink track type.
+ * Type representing a nullable voice channel update.
  */
-type PartialLavalinkTrack = Partial<Nullable<LavalinkTrack>>;
+type NullableVoiceChannelUpdate = Partial<Nullable<VoiceChannelUpdate>>;
 /**
- * The base options for playing a track.
+ * Class representing a Hoshimi player.
+ * @class Player
  */
-interface BasePlayOptions {
-    /**
-     * The position to start the track.
-     * @type {number | undefined}
-     */
-    position?: number;
-    /**
-     * The position to end the track.
-     * @type {number | undefined}
-     */
-    endTime?: number;
+declare class Player {
     /**
-     * The pause state of the player.
-     * @type {boolean | undefined}
+     * The data for the player.
+     * @type {PlayerStorage}
+     * @readonly
      */
-    paused?: boolean;
+    readonly data: PlayerStorage;
     /**
-     * The volume of the player.
-     * @type {number | undefined}
+     * The options for the player.
+     * @type {PlayerOptions}
+     * @readonly
      */
-    volume?: number;
+    readonly options: PlayerOptions;
     /**
-     * The filters for the player.
-     * @type {Partial<FilterSettings> | undefined}
+     * The manager for the player.
+     * @type {Hoshimi}
+     * @readonly
      */
-    filters?: Partial<FilterSettings>;
+    readonly manager: Hoshimi;
     /**
-     * The voice settings for the player.
-     * @type {LavalinkPlayerVoice | undefined}
+     * The queue for the player.
+     * @type {Queue}
+     * @readonly
      */
-    voice?: LavalinkPlayerVoice;
-}
-/**
- * The types of loop modes.
- */
-declare enum LoopMode {
+    readonly queue: QueueStructure;
     /**
-     * Loop mode for repeating the current track.
+     * The filter manager for the player.
+     * @type {FilterManager}
+     * @readonly
      */
-    Track = 1,
+    readonly filterManager: FilterManager;
     /**
-     * Loop mode for repeating the queue.
+     * The node for the player.
+     * @type {NodeStructure}
      */
-    Queue = 2,
+    node: NodeStructure;
     /**
-     * Loop mode for repeating nothing.
+     * Check if the player is self deafened.
+     * @type {boolean}
      */
-    Off = 3
-}
-/**
- * The types of player events.
- */
-declare enum PlayerEventType {
+    selfDeaf: boolean;
     /**
-     * Event type for when a track starts.
+     * Check if the player is self muted.
+     * @type {boolean}
      */
-    TrackStart = "TrackStartEvent",
+    selfMute: boolean;
     /**
-     * Event type for when a track ends.
+     * Loop mode of the player.
+     * @type {LoopMode}
+     * @default LoopMode.Off
      */
-    TrackEnd = "TrackEndEvent",
+    loop: LoopMode;
     /**
-     * Event type for when a track encounters an exception.
+     * Check if the player is playing.
+     * @type {boolean}
+     * @default false
      */
-    TrackException = "TrackExceptionEvent",
+    playing: boolean;
     /**
-     * Event type for when a track gets stuck.
+     * Check if the player is paused.
+     * @type {boolean}
+     * @default false
      */
-    TrackStuck = "TrackStuckEvent",
+    paused: boolean;
     /**
-     * Event type for when lyrics are found.
+     * Check if the player is connected.
+     * @type {boolean}
+     * @default false
      */
-    LyricsFound = "LyricsFoundEvent",
+    connected: boolean;
     /**
-     * Event type for when lyrics are not found.
+     * Volume of the player.
+     * @type {number}
+     * @default 100
      */
-    LyricsNotFound = "LyricsNotFoundEvent",
+    volume: number;
     /**
-     * Event type for when a lyrics line is sent.
+     * Guild ig of the player.
+     * @type {string}
      */
-    LyricsLine = "LyricsLineEvent",
+    guildId: string;
     /**
-     * Event type for when the WebSocket connection is closed.
+     * Voice channel idof the player.
+     * @type {string | undefined}
      */
-    WebsocketClosed = "WebSocketClosedEvent"
-}
-/**
- * The reasons a track can end.
- */
-declare enum TrackEndReason {
+    voiceId: string | undefined;
     /**
-     * The track ended normally.
+     * Text channel id of the player.
+     * @type {string | undefined}
      */
-    Finished = "finished",
+    textId: string | undefined;
     /**
-     * The track fails to load.
+     * The ping of the player.
+     * @type {number}
      */
-    LoadFailed = "loadFailed",
+    ping: number;
     /**
-     * The track was stopped.
+     * The timestamp when the player was created.
+     * @type {number}
      */
-    Stopped = "stopped",
+    createdTimestamp: number;
     /**
-     * The track was replaced.
+     * The last position received from Lavalink.
+     * @type {number}
      */
-    Replaced = "replaced",
+    lastPosition: number;
     /**
-     * The track was cleaned up.
+     * The timestamp when the last position change update happened.
+     * @type {number | null}
      */
-    Cleanup = "cleanup"
-}
-/**
- * The base interface for player events.
- */
-interface PlayerEvent {
+    lastPositionUpdate: number | null;
     /**
-     * The operation code for the event.
-     * @type {OpCodes.Event}
+     * The current calculated position of the player.
+     * @type {number}
+     * @readonly
      */
-    op: OpCodes.Event;
+    get position(): number;
     /**
-     * The guild ID associated with the event.
-     * @type {string}
+     * The voice connection details.
+     * @type {PlayerVoice}
      */
-    guildId: string;
-}
-/**
- * The event for when a track starts playing.
- */
-interface TrackStartEvent extends PlayerEvent {
+    voice: Nullable<LavalinkPlayerVoice>;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackStart}
+     *
+     * Create a new player.
+     * @param {Hoshimi} manager The manager for the player.
+     * @param {PlayOptions} options The options for the player.
+     * @example
+     * ```ts
+     * const player = new Player(manager, {
+     * 	guildId: "guildId",
+     * 	voiceId: "voiceId",
+     * 	textId: "textId",
+     * 	selfDeaf: true,
+     * 	selfMute: false,
+     * 	volume: 100,
+     * });
+     *
+     * console.log(player.guildId); // guildId
+     * console.log(player.voiceId); // voiceId
+     * console.log(player.textId); // textId
      */
-    type: PlayerEventType.TrackStart;
+    constructor(manager: Hoshimi, options: PlayerOptions);
     /**
-     * The track that started playing.
-     * @type {LavalinkTrack}
+     * The lyrics methods for the player.
+     * @type {LyricsMethods}
+     * @readonly
      */
-    track: LavalinkTrack;
-}
-/**
- * The event for when a track ends.
- */
-interface TrackEndEvent extends PlayerEvent {
+    readonly lyrics: LyricsMethods;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackEnd}
+     *
+     * Search for a track or playlist.
+     * @param {SearchOptions} options The options for the search.
+     * @returns {Promise<QueryResult>} The search result.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * const result = await player.search({
+     * 	query: "track name",
+     * 	engine: SearchEngine.Youtube,
+     * 	requester: {},
+     * });
+     *
+     * console.log(result) // the search result
+     * ```
      */
-    type: PlayerEventType.TrackEnd;
+    search(options: SearchOptions): Promise<QueryResult>;
     /**
-     * The track that ended.
-     * @type {LavalinkTrack}
+     *
+     * Play the next track in the queue.
+     * @param {number} [to=0] The amount of tracks to skip.
+     * @param {boolean} [throwError=true] Whether to throw an error if there are no tracks to skip.
+     * @returns {Promise<void>}
+     * @throws {PlayerError} If there are no tracks to skip.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.skip(2); // skip 2 tracks
+     * player.skip(); // skip 1 track
+     * ```
      */
-    track: LavalinkTrack;
+    skip(to?: number, throwError?: boolean): Promise<void>;
     /**
-     * The reason the track ended.
-     * @type {TrackEndReason}
+     *
+     * Seek to a specific position in the current track.
+     * @param {number} position The position to seek to in milliseconds.
+     * @returns {Promise<void>}
+     * @throws {PlayerError} If the position is invalid.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.seek(30000); // seek to 30 seconds
+     * ```
      */
-    reason: TrackEndReason;
-}
-/**
- * The event for when a track gets stuck.
- */
-interface TrackStuckEvent extends PlayerEvent {
+    seek(position: number): Promise<void>;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackStuck}
+     *
+     * Disconnect the player from the voice channel.
+     * @returns {Promise<this>} The player instance.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.disconnect();
+     * ```
      */
-    type: PlayerEventType.TrackStuck;
+    disconnect(): Promise<this>;
     /**
-     * The track that got stuck.
-     * @type {LavalinkTrack}
+     *
+     * Destroy and disconnect the player.
+     * @param {DestroyReasons} [reason] The reason for destroying the player.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.destroy(DestroyReasons.Stop);
+     * ```
      */
-    track: LavalinkTrack;
+    destroy(reason?: DestroyReasons): Promise<boolean>;
     /**
-     * The threshold in milliseconds.
-     * @type {number}
+     *
+     * Play a track in the player.
+     * @param {Partial<PlayOptions>} [options] The options to play the track.
+     * @returns {Promise<void>}
+     * @throws {PlayerError} If there are no tracks to play.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     *
+     * player.play({
+     * 	track: track,
+     * 	noReplace: true,
+     * });
+     * ```
      */
-    thresholdMs: number;
-}
-/**
- * The event for when a track encounters an exception.
- */
-interface TrackExceptionEvent extends PlayerEvent {
+    play(options?: Partial<PlayOptions>): Promise<void>;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackException}
+     * Connect the player to the voice channel.
+     * @returns {Promise<this>} The player instance.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.connect();
+     * ```
      */
-    type: PlayerEventType.TrackException;
+    connect(): Promise<this>;
     /**
-     * The exception that occurred.
-     * @type {Exception}
+     *
+     * Stop the player from playing.
+     * @param {boolean} [destroy=true] Whether to destroy the player or not.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.stop();
+     * ```
      */
-    exception: Exception;
-}
-/**
- * The event for when the WebSocket connection is closed.
- */
-interface WebSocketClosedEvent extends PlayerEvent {
+    stop(destroy?: boolean): Promise<void>;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.WebsocketClosed}
+     *
+     * Pause or resume the player.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.setPaused();
+     * ```
      */
-    type: PlayerEventType.WebsocketClosed;
+    setPaused(paused?: boolean): Promise<boolean>;
     /**
-     * The close code.
-     * @type {number}
+     *
+     * Set the volume of the player.
+     * @param {number} volume The volume to set.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.setVolume(50); // set the volume to 50%
+     * ```
      */
-    code: number;
+    setVolume(volume: number): Promise<void>;
     /**
-     * Whether the connection was closed by the remote.
-     * @type {boolean}
+     *
+     * Set the loop mode of the player.
+     * @param {LoopMode} mode The loop mode to set.
+     * @throws {PlayerError} If the loop mode is invalid.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.setLoop(LoopMode.Track);
+     * ```
      */
-    byRemote: boolean;
+    setLoop(mode: LoopMode): this;
     /**
-     * The reason for the closure.
-     * @type {string}
+     * Set the voice of the player.
+     * @param {NullableVoiceChannelUpdate} options The voice state to set.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.setVoice({ voiceId: "newVoiceId" });
+     * ```
      */
-    reason: string;
-}
-/**
- * The event for when lyrics are found.
- */
-interface LyricsFoundEvent extends PlayerEvent {
+    setVoice(options?: NullableVoiceChannelUpdate): Promise<void>;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsFound}
+     *
+     * Change the node the player is connected to.
+     * @param {NodeIdentifier} node The node to change to.
+     * @returns {Promise<void>} A promise that resolves when the node has been changed.
+     * @throws {PlayerError} If the target node is not found, not connected, or missing source managers.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.move("newNodeId");
+     * ```
      */
-    type: PlayerEventType.LyricsFound;
+    move(node: NodeIdentifier): Promise<void>;
     /**
-     * The guild id associated with the event.
-     * @type {string}
+     * Update the player with new data.
+     * @param {NonGuildUpdatePlayerInfo} data The data to update the player with.
+     * @returns {Promise<LavalinkPlayer | null>} The updated player data.
      */
-    guildId: string;
+    updatePlayer(data: NonGuildUpdatePlayerInfo): Promise<LavalinkPlayer | null>;
     /**
-     * The lyrics result of the event.
-     * @type {LyricsResult}
+     *
+     * Return the player as a json object.
+     * @returns {PlayerJson}
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * const json = player.toJSON();
+     * console.log(json); // the player as a json object
+     * ```
      */
-    lyrics: LyricsResult;
+    toJSON(): PlayerJson;
 }
 /**
- * The event for when lyrics are not found.
+ * Type representing the update player information without guildId.
  */
-interface LyricsNotFoundEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsNotFound}
-     */
-    type: PlayerEventType.LyricsNotFound;
-    /**
-     * The guild id associated with the event.
-     * @type {string}
-     */
-    guildId: string;
-}
+type NonGuildUpdatePlayerInfo = Omit<UpdatePlayerInfo, "guildId">;
 /**
- * The event for when a lyrics line is sent.
+ * Interface representing the customizable player storage.
  */
-interface LyricsLineEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsLine}
-     */
-    type: PlayerEventType.LyricsLine;
-    /**
-     * The guild id associated with the event.
-     * @type {string}
-     */
-    guildId: string;
-    /**
-     * The line index of the lyrics line.
-     * @type {number}
-     */
-    lineIndex: number;
-    /**
-     * The lyrics line of the event.
-     * @type {LyricsLine}
-     */
-    line: LyricsLine;
-    /**
-     * Returns if the line was skipped.
-     * @type {boolean}
-     */
-    skipped: boolean;
+interface CustomizablePlayerStorage {
 }
+
 /**
- * The update for the player state.
+ * Class representing the queue utils.
+ * @class QueueUtils
  */
-interface PlayerUpdate {
+declare class QueueUtils {
     /**
-     * The operation code for the update.
-     * @type {OpCodes.PlayerUpdate}
+     *
+     * Constructor of the queue utils.
+     * @param {QueueStructure} queue The queue instance.
      */
-    op: OpCodes.PlayerUpdate;
+    constructor(queue: QueueStructure);
     /**
-     * The guild ID associated with the update.
-     * @type {string}
+     *
+     * Save the queue.
+     * @returns {Awaitable<void>}
+     * @example
+     * ```ts
+     * await player.queue.utils.save();
+     * ```
      */
-    guildId: string;
+    save(): Awaitable<void>;
     /**
-     * The state of the player.
-     * @type {PlayerUpdateState}
+     *
+     * Destroy the queue.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * await player.queue.utils.destroy();
+     * ```
+     */
+    destroy(): Awaitable<boolean>;
+    /**
+     *
+     * Sync the queue.
+     * @returns {Awaitable<void>}
+     * @example
+     * ```ts
+     * await player.queue.utils.sync();
+     * ```
      */
-    state: PlayerUpdateState;
+    sync(override?: boolean, syncCurrent?: boolean): Promise<void>;
 }
-interface PlayerUpdateState {
+
+/**
+ * Class representing a queue.
+ * @class Queue
+ */
+declare class Queue {
     /**
-     * Whether the player is connected.
-     * @type {boolean}
+     * Tracks of the queue.
+     * @type {HoshimiTrack[]}
      */
-    connected: boolean;
+    tracks: HoshimiTrack[];
     /**
-     * The position of the track.
-     * @type {number}
+     * Previous tracks of the queue.
+     * @type {Track[]}
      */
-    position: number;
+    history: Track[];
     /**
-     * The time of the update.
-     * @type {number}
+     * Current track of the queue.
+     * @type {Track | null}
      */
-    time: number;
+    current: Track | null;
     /**
-     * The ping of the player.
-     * @type {number}
+     * The player instance.
+     * @type {PlayerStructure}
      */
-    ping: number;
-}
-/**
- * The options for the player.
- */
-interface PlayerOptions {
+    readonly player: PlayerStructure;
     /**
-     * Guild id of the player.
-     * @type {string}
+     * The queue utils instance.
+     * @type {QueueUtils}
+     * @readonly
      */
-    guildId: string;
+    readonly utils: QueueUtils;
     /**
-     * Voice channel id of the player.
-     * @type {string}
+     *
+     * Constructor of the queue.
+     * @param {PlayerStructure} player Player instance.
+     * @example
+     * ```ts
+     * const player = new Player();
+     * const queue = new Queue(player);
+     *
+     * console.log(queue.size); // 0
+     * queue.add(track);
+     * console.log(queue.size); // 1
+     * ```
      */
-    voiceId: string;
+    constructor(player: PlayerStructure);
     /**
-     * Volume of the player.
-     * @type {number | undefined}
-     * @default 100
+     * Get the track size of the queue.
+     * @type {number}
+     * @returns {number} The track size of the queue.
+     * @readonly
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(queue.size); // 0
+     * queue.add(track);
+     *
+     * console.log(queue.size); // 1
+     * queue.add([track1, track2]);
+     *
+     * console.log(queue.size); // 3
+     * queue.shift();
+     * console.log(queue.size); // 2
+     *
+     * queue.clear();
+     * console.log(queue.size); // 0
+     * ```
      */
-    volume?: number;
+    get size(): number;
     /**
-     * Set if the player should be deafened.
-     * @type {boolean | undefined}
-     * @default true
+     * Get the total track size of the queue (Includes the current track).
+     * @type {number}
+     * @returns {number} The total track size of the queue.
+     * @readonly
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(queue.totalSize); // 0
+     * queue.add(track);
+     *
+     * console.log(queue.totalSize); // 1
+     * queue.add([track1, track2]);
+     *
+     * console.log(queue.totalSize); // 3
+     * queue.shift();
+     * console.log(queue.totalSize); // 2
+     *
+     * queue.clear();
+     * console.log(queue.totalSize); // 0
+     * ```
      */
-    selfDeaf?: boolean;
+    get totalSize(): number;
     /**
-     * Set if the player should be muted.
-     * @type {boolean | undefined}
-     * @default false
+     *
+     * Check if the queue is empty.
+     * @type {boolean}
+     * @returns {boolean} True if the queue is empty.
+     * @readonly
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(queue.isEmpty()); // true
+     * queue.add(track);
+     *
+     * console.log(queue.isEmpty()); // false
+     * queue.clear();
+     *
+     * console.log(queue.isEmpty()); // true
+     * ```
      */
-    selfMute?: boolean;
+    isEmpty(): boolean;
     /**
-     * Text channel id of the player.
-     * @type {string | undefined}
+     *
+     * Build a track from a Lavalink track or unresolved Lavalink track.
+     * @param {LavalinkTrack | UnresolvedLavalinkTrack} track The track to build.
+     * @param {TrackRequester} requester The requester of the track.
+     * @returns {Promise<Track>} The built track.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     * const lavalinkTrack = {...} // some lavalink track
+     * const track = await queue.build(lavalinkTrack, author);
+     *
+     * console.log(track.info.title); // The title of the track
+     * ```
      */
-    textId?: string;
+    build(track: LavalinkTrack | UnresolvedLavalinkTrack | HoshimiTrack, requester: TrackRequester): Promise<Track>;
     /**
-     * Lavalink node of the player.
-     * @type {NodeIdentifier}
+     *
+     * Get the previous track of the queue.
+     * @param {boolean} [remove=false] Whether to remove the track from the previous queue.
+     * @returns {Promise<Track | null>} The previous track of the queue.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(await queue.previous()); // null
+     * queue.add(track);
+     * queue.add(track2);
+     *
+     * console.log(await queue.previous()); // track
+     * console.log(await queue.previous(true)); // track and remove it from the previous tracks
+     * ```
      */
-    node?: NodeIdentifier;
-}
-/**
- * The options for playing a track with Lavalink.
- */
-interface LavalinkPlayOptions extends BasePlayOptions {
+    previous(remove?: boolean): Promise<Track | null>;
     /**
-     * Track to play.
-     * @type {PartialLavalinkTrack | undefined}
+     *
+     * Add a track or tracks to the queue.
+     * @param {Track | Track[]} track The track or tracks to add.
+     * @param {number} [position] The position to add the track or tracks.
+     * @returns {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(queue.size); // 0
+     *
+     * await queue.add(track);
+     * console.log(queue.size); // 1
+     *
+     * await queue.add([track1, track2]);
+     * console.log(queue.size); // 3
+     *
+     * await queue.add(track3, 1);
+     * console.log(queue.size); // 4
+     * console.log(queue.tracks); // [track1, track3, track2, track]
+     * ```
      */
-    track?: PartialLavalinkTrack;
-}
-/**
- * The options for playing a track.
- */
-interface PlayOptions extends BasePlayOptions {
+    add(track: HoshimiTrack | HoshimiTrack[], position?: number): Promise<this>;
     /**
-     * Whether to replace the current track.
-     * @type {boolean | undefined}
-     * @default false
+     *
+     * Get the first track of the queue.
+     * @returns {Promise<HoshimiTrack | null>} The first track of the queue.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(await queue.shift()); // null
+     * await queue.add(track);
+     *
+     * console.log(await queue.shift()); // track
+     * await queue.add(track2);
+     * ```
      */
-    noReplace?: boolean;
+    shift(): Promise<HoshimiTrack | null>;
     /**
-     * Track to play.
-     * @type {Track | UnresolvedTrack | undefined}
+     *
+     * Add tracks to the beginning of the queue.
+     * @param {Track[]} tracks The tracks to add.
+     * @returns {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(queue.size); // 0
+     * await queue.unshift(track);
+     *
+     * console.log(queue.size); // 1
+     * await queue.unshift(track1, track2);
+     *
+     * console.log(queue.size); // 3
+     * console.log(queue.tracks); // [track1, track2, track]
+     * ```
      */
-    track?: Track | UnresolvedTrack;
-}
-interface PlayerVoice {
+    unshift(...tracks: Track[]): Promise<this>;
     /**
-     * The voice server token.
-     * @type {string}
+     *
+     * Shuffle the queue.
+     * @returns {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(queue.size); // 0
+     * await queue.add(track);
+     * await queue.add(track1, track2);
+     *
+     * console.log(queue.size); // 3
+     * console.log(queue.tracks); // [track, track1, track2]
+     *
+     * await queue.shuffle();
+     * console.log(queue.tracks); // [track2, track, track1]
+     * ```
      */
-    token: string;
+    shuffle(): Promise<this>;
     /**
-     * The voice server endpoint.
-     * @type {string}
+     *
+     * Clear the queue.
+     * @returns {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     *
+     * console.log(queue.size); // 0
+     * await queue.add(track);
+     * await queue.add(track1, track2);
+     *
+     * console.log(queue.size); // 3
+     * await queue.clear();
+     * console.log(queue.size); // 0
+     * ```
      */
-    endpoint: string;
+    clear(): Promise<this>;
     /**
-     * The voice server session id.
-     * @type {string}
+     *
+     * Move a track to a specific position in the queue.
+     * @param {Track} track The track to move.
+     * @param {number} to The position to move.
+     * @returns {Promise<this>} The queue instance.
      */
-    sessionId: string;
+    move(track: Track, to: number): Promise<this>;
     /**
-     * The voice server guild id.
-     * @type {string | undefined}
+     *
+     * Delete tracks from the queue.
+     * @param {number} start The start index.
+     * @param {number} deleteCount The number of tracks to delete.
+     * @param {Track | Track[]} [tracks] The tracks to add.
+     * @returns {Promise<this>} The queue instance.
      */
-    connected?: boolean;
+    splice(start: number, deleteCount: number, tracks?: HoshimiTrack | HoshimiTrack[]): Promise<this>;
     /**
-     * The voice server ping.
-     * @type {number | undefined}
+     *
+     * Convert the queue to a JSON object.
+     * @returns {QueueJson} The queue JSON object.
      */
-    ping?: number;
+    toJSON(): QueueJson;
 }
+
 /**
- * The JSON representation of the player.
+ * The structure for the Player class.
  */
-interface PlayerJson {
+type PlayerStructure = InferCustomStructure<Player, "Player">;
+/**
+ * The structure for the Rest class.
+ */
+type RestStructure = InferCustomStructure<Rest, "Rest">;
+/**
+ * The structure for the Node class.
+ */
+type NodeStructure = InferCustomStructure<Node, "Node">;
+/**
+ * The structure for the Queue class.
+ */
+type QueueStructure = InferCustomStructure<Queue, "Queue">;
+/**
+ * The structure for the LyricsManager class.
+ */
+type LyricsManagerStructure = InferCustomStructure<LyricsManager, "LyricsManager">;
+/**
+ * The structure for the NodeManager class.
+ */
+type NodeManagerStructure = InferCustomStructure<NodeManager, "NodeManager">;
+/**
+ * The structure for the FilterManager class.
+ */
+type FilterManagerStructure = InferCustomStructure<FilterManager, "FilterManager">;
+/**
+ * The structures of the Hoshimi classes.
+ */
+declare const Structures: {
+    Player(manager: Hoshimi, options: PlayerOptions): PlayerStructure;
+    Rest(node: Node): RestStructure;
+    Node(nodeManager: NodeManager, options: NodeOptions): NodeStructure;
+    Queue(player: Player): QueueStructure;
+    LyricsManager(node: Node): LyricsManagerStructure;
+    NodeManager(manager: Hoshimi): NodeManagerStructure;
+    FilterManager(player: Player): FilterManagerStructure;
+};
+/**
+ * Infers the custom structure for a given class.
+ */
+type InferCustomStructure<T, N extends string> = CustomizableStructures extends Record<N, infer P> ? P : T;
+
+/**
+ * Class representing a Hoshimi track.
+ * @class Track
+ * @implements {LavalinkTrack}
+ */
+declare class Track implements LavalinkTrack {
     /**
-     * The guild id of the player.
+     * The base64 encoded track.
      * @type {string}
      */
-    guildId: string;
-    /**
-     * The volume of the player.
-     * @type {number}
-     */
-    volume: number;
-    /**
-     * The self deaf state of the player.
-     * @type {boolean}
-     */
-    selfDeaf: boolean;
-    /**
-     * The self mute state of the player.
-     * @type {boolean}
-     */
-    selfMute: boolean;
+    readonly encoded: string;
     /**
-     * The voice settings for the player.
-     * @type {LavalinkPlayerVoice}
+     * The track info.
+     * @type {TrackInfo}
      */
-    voice: Nullable<LavalinkPlayerVoice>;
+    readonly info: TrackInfo;
     /**
-     * The loop mode of the player.
-     * @type {LoopMode}
+     * The plugin info of the track.
+     * @type {PluginInfo}
      */
-    loop: LoopMode;
+    readonly pluginInfo: PluginInfo;
     /**
-     * The options for the player.
-     * @type {boolean}
+     * The track user data.
+     * @type {TrackUserData}
      */
-    options: PlayerOptions;
+    userData: TrackUserData;
     /**
-     * The paused state of the player.
-     * @type {boolean}
+     * The requester of the track.
+     * @type {TrackRequester}
      */
-    paused: boolean;
+    requester: TrackRequester;
     /**
-     * The playing state of the player.
-     * @type {boolean}
+     * The constructor for the track.
+     * @param {LavalinkTrack} track The track to construct the track from.
+     * @param {TrackRequester} requester The requester of the track.
+     * @example
+     * ```ts
+     * const track = new Track({
+     * 	encoded: "base64",
+     * 	info: {
+     * 		title: "Track Title",
+     * 		uri: "https://example.com",
+     * 		duration: 300000,
+     * 	},
+     * 	// the rest of the track info
+     * }, requester);
+     *
+     * console.log(track.encoded); // the track encoded in base64
+     * ```
      */
-    playing: boolean;
+    constructor(track: LavalinkTrack | null, requester?: TrackRequester);
     /**
-     * The voice channel id of the player.
-     * @type {string}
+     *
+     * Get the hyperlink of the track.
+     * @param {boolean} [embedable=true] Whether the hyperlink should be embedable or not.
+     * @returns {string} The hyperlink of the track.
+     * @example
+     * ```ts
+     * const track = queue.current;
+     * console.log(track.toHyperlink()); // [Track Title](https://example.com)
+     * console.log(track.toHyperlink(false)); // [Track Title](<https://example.com>)
+     * ```
      */
-    voiceId?: string;
+    toHyperlink(embedable?: boolean): string;
+}
+/**
+ * Class representing an unresolved track.
+ * @class UnresolvedTrack
+ * @implements {UnresolvedLavalinkTrack}
+ */
+declare class UnresolvedTrack implements UnresolvedLavalinkTrack {
     /**
-     * The text channel id of the player.
+     * The base64 encoded track.
      * @type {string | undefined}
      */
-    textId?: string;
+    readonly encoded?: string;
     /**
-     * The queue of the player.
-     * @type {QueueJson | undefined}
+     * The track info.
+     * @type {UnresolvedTrackInfo}
      */
-    queue?: QueueJson;
+    readonly info: UnresolvedTrackInfo;
     /**
-     * The node of the player.
-     * @type {NodeJson | undefined}
+     * The plugin info of the track.
+     * @type {Partial<PluginInfo>}
      */
-    node?: NodeJson;
-}
-/**
- * The lyrics methods for the player.
- */
-interface LyricsMethods {
+    readonly pluginInfo?: Partial<PluginInfo>;
     /**
-     *
-     * Get the current lyrics for the current track.
-     * @param {boolean} [skipSource=false] Whether to skip the source or not.
-     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const lyrics = await player.lyricsManager.current();
-     * ```
+     * The track user data.
+     * @type {TrackUserData | undefined}
      */
-    current(skipSource?: boolean): Promise<LyricsResult | null>;
+    userData?: TrackUserData;
     /**
-     *
-     * Get the lyrics for a specific track.
-     * @param {Track} track The track to get the lyrics for.
-     * @param {boolean} [skipSource=false] Whether to skip the source or not.
-     * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const track = player.queue.current;
-     * const lyrics = await player.lyrics.get(track);
-     * ```
+     * The requester of the track.
+     * @type {TrackRequester | undefined}
      */
-    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    requester: TrackRequester;
     /**
-     *
-     * Subscribe to the lyrics for a specific guild.
-     * @param {boolean} [skipSource=false] Whether to skip the source or not.
-     * @returns {Promise<void>} Let's start the sing session!
+     * The constructor for the track.
+     * @param {UnresolvedLavalinkTrack} track The track to construct the track from.
+     * @param {TrackRequester} requester The requester of the track.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * await player.lyrics.subscribe();
+     * const track = new UnresolvedTrack({
+     * 	encoded: "base64",
+     * 	info: {
+     * 		title: "Track Title",
+     * 	},
+     * 	// the rest of the track info
+     * }, requester);
+     *
+     * console.log(track.encoded); // the track encoded in base64
      * ```
      */
-    subscribe(skipSource?: boolean): Promise<void>;
+    constructor(track: UnresolvedLavalinkTrack, requester?: TrackRequester);
     /**
-     *
-     * Unsubscribe from the lyrics for a specific guild.
-     * @returns {Promise<void>} Let's stop the sing session!
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * await player.lyrics.unsubscribe();
-     * ```
+     * Resolves the track to a playable track.
+     * @param {PlayerStructure} player The player to resolve the track for.
+     * @returns {Promise<Track>} The resolved track.
+     * @throws {ResolveError} If the track cannot be resolved.
      */
-    unsubscribe(): Promise<void>;
+    resolve(player: PlayerStructure): Promise<Track>;
 }
 /**
- * The voice channel update options.
+ * Type representing a Hoshimi track, which can be either a resolved or unresolved track.
  */
-type VoiceChannelUpdate = Pick<PlayerOptions, "selfDeaf" | "voiceId" | "selfMute">;
+type HoshimiTrack = Track | UnresolvedTrack;
 /**
- * The voice settings for the player.
+ * Interface representing an extendable track.
  */
-type LavalinkPlayerVoice = Omit<PlayerVoice, "connected" | "ping">;
+interface CustomizableTrack {
+}
+/**
+ * The requester of the track.
+ */
+type TrackRequester = Inferable<CustomizableTrack, "requester">;
+/**
+ * The user data of the track.
+ */
+type TrackUserData = Inferable<CustomizableTrack, "userData">;
 
 /**
  * The states.
@@ -3908,9 +4039,9 @@ interface LavalinkTrack {
     info: TrackInfo;
     /**
      * The user data of the track.
-     * @type {Record<string, unknown> | undefined}
+     * @type {TrackUserData | undefined}
      */
-    userData?: Record<string, unknown>;
+    userData?: TrackUserData;
 }
 interface UnresolvedLavalinkTrack {
     /**
@@ -3930,9 +4061,9 @@ interface UnresolvedLavalinkTrack {
     pluginInfo?: Partial<PluginInfo>;
     /**
      * The user data of the track.
-     * @type {Record<string, unknown> | undefined}
+     * @type {TrackUserData | undefined}
      */
-    userData?: Record<string, unknown>;
+    userData?: TrackUserData;
 }
 /**
  * The track information.
@@ -5122,6 +5253,10 @@ declare enum Events {
      * Emitted when the player is destroyed.
      */
     PlayerDestroy = "playerDestroy",
+    /**
+     * Emitted when the player has an error.
+     */
+    PlayerError = "playerError",
     /**
      * Emitted when a track starts playing.
      */
@@ -5190,7 +5325,15 @@ declare enum DestroyReasons {
     /**
      * The player was destroyed because the voice channel was deleted.
      */
-    VoiceChannelDeleted = "Player-VoiceChannelDeleted"
+    VoiceChannelDeleted = "Player-VoiceChannelDeleted",
+    /**
+     * The player was destroyed because it left the voice channel.
+     */
+    VoiceChannelLeft = "Player-VoiceChannelLeft",
+    /**
+     * The player was destroyed because it failed to reconnect.
+     */
+    ReconnectFailed = "Player-ReconnectFailed"
 }
 /**
  * The client data for the manager.
@@ -5289,6 +5432,11 @@ interface HoshimiOptions {
      * @type {HoshimiRestOptions}
      */
     restOptions?: HoshimiRestOptions;
+    /**
+     * The player options to use.
+     * @type {HoshimiPlayerOptions}
+     */
+    playerOptions?: HoshimiPlayerOptions;
 }
 /**
  * The events for the manager.
@@ -5371,6 +5519,12 @@ interface HoshimiEvents {
      * @param {string} reason The reason for the destroy.
      */
     playerDestroy: [player: PlayerStructure, reason: string];
+    /**
+     * Emitted when the player has an error.
+     * @param {PlayerStructure} player The player that emitted the event.
+     * @param {Error | unknown} error The error that was emitted.
+     */
+    playerError: [player: PlayerStructure, error: Error | unknown];
     /**
      * Emitted when a track starts playing.
      * @param {PlayerStructure} player The player that emitted the event.
@@ -5753,10 +5907,24 @@ declare class Hoshimi extends EventEmitter<RawEvents> {
      * 		resumeByLibrary: false,
      * 	},
      * 	queueOptions: {
-     * 		maxPreviousTracks: 25,
-     * 		autoplayFn: autoplayFn,
-     * 		autoPlay: false,
+     *      maxHistory: 25,
+     *      autoplayFn: autoplayFn,
+     *      autoPlay: false,
+     *      storage: new MemoryAdapter(),
+     *      requesterFn: defaultRequesterFn,
      * 	},
+     *   playerOptions: {
+     *    	onDisconnect: {
+     *        autoDestroy: false,
+     *        autoReconnect: false,
+     *        autoQueue: false,
+     *   	},
+     *   	onError: {
+     *        autoDestroy: false,
+     *        autoSkip: false,
+     *        autoStop: false,
+     *      },
+     *   },
      * });
      *
      * console.log(manager); // The manager instance
@@ -5890,4 +6058,4 @@ declare class MemoryAdapter<T extends QueueJson = QueueJson> extends StorageAdap
     stringify<R = string>(value: unknown): R;
 }
 
-export { AudioOutput, type Awaitable, type ChannelDelete, type ChannelDeletePacket, type ChannelMixSettings, type ClientData, type CustomizablePlayerStorage, type CustomizableStructures, type CustomizableTrack, DSPXPluginFilter, DebugLevels, type DecodeMethods, type DeepRequired, DestroyReasons, type DistortionSettings, type EQBandSettings, type EchoSettings, type EnabledDSPXPluginFilters, type EnabledLavalinkFilters, type EnabledPlayerFilters, Events, type Exception, type FetchOptions, FilterManager, type FilterManagerStructure, type FilterPluginPassSettings, type FilterSettings, FilterType, type FreqSettings, type GatewayPayload, type GatewaySendPayload, Hoshimi, type HoshimiEvents, type HoshimiNodeOptions, type HoshimiOptions, type HoshimiQueueOptions, type HoshimiRestOptions, type HoshimiTrack, HttpMethods, HttpStatusCodes, type InferCustomStructure, type Inferable, type KaraokeSettings, type LavalinkFilterPluginEchoSettings, type LavalinkFilterPluginReverbSettings, type LavalinkFilterPluginSettings, type LavalinkPayload, type LavalinkPlayOptions, type LavalinkPlayer, type LavalinkPlayerState, type LavalinkPlayerVoice, LavalinkPluginFilter, type LavalinkRestError, type LavalinkSearchResponse, type LavalinkSession, type LavalinkTrack, LoadType, LoopMode, type LowPassSettings, type LyricsFoundEvent, type LyricsLine, type LyricsLineEvent, type LyricsManagerStructure, type LyricsMethods, type LyricsNotFoundEvent, type LyricsResult, ManagerError, MemoryAdapter, Node, type NodeCpu, type NodeDestroyInfo, NodeDestroyReasons, type NodeDisconnectInfo, NodeError, type NodeFrameStats, type NodeIdentifier, type NodeInfo, type NodeInfoGit, type NodeInfoPlugin, type NodeInfoVersion, type NodeJson, type NodeManagerStructure, type NodeMemory, type NodeOptions, NodeSortTypes, type NodeStructure, type NormalizationSettings, type Nullable, type NullableLavalinkSession, type Omit$1 as Omit, OpCodes, OptionError, type PickNullable, type PickRequired, type PlayOptions, Player, PlayerError, type PlayerEvent, PlayerEventType, type PlayerJson, type PlayerOptions, type PlayerStructure, type PlayerUpdate, type PlayerUpdateState, type PlayerVoice, type Playlist, type PlaylistInfo, type PluginFilterSettings, type PluginInfo, PluginInfoType, PluginNames, type QueryResult, Queue, type QueueJson, type QueueStructure, type Ready, ResolveError, Rest, type RestOptions, type RestOrArray, RestPathType, type RestStructure, type ResumableHeaders, type RotationSettings, SearchEngines, type SearchOptions, type SearchQuery, Severity, SourceNames, State, type Stats, StorageAdapter, StorageError, Structures, type TimescaleSettings, Track, type TrackEndEvent, TrackEndReason, type TrackExceptionEvent, type TrackInfo, type TrackRequester, type TrackStartEvent, type TrackStuckEvent, type TremoloSettings, type UnresolvedLavalinkTrack, UnresolvedTrack, type UnresolvedTrackInfo, type UpdatePlayerInfo, type UserAgent, type VoiceChannelUpdate, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent, WebsocketCloseCodes, createHoshimi };
+export { AudioOutput, type Awaitable, type ChannelDelete, type ChannelDeletePacket, type ChannelMixSettings, type ClientData, type CustomizablePlayerStorage, type CustomizableStructures, type CustomizableTrack, DSPXPluginFilter, DebugLevels, type DecodeMethods, type DeepRequired, DestroyReasons, type DistortionSettings, type EQBandSettings, type EchoSettings, type EnabledDSPXPluginFilters, type EnabledLavalinkFilters, type EnabledPlayerFilters, Events, type Exception, type FetchOptions, FilterManager, type FilterManagerStructure, type FilterPluginPassSettings, type FilterSettings, FilterType, type FreqSettings, type GatewayPayload, type GatewaySendPayload, Hoshimi, type HoshimiEvents, type HoshimiNodeOptions, type HoshimiOptions, type HoshimiPlayerOptions, type HoshimiQueueOptions, type HoshimiRestOptions, type HoshimiTrack, HttpMethods, HttpStatusCodes, type InferCustomStructure, type Inferable, type KaraokeSettings, type LavalinkFilterPluginEchoSettings, type LavalinkFilterPluginReverbSettings, type LavalinkFilterPluginSettings, type LavalinkPayload, type LavalinkPlayOptions, type LavalinkPlayer, type LavalinkPlayerState, type LavalinkPlayerVoice, LavalinkPluginFilter, type LavalinkRestError, type LavalinkSearchResponse, type LavalinkSession, type LavalinkTrack, LoadType, LoopMode, type LowPassSettings, type LyricsFoundEvent, type LyricsLine, type LyricsLineEvent, type LyricsManagerStructure, type LyricsMethods, type LyricsNotFoundEvent, type LyricsResult, ManagerError, MemoryAdapter, Node, type NodeCpu, type NodeDestroyInfo, NodeDestroyReasons, type NodeDisconnectInfo, NodeError, type NodeFrameStats, type NodeIdentifier, type NodeInfo, type NodeInfoGit, type NodeInfoPlugin, type NodeInfoVersion, type NodeJson, type NodeManagerStructure, type NodeMemory, type NodeOptions, NodeSortTypes, type NodeStructure, type NormalizationSettings, type Nullable, type NullableLavalinkSession, type Omit$1 as Omit, OpCodes, OptionError, type PickNullable, type PickRequired, type PlayOptions, Player, PlayerError, type PlayerEvent, PlayerEventType, type PlayerJson, type PlayerOptions, type PlayerStructure, type PlayerUpdate, type PlayerUpdateState, type PlayerVoice, type Playlist, type PlaylistInfo, type PluginFilterSettings, type PluginInfo, PluginInfoType, PluginNames, type QueryResult, Queue, type QueueJson, type QueueStructure, type Ready, ResolveError, Rest, type RestOptions, type RestOrArray, RestPathType, type RestStructure, type ResumableHeaders, type RotationSettings, SearchEngines, type SearchOptions, type SearchQuery, Severity, SourceNames, State, type Stats, StorageAdapter, StorageError, Structures, type TimescaleSettings, Track, type TrackEndEvent, TrackEndReason, type TrackExceptionEvent, type TrackInfo, type TrackRequester, type TrackStartEvent, type TrackStuckEvent, type TrackUserData, type TremoloSettings, type UnresolvedLavalinkTrack, UnresolvedTrack, type UnresolvedTrackInfo, type UpdatePlayerInfo, type UserAgent, type VoiceChannelUpdate, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent, WebsocketCloseCodes, createHoshimi };