hoshimi 0.3.3 → 0.3.6

package/dist/index.d.mts

@@ -41,6 +41,14 @@ declare class NodeError extends Error {
 declare class StorageError extends Error {
     constructor(message: string);
 }
+/**
+ * Error class for the node manager.
+ * @class NodeManagerError
+ * @extends {Error}
+ */
+declare class NodeManagerError extends Error {
+    constructor(message: string);
+}
 /**
  * Error class for resolving tracks.
  * @class ResolveError
@@ -648,431 +656,113 @@ interface EnabledDSPXPluginFilters {
 }
 
 /**
- * Class representing a LyricsManager.
- * @class LyricsManager
+ * The methods for http requests
  */
-declare class LyricsManager {
+declare enum HttpMethods {
     /**
-     * The node instance.
-     * @type {NodeStructure}
-     * @readonly
+     * 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}
      */
-    readonly node: NodeStructure;
+    Get = "GET",
     /**
-     * Create a new LyricsManager instance.
-     * @param {NodeStructure} node The node instance.
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * const lyricsManager = new LyricsManager(node);
-     * ```
+     * 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}
      */
-    constructor(node: NodeStructure);
+    Post = "POST",
     /**
-     *
-     * 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();
-     * ```
+     * 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}
      */
-    current(guildId: string, skipSource?: boolean): Promise<LyricsResult | null>;
+    Put = "PUT",
     /**
-     *
-     * 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);
-     * ```
+     * 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}
      */
-    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    Patch = "PATCH",
     /**
-     *
-     * 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");
-     * ```
+     * The DELETE method deletes the specified resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE
+     * @type {string}
      */
-    subscribe(guildId: string, skipSource?: boolean): Promise<void>;
+    Delete = "DELETE",
     /**
-     *
-     * 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");
-     * ```
+     * 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}
      */
-    unsubscribe(guildId: string): Promise<void>;
+    Head = "HEAD"
+}
+declare enum RestPathType {
+    /**
+     * The raw path of the request.
+     * @type {string}
+     */
+    Raw = "/",
+    /**
+     * The versioned path v4 of the request.
+     * @type {string}
+     */
+    V4 = "/v4"
 }
-
 /**
- * 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 status codes for the REST.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
  */
-declare class Collection<K, V> extends Map<K, V> {
+declare enum HttpStatusCodes {
     /**
-     * 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 request has succeeded.
+     * @type {number}
      */
-    sweep(fn: (value: V, key: K, collection: this) => unknown): number;
+    OK = 200,
     /**
-     * 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 request has been fulfilled and resulted in a new resource being created.
+     * @type {number}
      */
-    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    Created = 201,
     /**
-     * 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']
+     * The request has been accepted for processing, but the processing has not been completed.
+     * @type {number}
      */
-    filter(fn: (value: V, key: K, collection: this) => boolean): V[];
+    Accepted = 202,
     /**
-     * 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 server successfully processed the request, but is not returning any content.
+     * @type {number}
      */
-    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
-}
-
-/**
- * Class representing a node manager.
- * @class NodeManager
- */
-declare class NodeManager {
+    NoContent = 204,
     /**
-     * The manager for the node.
-     * @type {Hoshimi}
-     * @readonly
+     * The resource has been moved permanently to a new URI.
+     * @type {number}
      */
-    readonly manager: Hoshimi;
+    MovedPermanently = 301,
     /**
-     * The nodes for the manager.
-     * @type {Collection<string, Node>}
-     * @readonly
+     * The requested resource has been found at a different URI.
+     * @type {number}
      */
-    readonly nodes: Collection<string, NodeStructure>;
+    Found = 302,
     /**
-     *
-     * 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 resource has not been modified since the last request.
+     * @type {number}
      */
-    constructor(manager: Hoshimi);
+    NotModified = 304,
     /**
-     *
-     * 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 request cannot be processed due to bad syntax.
+     * @type {number}
      */
-    delete(node: NodeIdentifier): boolean;
+    BadRequest = 400,
     /**
-     *
-     * 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 request requires user authentication.
+     * @type {number}
      */
-    get(node: NodeIdentifier): NodeStructure | undefined;
+    Unauthorized = 401,
     /**
-     *
-     * 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
+     * The request was valid, but the server is refusing action.
+     * @type {number}
      */
-    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();
-     * ```
-     */
-    disconnect(node: NodeIdentifier): void;
-    /**
-     *
-     * 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();
-     * ```
-     */
-    connect(node: NodeIdentifier): void;
-    /**
-     *
-     * 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
-     * }
-     * ```
-     */
-    getLeastUsed(sortType?: NodeSortTypes): NodeStructure;
-    /**
-     *
-     * Reconnect the nodes.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.reconnectAll();
-     * ```
-     */
-    reconnectAll(): void;
-    /**
-     * Disconnect the nodes.
-     * @returns {void}
-     * @example
-     * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.disconnectAll();
-     * ```
-     */
-    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;
-}
-
-/**
- * The methods for http requests
- */
-declare enum HttpMethods {
-    /**
-     * 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 = "GET",
-    /**
-     * 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}
-     */
-    Post = "POST",
-    /**
-     * 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}
-     */
-    Put = "PUT",
-    /**
-     * 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}
-     */
-    Patch = "PATCH",
-    /**
-     * The DELETE method deletes the specified resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE
-     * @type {string}
-     */
-    Delete = "DELETE",
-    /**
-     * 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}
-     */
-    Head = "HEAD"
-}
-declare enum RestPathType {
-    /**
-     * The raw path of the request.
-     * @type {string}
-     */
-    Raw = "/",
-    /**
-     * The versioned path v4 of the request.
-     * @type {string}
-     */
-    V4 = "/v4"
-}
-/**
- * The status codes for the REST.
- * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
- */
-declare enum HttpStatusCodes {
-    /**
-     * The request has succeeded.
-     * @type {number}
-     */
-    OK = 200,
-    /**
-     * The request has been fulfilled and resulted in a new resource being created.
-     * @type {number}
-     */
-    Created = 201,
-    /**
-     * The request has been accepted for processing, but the processing has not been completed.
-     * @type {number}
-     */
-    Accepted = 202,
-    /**
-     * The server successfully processed the request, but is not returning any content.
-     * @type {number}
-     */
-    NoContent = 204,
-    /**
-     * The resource has been moved permanently to a new URI.
-     * @type {number}
-     */
-    MovedPermanently = 301,
-    /**
-     * The requested resource has been found at a different URI.
-     * @type {number}
-     */
-    Found = 302,
-    /**
-     * The resource has not been modified since the last request.
-     * @type {number}
-     */
-    NotModified = 304,
-    /**
-     * The request cannot be processed due to bad syntax.
-     * @type {number}
-     */
-    BadRequest = 400,
-    /**
-     * The request requires user authentication.
-     * @type {number}
-     */
-    Unauthorized = 401,
-    /**
-     * The request was valid, but the server is refusing action.
-     * @type {number}
-     */
-    Forbidden = 403,
+    Forbidden = 403,
     /**
      * The server cannot find the requested resource.
      * @type {number}
@@ -1129,15 +819,95 @@ declare enum HttpStatusCodes {
      */
     GatewayTimeout = 504
 }
+/**
+ * The REST routes.
+ */
+declare const RestRoutes: {
+    /**
+     *
+     * Get the updated player endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @param {string} guildId The guild id of the player.
+     * @returns {RestEndpoint} The endpoint for updating the player.
+     */
+    UpdatePlayer(sessionId: string, guildId: string): `/sessions/${string}/players/${string}`;
+    /**
+     *
+     * Get the update session endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @returns {RestEndpoint} The endpoint for updating the session.
+     */
+    UpdateSession(sessionId: string): `/sessions/${string}`;
+    /**
+     *
+     * Get the get players endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @returns {RestEndpoint} The endpoint for getting the players.
+     */
+    GetPlayers(sessionId: string): `/sessions/${string}/players`;
+    /**
+     *
+     * Get the current lyrics endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @param {string} guildId The guild id of the player.
+     * @returns {RestEndpoint} The endpoint for getting the current lyrics.
+     */
+    CurrentLyrics(sessionId: string, guildId: string): `/sessions/${string}/players/${string}/track/lyrics`;
+    /**
+     *
+     * Subscribe to lyrics endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @param {string} guildId The guild id of the player.
+     * @returns {RestEndpoint} The endpoint for subscribing to lyrics.
+     */
+    SubscribeLyrics(sessionId: string, guildId: string): `/sessions/${string}/players/${string}/lyrics/subscribe`;
+    /**
+     * Get the lyrics endpoint.
+     * @type {RestEndpoint}
+     */
+    GetLyrics: "/lyrics";
+    /**
+     * Get the decode track endpoint.
+     * @type {RestEndpoint}
+     */
+    DecodeTrack: "/decodetrack";
+    /**
+     * Get the decode tracks endpoint.
+     * @type {RestEndpoint}
+     */
+    DecodeTracks: "/decodetracks";
+    /**
+     * Get the load tracks endpoint.
+     * @type {RestEndpoint}
+     */
+    LoadTracks: "/loadtracks";
+    /**
+     * Get the node info endpoint.
+     * @type {RestEndpoint}
+     */
+    NodeInfo: "/info";
+    /**
+     * Get the load lyrics endpoint.
+     * @type {RestEndpoint}
+     * @description Used in NodelinkLyricsManager, only for nodelink nodes.
+     */
+    LoadLyrics: "/loadlyrics";
+    /**
+     * Get the connection endpoint.
+     * @type {RestEndpoint}
+     * @description Used for checking the connection status of the node, only for nodelink nodes.
+     */
+    Connection: "/connection";
+};
 /**
  * The options for the REST.
  */
 interface RestOptions {
     /**
      * The endpoint for the REST.
-     * @type {string}
+     * @type {RestEndpoint}
      */
-    endpoint: `/${string}`;
+    endpoint: RestEndpoint;
     /**
      * The method for the REST.
      * @type {HttpMethods}
@@ -1357,134 +1127,29 @@ interface DecodeMethods {
      */
     multiple(tracks: string[], requester: TrackRequester): Promise<Track[]>;
 }
+/**
+ * The options for resuming a session.
+ */
+interface SessionResumingOptions {
+    /**
+     * Whether the session is resuming.
+     * @type {boolean}
+     */
+    resuming: boolean;
+    /**
+     * The timeout for resuming the session in milliseconds.
+     * @type {number | null | undefined}
+     */
+    timeout?: number | null;
+}
 /**
  * The session of the node.
  */
 type NullableLavalinkSession = PickNullable<LavalinkSession, "timeout">;
-
 /**
- * Class representing the REST for the node.
- * @class Rest
+ * The REST endpoint type.
  */
-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;
-    /**
-     *
-     * 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
-     * ```
-     */
-    constructor(node: NodeStructure);
-    /**
-     * 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
-     * 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
-     * ```
-     */
-    updatePlayer(data: Partial<UpdatePlayerInfo>): Promise<LavalinkPlayer | null>;
-    /**
-     *
-     * 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
-     * ```
-     */
-    stopPlayer(guildId: string): Promise<LavalinkPlayer | null>;
-    /**
-     *
-     * 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
-     */
-    destroyPlayer(guildId: string): Promise<void>;
-    /**
-     *
-     * 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
-     * ```
-     */
-    updateSession(resuming: boolean, timeout?: number | null): Promise<LavalinkSession | null>;
-}
+type RestEndpoint = `/${string}`;
 
 /**
  * Class representing the DSPX Plugin filters for a player.
@@ -1507,6 +1172,14 @@ declare class DSPXPluginFilter {
      * 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.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the low-pass filter with custom settings
+     * await player.filterManager.dspxPlugin.setLowPass({ cutoffFrequency: 500, boostFactor: 1.5 });
+     * // Disable the low-pass filter
+     * await player.filterManager.dspxPlugin.setLowPass();
+     * ```
      */
     setLowPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
     /**
@@ -1514,6 +1187,14 @@ declare class DSPXPluginFilter {
      * 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.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the high-pass filter with custom settings
+     * await player.filterManager.dspxPlugin.setHighPass({ cutoffFrequency: 2000, boostFactor: 0.8 });
+     * // Disable the high-pass filter
+     * await player.filterManager.dspxPlugin.setHighPass();
+     * ```
      */
     setHighPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
     /**
@@ -1521,6 +1202,14 @@ declare class DSPXPluginFilter {
      * 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.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the normalization filter with custom settings
+     * await player.filterManager.dspxPlugin.setNormalization({ maxAmplitude: 0.9, adaptive: true });
+     * // Disable the normalization filter
+     * await player.filterManager.dspxPlugin.setNormalization();
+     * ```
      */
     setNormalization(settings?: Partial<NormalizationSettings>): Promise<this>;
     /**
@@ -1528,6 +1217,14 @@ declare class DSPXPluginFilter {
      * 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.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the echo filter with custom settings
+     * await player.filterManager.dspxPlugin.setEcho({ echoLength: 500, decay: 0.5, delay: 200 });
+     * // Disable the echo filter
+     * await player.filterManager.dspxPlugin.setEcho();
+     * ```
      */
     setEcho(settings?: Partial<EchoSettings>): Promise<this>;
 }
@@ -1555,6 +1252,14 @@ declare class LavalinkPluginFilter {
      * 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.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the echo filter with custom settings
+     * await player.filterManager.lavalinkPlugin.setEcho({ decay: 0.5, delay: 200 });
+     * // Disable the echo filter
+     * await player.filterManager.lavalinkPlugin.setEcho();
+     * ```
      */
     setEcho(settings?: Partial<NonLengthEchoSettings>): Promise<this>;
     /**
@@ -1562,6 +1267,14 @@ declare class LavalinkPluginFilter {
      * 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.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the reverb filter with custom settings
+     * await player.filterManager.lavalinkPlugin.setReverb({ delays: [50, 100, 150], gains: [0.5, 0.3, 0.2] });
+     * // Disable the reverb filter
+     * await player.filterManager.lavalinkPlugin.setReverb();
+     * ```
      */
     setReverb(settings?: Partial<LavalinkFilterPluginReverbSettings>): Promise<this>;
 }
@@ -1616,18 +1329,33 @@ declare class FilterManager {
     /**
      * Resets all filters to their default values.
      * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
+     * @example
+     * ```ts
+     * // Reset all filters
+     * await player.filterManager.reset();
+     * ```
      */
     reset(): Promise<this>;
     /**
      *
      * Applies the current filters to the player.
      * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
+     * @example
+     * ```ts
+     * // Apply the current filters
+     * await player.filterManager.apply();
+     * ```
      */
     apply(): Promise<this>;
     /**
      * Checks if the current filters are active.
      * @param {TimescaleSettings} timescale The timescale settings to check against.
      * @returns {void} Nothing!
+     * @example
+     * ```ts
+     * // Check the current filters
+     * player.filterManager.check();
+     * ```
      */
     check(timescale?: TimescaleSettings): void;
     /**
@@ -1635,6 +1363,12 @@ declare class FilterManager {
      * 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.
+     * @example
+     * ```ts
+     * // Check if the nightcore filter is active
+     * const isNightcoreActive = player.filterManager.has(FilterType.Nightcore);
+     * console.log(isNightcoreActive); // true or false
+     * ```
      */
     has(filter: FilterType): boolean;
     /**
@@ -1642,12 +1376,24 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the volume is not a number between 0 and 5.
+     * @example
+     * ```ts
+     * // Set the volume to 2.5
+     * await player.filterManager.setVolume(2.5);
+     * ```
      */
     setVolume(volume: number): Promise<this>;
     /**
      * 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.
+     * @throws {PlayerError} If the output is not a valid AudioOutput value.
+     * @example
+     * ```ts
+     * // Set the audio output to mono
+     * await player.filterManager.setAudioOutput(AudioOutput.Mono);
+     * ```
      */
     setAudioOutput(output: AudioOutput): Promise<this>;
     /**
@@ -1655,6 +1401,12 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the timescale filter.
+     * @example
+     * ```ts
+     * // Set the speed to 1.5
+     * await player.filterManager.setSpeed(1.5);
+     * ```
      */
     setSpeed(speed?: number): Promise<this>;
     /**
@@ -1662,6 +1414,12 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the timescale filter.
+     * @example
+     * ```ts
+     * // Set the rate to 1.2
+     * await player.filterManager.setRate(1.2);
+     * ```
      */
     setRate(rate?: number): Promise<this>;
     /**
@@ -1669,6 +1427,12 @@ declare class FilterManager {
      * Sets the pitch for the player.
      * @param {number} pitch The pitch
      * @returns {Promise<this>} A promise that resolves to the player instance.
+     * @throws {PlayerError} If the node does not support the timescale filter.
+     * @example
+     * ```ts
+     * // Set the pitch to 0.8
+     * await player.filterManager.setPitch(0.8);
+     * ```
      */
     setPitch(pitch?: number): Promise<this>;
     /**
@@ -1676,12 +1440,26 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the bands array is empty or contains invalid band settings.
+     * @example
+     * ```ts
+     * // Set multiple EQ bands
+     * await player.filterManager.setEQBand(
+     *   { band: 0, gain: 0.5 },
+     *   { band: 1, gain: -0.3 },
+     * );
+     * ```
      */
     setEQBand(...bands: RestOrArray<EQBandSettings>): Promise<this>;
     /**
      *
      * Clears all EQ bands for the player.
      * @returns {Promise<this>} A promise that resolves to the instance of the manager.
+     * @example
+     * ```ts
+     * // Clear all EQ bands
+     * await player.filterManager.clearEQBands();
+     * ```
      */
     clearEQBands(): Promise<this>;
     /**
@@ -1689,6 +1467,12 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the vibrato filter.
+     * @example
+     * ```ts
+     * // Set the vibrato filter
+     * await player.filterManager.setVibrato({ frequency: 4.0, depth: 0.5 });
+     * ```
      */
     setVibrato(settings?: Partial<TremoloSettings>): Promise<this>;
     /**
@@ -1696,6 +1480,12 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the tremolo filter.
+     * @example
+     * ```ts
+     * // Set the tremolo filter
+     * await player.filterManager.setTremolo({ frequency: 4.0, depth: 0.5 });
+     * ```
      */
     setTremolo(settings?: Partial<TremoloSettings>): Promise<this>;
     /**
@@ -1703,12 +1493,24 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the low-pass filter.
+     * @example
+     * ```ts
+     * // Set the low-pass filter
+     * await player.filterManager.setLowPass({ smoothing: 20.0 });
+     * ```
      */
     setLowPass(settings?: Partial<LowPassSettings>): Promise<this>;
     /**
      * 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.
+     * @throws {PlayerError} If the node does not support the timescale filter.
+     * @example
+     * ```ts
+     * // Set the nightcore filter
+     * await player.filterManager.setNightcore();
+     * ```
      */
     setNightcore(settings?: Partial<TimescaleSettings>): Promise<this>;
     /**
@@ -1716,6 +1518,12 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the timescale filter.
+     * @example
+     * ```ts
+     * // Set the vaporwave filter
+     * await player.filterManager.setVaporwave();
+     * ```
      */
     setVaporwave(settings?: Partial<TimescaleSettings>): Promise<this>;
     /**
@@ -1723,6 +1531,12 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the karaoke filter.
+     * @example
+     * ```ts
+     * // Set the karaoke filter
+     * await player.filterManager.setKaraoke({ level: -15.0, monoLevel: -20.0, filterBand: 220.0, filterWidth: 100.0 });
+     * ```
      */
     setKaraoke(settings?: Partial<KaraokeSettings>): Promise<this>;
     /**
@@ -1730,91 +1544,43 @@ declare class FilterManager {
      * 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.
+     * @throws {PlayerError} If the node does not support the distortion filter.
+     * @example
+     * ```ts
+     * // Set the distortion filter
+     * await player.filterManager.setDistortion({ sinOffset: 0.5, sinScale: 2.0 });
+     * ```
      */
     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.
+     * @throws {PlayerError} If the node does not support the timescale filter.
+     * @example
+     * ```ts
+     * // Set the timescale filter
+     * await player.filterManager.setTimescale({ speed: 1.2, pitch: 0.8, rate: 1.0 });
+     * ```
      */
     setTimescale(settings: Partial<TimescaleSettings>): Promise<this>;
     /**
      * Convert the filter settings to a JSON object.
      * @returns {FilterSettings} The filter settings as a JSON object.
+     * @example
+     * ```ts
+     * // Convert filter settings to JSON
+     * const filterSettingsJSON = player.filterManager.toJSON();
+     * console.log(filterSettingsJSON); // { volume: 1, equalizer: [...], ... }
+     * ```
      */
     toJSON(): FilterSettings;
 }
 
 /**
- * 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
+ * Type representing a nullable voice channel update.
  */
-declare class PlayerStorage<K extends StorageKeys = StorageKeys, V extends StorageValues<K> = StorageValues<K>> {
-    /**
-     *
-     * 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.
-     */
-    get<K extends StorageKeys, V extends StorageValues<K>>(key: K): V | undefined;
-    /**
-     * 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.
-     */
-    set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): void;
-    /**
-     * 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.
-     */
-    has(key: K): boolean;
-    /**
-     * Delete a key from the storage.
-     * @param {K} key The key to delete.
-     * @returns {boolean} True if the key was deleted, false otherwise.
-     */
-    delete(key: K): boolean;
-    /**
-     * 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.
-     */
-    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;
-}
-
+type NullableVoiceChannelUpdate = Partial<Nullable<VoiceChannelUpdate>>;
 /**
  * Class representing a Hoshimi player.
  * @class Player
@@ -1822,10 +1588,10 @@ declare class PlayerStorage<K extends StorageKeys = StorageKeys, V extends Stora
 declare class Player {
     /**
      * The data for the player.
-     * @type {PlayerStorage}
+     * @type {PlayerStorageAdapter}
      * @readonly
      */
-    readonly data: PlayerStorage;
+    readonly data: PlayerStorageAdapter;
     /**
      * The options for the player.
      * @type {PlayerOptions}
@@ -1968,6 +1734,12 @@ declare class Player {
      * @readonly
      */
     readonly lyrics: LyricsMethods;
+    /**
+     *
+     * Check if the player is currently playing a track.
+     * @returns {boolean} Whether the player is currently playing a track.
+     */
+    isPlaying(): boolean;
     /**
      *
      * Search for a track or playlist.
@@ -2113,7 +1885,7 @@ declare class Player {
     setLoop(mode: LoopMode): this;
     /**
      * Set the voice of the player.
-     * @param {Partial<VoiceChannelUpdate>} voice The voice state to set.
+     * @param {NullableVoiceChannelUpdate} options The voice state to set.
      * @returns {Promise<void>}
      * @example
      * ```ts
@@ -2121,7 +1893,7 @@ declare class Player {
      * player.setVoice({ voiceId: "newVoiceId" });
      * ```
      */
-    setVoice(voice: Partial<VoiceChannelUpdate>): Promise<void>;
+    setVoice(options?: NullableVoiceChannelUpdate): Promise<void>;
     /**
      *
      * Change the node the player is connected to.
@@ -2139,6 +1911,12 @@ declare class Player {
      * Update the player with new data.
      * @param {NonGuildUpdatePlayerInfo} data The data to update the player with.
      * @returns {Promise<LavalinkPlayer | null>} The updated player data.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * const updatedPlayer = await player.updatePlayer({ volume: 50 });
+     * console.log(updatedPlayer); // the updated player data
+     * ```
      */
     updatePlayer(data: NonGuildUpdatePlayerInfo): Promise<LavalinkPlayer | null>;
     /**
@@ -2165,25 +1943,188 @@ interface CustomizablePlayerStorage {
 }
 
 /**
- * Class representing a storage manager.
+ * 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 adapter.
  * @abstract
- * @class StorageManager
+ * @class PlayerStorageAdapter
  * @example
  * ```ts
- * class MyStorageManager extends StorageManager {};
+ * class MyPlayerStorageAdapter extends PlayerStorageAdapter {};
  *
- * const storage = new MyStorageManager();
- * storage.set("key", "value");
+ * const storage = new MyPlayerStorageAdapter();
+ * await storage.set("key", "value");
  *
  * const value = await storage.get("key");
  * console.log(value); // "value"
  * ```
  */
-declare abstract class StorageAdapter<T extends QueueJson = QueueJson> {
+declare abstract class PlayerStorageAdapter {
     /**
-     *
-     * Get the value using the key.
-     * @param {string} key The key to get the value from.
+     * The namespace of the storage.
+     * @type {string}
+     * @default "hoshimiplayer"
+     * @example
+     * ```ts
+     * console.log(storage.namespace); // "hoshimiplayer"
+     * ```
+     */
+    namespace: string;
+    /**
+     *
+     * 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"
+     * ```
+     */
+    abstract get<K extends StorageKeys, V extends StorageValues<K>>(key: K): Awaitable<V | undefined>;
+    /**
+     *
+     * 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
+     * await storage.set("key", "value");
+     * ```
+     */
+    abstract set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): Awaitable<void>;
+    /**
+     *
+     * 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 success = await storage.delete("key");
+     * console.log(success); // true
+     * ```
+     */
+    abstract delete<K extends StorageKeys>(key: K): Awaitable<boolean>;
+    /**
+     * Clear the storage.
+     * @returns {Awaitable<void>} Scary, right?
+     * @example
+     * ```ts
+     * await storage.clear();
+     * ```
+     */
+    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<K extends StorageKeys>(key: K): Awaitable<boolean>;
+    /**
+     * Get all keys in the storage.
+     * @returns {Awaitable<K[]>} The keys in the storage.
+     * @example
+     * ```ts
+     * const keys = await storage.keys();
+     * console.log(keys); // ["key1", "key2"]
+     * ```
+     */
+    abstract keys<K extends StorageKeys[]>(): Awaitable<K[]>;
+    /**
+     * Get all values in the storage.
+     * @returns {Awaitable<V[]>} The values in the storage.
+     * @example
+     * ```ts
+     * const values = await storage.values();
+     * console.log(values); // ["value1", "value2"]
+     * ```
+     */
+    abstract values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<V[]>;
+    /**
+     * Get all entries in the storage.
+     * @returns {Awaitable<[K, V][]>} The entries in the storage.
+     * @example
+     * ```ts
+     * const entries = await storage.entries();
+     * console.log(entries); // [["key1", "value1"], ["key2", "value2"]]
+     * ```
+     */
+    abstract entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<[K, V][]>;
+    /**
+     * Get all key-value pairs in the storage.
+     * @returns {Awaitable<Record<K[number], V>>} An object containing all key-value pairs in the storage, excluding internal keys.
+     * @example
+     * ```ts
+     * const all = await storage.all();
+     * console.log(all); // { key1: "value1", key2: "value2" }
+     * ```
+     */
+    abstract all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<Record<K[number], V>>;
+    /**
+     * Get the size of the storage.
+     * @returns {Awaitable<number>} The size of the storage.
+     * @example
+     * ```ts
+     * const size = await storage.size();
+     * console.log(size); // 2
+     * ```
+     */
+    abstract size(): Awaitable<number>;
+    /**
+     *
+     * Build a key from the given parts.
+     * @param {string[]} parts The parts to build the key from.
+     * @returns {string} The built key.
+     * @example
+     * ```ts
+     * const key = storage.buildKey("part1", "part2", "part3");
+     * ```
+     */
+    abstract buildKey(...parts: RestOrArray<string>): string;
+}
+
+/**
+ * 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 abstract class QueueStorageAdapter<T extends QueueJson = QueueJson> {
+    /**
+     * The namespace of the storage.
+     * @type {string}
+     * @default "hoshimiqueue"
+     * @example
+     * ```ts
+     * console.log(storage.namespace); // "hoshimiqueue"
+     * ```
+     */
+    namespace: string;
+    /**
+     *
+     * 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
@@ -2260,6 +2201,17 @@ declare abstract class StorageAdapter<T extends QueueJson = QueueJson> {
      * ```
      */
     abstract stringify<R = string>(value: unknown): Awaitable<R>;
+    /**
+     *
+     * Build a key from the given parts.
+     * @param {string[]} parts The parts to build the key from.
+     * @returns {string} The built key.
+     * @example
+     * ```ts
+     * const key = storage.buildKey("part1", "part2", "part3");
+     * ```
+     */
+    abstract buildKey(...parts: RestOrArray<string>): string;
 }
 
 /**
@@ -2271,7 +2223,7 @@ interface HoshimiQueueOptions {
      * @type {number}
      * @default 25
      */
-    maxPreviousTracks?: number;
+    maxHistory?: number;
     /**
      *
      * The function to use for autoplay.
@@ -2287,10 +2239,10 @@ interface HoshimiQueueOptions {
     autoPlay?: boolean;
     /**
      * The storage manager to use for the queue.
-     * @type {StorageAdapter}
+     * @type {QueueStorageAdapter}
      * @default {MemoryAdapter}
      */
-    storage?: StorageAdapter;
+    storage?: QueueStorageAdapter;
 }
 /**
  * The queue json.
@@ -2314,613 +2266,206 @@ interface QueueJson {
 }
 
 /**
- * Class representing the queue utils.
- * @class QueueUtils
+ * Partial Lavalink track type.
  */
-declare class QueueUtils {
+type PartialLavalinkTrack = Partial<Nullable<LavalinkTrack>>;
+/**
+ * The base options for playing a track.
+ */
+interface BasePlayOptions {
     /**
-     *
-     * Constructor of the queue utils.
-     * @param {QueueStructure} queue The queue instance.
+     * The position to start the track.
+     * @type {number | undefined}
      */
-    constructor(queue: QueueStructure);
+    position?: number;
     /**
-     *
-     * Save the queue.
-     * @returns {Awaitable<void>}
-     * @example
-     * ```ts
-     * await player.queue.utils.save();
-     * ```
+     * The position to end the track.
+     * @type {number | undefined}
      */
-    save(): Awaitable<void>;
+    endTime?: number;
     /**
-     *
-     * Destroy the queue.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * await player.queue.utils.destroy();
-     * ```
+     * The pause state of the player.
+     * @type {boolean | undefined}
      */
-    destroy(): Awaitable<boolean>;
+    paused?: boolean;
     /**
-     *
-     * Sync the queue.
-     * @returns {Awaitable<void>}
-     * @example
-     * ```ts
-     * await player.queue.utils.sync();
-     * ```
+     * The volume of the player.
+     * @type {number | undefined}
      */
-    sync(override?: boolean, syncCurrent?: boolean): Promise<void>;
+    volume?: number;
+    /**
+     * The filters for the player.
+     * @type {Partial<FilterSettings> | undefined}
+     */
+    filters?: Partial<FilterSettings>;
+    /**
+     * The voice settings for the player.
+     * @type {LavalinkPlayerVoice | undefined}
+     */
+    voice?: LavalinkPlayerVoice;
 }
-
 /**
- * Class representing a queue.
- * @class Queue
+ * The types of loop modes.
  */
-declare class Queue {
+declare enum LoopMode {
     /**
-     * Tracks of the queue.
-     * @type {HoshimiTrack[]}
+     * Loop mode for repeating the current track.
      */
-    tracks: HoshimiTrack[];
+    Track = 1,
     /**
-     * Previous tracks of the queue.
-     * @type {Track[]}
+     * Loop mode for repeating the queue.
      */
-    history: Track[];
+    Queue = 2,
     /**
-     * Current track of the queue.
-     * @type {Track | null}
+     * Loop mode for repeating nothing.
      */
-    current: Track | null;
+    Off = 3
+}
+/**
+ * The types of player events.
+ */
+declare enum PlayerEventType {
     /**
-     * The player instance.
-     * @type {PlayerStructure}
+     * Event type for when a track starts.
      */
-    readonly player: PlayerStructure;
+    TrackStart = "TrackStartEvent",
     /**
-     * The queue utils instance.
-     * @type {QueueUtils}
-     * @readonly
+     * Event type for when a track ends.
      */
-    readonly utils: QueueUtils;
+    TrackEnd = "TrackEndEvent",
     /**
-     *
-     * 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
-     * ```
+     * Event type for when a track encounters an exception.
      */
-    constructor(player: PlayerStructure);
+    TrackException = "TrackExceptionEvent",
     /**
-     * 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
-     * ```
+     * Event type for when a track gets stuck.
      */
-    get size(): number;
+    TrackStuck = "TrackStuckEvent",
     /**
-     * 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
-     * ```
+     * Event type for when lyrics are found.
      */
-    get totalSize(): number;
+    LyricsFound = "LyricsFoundEvent",
     /**
-     *
-     * 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
-     * ```
+     * Event type for when lyrics are not found.
      */
-    isEmpty(): boolean;
+    LyricsNotFound = "LyricsNotFoundEvent",
     /**
-     *
-     * 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
-     * ```
+     * Event type for when a lyrics line is sent.
      */
-    previous(remove?: boolean): Track | null;
+    LyricsLine = "LyricsLineEvent",
     /**
-     *
-     * 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]
-     * ```
+     * Event type for when the WebSocket connection is closed.
      */
-    add(track: HoshimiTrack | HoshimiTrack[], position?: number): this;
+    WebsocketClosed = "WebSocketClosedEvent"
+}
+/**
+ * The reasons a track can end.
+ */
+declare enum TrackEndReason {
     /**
-     *
-     * 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);
-     * ```
+     * The track ended normally.
      */
-    shift(): HoshimiTrack | null;
+    Finished = "finished",
     /**
-     *
-     * 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]
-     * ```
+     * The track fails to load.
      */
-    unshift(...tracks: Track[]): this;
+    LoadFailed = "loadFailed",
     /**
-     *
-     * 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]
-     * ```
+     * The track was stopped.
      */
-    shuffle(): this;
+    Stopped = "stopped",
     /**
-     *
-     * 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]);
-     *
-     * console.log(queue.size); // 3
-     * queue.clear();
-     * console.log(queue.size); // 0
-     * ```
+     * The track was replaced.
      */
-    clear(): this;
+    Replaced = "replaced",
     /**
-     *
-     * 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.
+     * The track was cleaned up.
      */
-    move(track: Track, to: number): this;
+    Cleanup = "cleanup"
+}
+/**
+ * The options for automatic player error handling.
+ */
+interface ErrorPlayerActions {
     /**
-     *
-     * 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.
+     * Whether to automatically destroy the player on disconnect or error.
+     * @type {boolean | undefined}
+     * @default false
      */
-    splice(start: number, deleteCount: number, tracks?: HoshimiTrack | HoshimiTrack[]): this;
+    autoDestroy?: boolean;
     /**
-     *
-     * Convert the queue to a JSON object.
-     * @returns {QueueJson} The queue JSON object.
+     * Whether to automatically skip the track on error
+     * @type {boolean | undefined}
+     * @default false
      */
-    toJSON(): QueueJson;
+    autoSkip?: boolean;
+    /**
+     * Whether to automatically stop the player on error.
+     * @type {boolean | undefined}
+     * @default false
+     */
+    autoStop?: boolean;
 }
-
-/**
- * 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.
+ * The options for error actions.
  */
-type InferCustomStructure<T, N extends string> = CustomizableStructures extends Record<N, infer P> ? P : T;
-
+interface DisconnectPlayerActions extends Pick<ErrorPlayerActions, "autoDestroy"> {
+    /**
+     * Whether to automatically reconnect on disconnect.
+     * @type {boolean | undefined}
+     * @default false
+     */
+    autoReconnect?: boolean;
+    /**
+     * Whether to automatically add tracks back to the queue on disconnect.
+     * @type {boolean | undefined}
+     * @default false
+     */
+    autoQueue?: boolean;
+}
 /**
- * Class representing a Hoshimi track.
- * @class Track
- * @implements {LavalinkTrack}
+ * The Hoshimi player options.
  */
-declare class Track implements LavalinkTrack {
+interface HoshimiPlayerOptions {
     /**
-     * The base64 encoded track.
-     * @type {string}
+     *
+     * The function to use to get the requester data.
+     * @param {TrackRequester} requester The requester of the track.
      */
-    readonly encoded: string;
+    requesterFn?<T extends TrackRequester = TrackRequester>(requester: TrackRequester): Awaitable<T>;
     /**
-     * The track info.
-     * @type {TrackInfo}
+     * The options for handling errors.
+     * @type {ErrorPlayerActions | undefined}
      */
-    readonly info: TrackInfo;
+    onError?: ErrorPlayerActions;
     /**
-     * The plugin info of the track.
-     * @type {PluginInfo}
+     * The options for handling disconnects.
+     * @type {DisconnectPlayerActions | undefined}
      */
-    readonly pluginInfo: PluginInfo;
+    onDisconnect?: DisconnectPlayerActions;
     /**
-     * The track user data.
-     * @type {Record<string, unknown>}
+     * The customizable player storage adapter.
+     * @type {PlayerStorageAdapter | undefined}
+     * @default {PlayerMemoryStorage}
      */
-    userData: Record<string, unknown>;
+    storage?: PlayerStorageAdapter;
+}
+/**
+ * The base interface for player events.
+ */
+interface PlayerEvent<E extends PlayerEventType> {
     /**
-     * The requester of the track.
-     * @type {TrackRequester}
+     * The type of the event.
+     * @type {E}
      */
-    requester: TrackRequester;
-    /**
-     * 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
-     * ```
-     */
-    constructor(track: LavalinkTrack | null, requester?: TrackRequester);
-    /**
-     *
-     * 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>)
-     * ```
-     */
-    toHyperlink(embedable?: boolean): string;
-}
-/**
- * Class representing an unresolved track.
- * @class UnresolvedTrack
- * @implements {UnresolvedLavalinkTrack}
- */
-declare class UnresolvedTrack implements UnresolvedLavalinkTrack {
-    /**
-     * The base64 encoded track.
-     * @type {string | undefined}
-     */
-    readonly encoded?: string;
-    /**
-     * The track info.
-     * @type {UnresolvedTrackInfo}
-     */
-    readonly info: UnresolvedTrackInfo;
-    /**
-     * The plugin info of the track.
-     * @type {Partial<PluginInfo>}
-     */
-    readonly pluginInfo?: Partial<PluginInfo>;
-    /**
-     * The track user data.
-     * @type {Record<string, unknown> | undefined}
-     */
-    userData?: Record<string, unknown>;
-    /**
-     * The requester of the track.
-     * @type {TrackRequester | undefined}
-     */
-    requester: TrackRequester;
-    /**
-     * 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
-     * ```
-     */
-    constructor(track: UnresolvedLavalinkTrack, requester: TrackRequester);
-    /**
-     * 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.
-     */
-    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 {
-}
-/**
- * The requester of the track.
- */
-type TrackRequester = Inferable<CustomizableTrack, "requester">;
-
-/**
- * Partial Lavalink track type.
- */
-type PartialLavalinkTrack = Partial<Nullable<LavalinkTrack>>;
-/**
- * The base options for playing a track.
- */
-interface BasePlayOptions {
-    /**
-     * The position to start the track.
-     * @type {number | undefined}
-     */
-    position?: number;
-    /**
-     * The position to end the track.
-     * @type {number | undefined}
-     */
-    endTime?: number;
-    /**
-     * The pause state of the player.
-     * @type {boolean | undefined}
-     */
-    paused?: boolean;
-    /**
-     * The volume of the player.
-     * @type {number | undefined}
-     */
-    volume?: number;
-    /**
-     * The filters for the player.
-     * @type {Partial<FilterSettings> | undefined}
-     */
-    filters?: Partial<FilterSettings>;
-    /**
-     * The voice settings for the player.
-     * @type {LavalinkPlayerVoice | undefined}
-     */
-    voice?: LavalinkPlayerVoice;
-}
-/**
- * The types of loop modes.
- */
-declare enum LoopMode {
-    /**
-     * Loop mode for repeating the current track.
-     */
-    Track = 1,
-    /**
-     * Loop mode for repeating the queue.
-     */
-    Queue = 2,
-    /**
-     * Loop mode for repeating nothing.
-     */
-    Off = 3
-}
-/**
- * The types of player events.
- */
-declare enum PlayerEventType {
-    /**
-     * Event type for when a track starts.
-     */
-    TrackStart = "TrackStartEvent",
-    /**
-     * Event type for when a track ends.
-     */
-    TrackEnd = "TrackEndEvent",
-    /**
-     * Event type for when a track encounters an exception.
-     */
-    TrackException = "TrackExceptionEvent",
-    /**
-     * Event type for when a track gets stuck.
-     */
-    TrackStuck = "TrackStuckEvent",
-    /**
-     * Event type for when lyrics are found.
-     */
-    LyricsFound = "LyricsFoundEvent",
-    /**
-     * Event type for when lyrics are not found.
-     */
-    LyricsNotFound = "LyricsNotFoundEvent",
-    /**
-     * Event type for when a lyrics line is sent.
-     */
-    LyricsLine = "LyricsLineEvent",
-    /**
-     * Event type for when the WebSocket connection is closed.
-     */
-    WebsocketClosed = "WebSocketClosedEvent"
-}
-/**
- * The reasons a track can end.
- */
-declare enum TrackEndReason {
-    /**
-     * The track ended normally.
-     */
-    Finished = "finished",
-    /**
-     * The track fails to load.
-     */
-    LoadFailed = "loadFailed",
-    /**
-     * The track was stopped.
-     */
-    Stopped = "stopped",
-    /**
-     * The track was replaced.
-     */
-    Replaced = "replaced",
-    /**
-     * The track was cleaned up.
-     */
-    Cleanup = "cleanup"
-}
-/**
- * The base interface for player events.
- */
-interface PlayerEvent {
+    type: E;
     /**
      * The operation code for the event.
      * @type {OpCodes.Event}
      */
     op: OpCodes.Event;
     /**
-     * The guild ID associated with the event.
+     * The guild id associated with the event.
      * @type {string}
      */
     guildId: string;
@@ -2928,12 +2473,7 @@ interface PlayerEvent {
 /**
  * The event for when a track starts playing.
  */
-interface TrackStartEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackStart}
-     */
-    type: PlayerEventType.TrackStart;
+interface TrackStartEvent extends PlayerEvent<PlayerEventType.TrackStart> {
     /**
      * The track that started playing.
      * @type {LavalinkTrack}
@@ -2943,12 +2483,7 @@ interface TrackStartEvent extends PlayerEvent {
 /**
  * The event for when a track ends.
  */
-interface TrackEndEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackEnd}
-     */
-    type: PlayerEventType.TrackEnd;
+interface TrackEndEvent extends PlayerEvent<PlayerEventType.TrackEnd> {
     /**
      * The track that ended.
      * @type {LavalinkTrack}
@@ -2963,12 +2498,7 @@ interface TrackEndEvent extends PlayerEvent {
 /**
  * The event for when a track gets stuck.
  */
-interface TrackStuckEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackStuck}
-     */
-    type: PlayerEventType.TrackStuck;
+interface TrackStuckEvent extends PlayerEvent<PlayerEventType.TrackStuck> {
     /**
      * The track that got stuck.
      * @type {LavalinkTrack}
@@ -2983,12 +2513,7 @@ interface TrackStuckEvent extends PlayerEvent {
 /**
  * The event for when a track encounters an exception.
  */
-interface TrackExceptionEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackException}
-     */
-    type: PlayerEventType.TrackException;
+interface TrackExceptionEvent extends PlayerEvent<PlayerEventType.TrackException> {
     /**
      * The exception that occurred.
      * @type {Exception}
@@ -2998,12 +2523,7 @@ interface TrackExceptionEvent extends PlayerEvent {
 /**
  * The event for when the WebSocket connection is closed.
  */
-interface WebSocketClosedEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.WebsocketClosed}
-     */
-    type: PlayerEventType.WebsocketClosed;
+interface WebSocketClosedEvent extends PlayerEvent<PlayerEventType.WebsocketClosed> {
     /**
      * The close code.
      * @type {number}
@@ -3023,12 +2543,7 @@ interface WebSocketClosedEvent extends PlayerEvent {
 /**
  * The event for when lyrics are found.
  */
-interface LyricsFoundEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsFound}
-     */
-    type: PlayerEventType.LyricsFound;
+interface LyricsFoundEvent extends PlayerEvent<PlayerEventType.LyricsFound> {
     /**
      * The guild id associated with the event.
      * @type {string}
@@ -3043,27 +2558,12 @@ interface LyricsFoundEvent extends PlayerEvent {
 /**
  * The event for when lyrics are not found.
  */
-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;
+interface LyricsNotFoundEvent extends PlayerEvent<PlayerEventType.LyricsNotFound> {
 }
 /**
  * The event for when a lyrics line is sent.
  */
-interface LyricsLineEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsLine}
-     */
-    type: PlayerEventType.LyricsLine;
+interface LyricsLineEvent extends PlayerEvent<PlayerEventType.LyricsLine> {
     /**
      * The guild id associated with the event.
      * @type {string}
@@ -3226,165 +2726,1147 @@ interface PlayerVoice {
 /**
  * The JSON representation of the player.
  */
-interface PlayerJson {
+interface PlayerJson {
+    /**
+     * The guild id of the player.
+     * @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;
+    /**
+     * The voice settings for the player.
+     * @type {LavalinkPlayerVoice}
+     */
+    voice: Nullable<LavalinkPlayerVoice>;
+    /**
+     * The loop mode of the player.
+     * @type {LoopMode}
+     */
+    loop: LoopMode;
+    /**
+     * The options for the player.
+     * @type {boolean}
+     */
+    options: PlayerOptions;
+    /**
+     * The paused state of the player.
+     * @type {boolean}
+     */
+    paused: boolean;
+    /**
+     * The playing state of the player.
+     * @type {boolean}
+     */
+    playing: boolean;
+    /**
+     * The voice channel id of the player.
+     * @type {string}
+     */
+    voiceId?: string;
+    /**
+     * The text channel id of the player.
+     * @type {string | undefined}
+     */
+    textId?: string;
+    /**
+     * The last position received from Lavalink.
+     * @type {number}
+     */
+    lastPosition: number;
+    /**
+     * The timestamp when the last position change update happened.
+     * @type {number | null}
+     */
+    lastPositionUpdate: number | null;
+    /**
+     * The current calculated position of the player.
+     * @type {number}
+     */
+    position: number;
+    /**
+     * The timestamp when the player was created.
+     * @type {number}
+     */
+    createdTimestamp: number;
+    /**
+     * The ping of the player.
+     * @type {number}
+     */
+    ping: number;
+    /**
+     * The queue of the player.
+     * @type {QueueJson}
+     */
+    queue: QueueJson;
+    /**
+     * The node of the player.
+     * @type {NodeJson}
+     */
+    node: NodeJson;
+    /**
+     * The filter settings of the player.
+     * @type {FilterSettings}
+     */
+    filters: FilterSettings;
+}
+/**
+ * The lyrics methods for the player.
+ */
+interface LyricsMethods {
+    /**
+     *
+     * 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.lyrics.current();
+     * ```
+     */
+    current(skipSource?: boolean): Promise<LyricsResult | null>;
+    /**
+     *
+     * 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);
+     * ```
+     */
+    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    /**
+     *
+     * 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();
+     * ```
+     */
+    subscribe(skipSource?: boolean): Promise<void>;
+    /**
+     *
+     * 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();
+     * ```
+     */
+    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 node instance.
+     * @type {NodeStructure}
+     * @readonly
+     */
+    readonly node: NodeStructure;
+    /**
+     * Create a new LyricsManager instance.
+     * @param {NodeStructure} node The node instance.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("nodeId");
+     * const lyricsManager = new LyricsManager(node);
+     * ```
+     */
+    constructor(node: NodeStructure);
+    /**
+     *
+     * 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();
+     * ```
+     */
+    current(guildId: string, skipSource?: boolean): Promise<LyricsResult | null>;
+    /**
+     *
+     * 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);
+     * ```
+     */
+    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    /**
+     *
+     * 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");
+     * ```
+     */
+    subscribe(guildId: string, skipSource?: boolean): Promise<void>;
+    /**
+     *
+     * 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");
+     * ```
+     */
+    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> {
+    /**
+     * 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
+     */
+    sweep(fn: (value: V, key: K, collection: this) => unknown): 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']
+     */
+    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    /**
+     * 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']
+     */
+    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>;
+    /**
+     *
+     * 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
+     * ```
+     */
+    constructor(manager: Hoshimi);
+    /**
+     *
+     * 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
+     * ```
+     */
+    delete(node: NodeIdentifier): boolean;
+    /**
+     *
+     * 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");
+     * }
+     * ```
+     */
+    get(node: NodeIdentifier): NodeStructure | undefined;
+    /**
+     *
+     * 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();
+     * ```
+     */
+    disconnect(node: NodeIdentifier): void;
+    /**
+     *
+     * 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();
+     * ```
+     */
+    connect(node: NodeIdentifier): void;
+    /**
+     *
+     * 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
+     * }
+     * ```
+     */
+    getLeastUsed(sortType?: NodeSortTypes): NodeStructure;
+    /**
+     *
+     * Reconnect the nodes.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.reconnectAll();
+     * ```
+     */
+    reconnectAll(): void;
+    /**
+     * Disconnect the nodes.
+     * @returns {void}
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.disconnectAll();
+     * ```
+     */
+    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;
+}
+
+/**
+ * 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;
+    /**
+     *
+     * 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
+     * ```
+     */
+    constructor(node: NodeStructure);
+    /**
+     * 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
+     * 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
+     * ```
+     */
+    updatePlayer(data: Partial<UpdatePlayerInfo>): Promise<LavalinkPlayer | null>;
+    /**
+     *
+     * 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
+     * ```
+     */
+    stopPlayer(guildId: string): Promise<LavalinkPlayer | null>;
+    /**
+     *
+     * 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
+     */
+    destroyPlayer(guildId: string): Promise<void>;
+    /**
+     *
+     * Update the session for the node
+     * @param {SessionResumingOptions} options The session resuming options.
+     * @returns {Promise<LavalinkSession | null>} The updated session data.
+     * @example
+     * ```ts
+     * const session = await node.rest.updateSession({ resuming: true, timeout: 30000 });
+     * if (session) console.log(session); // The lavalink session data
+     * ```
+     */
+    updateSession(options: SessionResumingOptions): Promise<LavalinkSession | null>;
+    /**
+     *
+     * Get all players for the current session.
+     * @returns {Promise<LavalinkPlayer[]>} The players for the current session.
+     * @example
+     * ```ts
+     * const players = await node.rest.getPlayers();
+     * console.log(players); // The lavalink players for the current session
+     * ```
+     */
+    getPlayers(): Promise<LavalinkPlayer[]>;
+}
+
+/**
+ * Class representing the queue utils.
+ * @class QueueUtils
+ */
+declare class QueueUtils {
+    /**
+     *
+     * Constructor of the queue utils.
+     * @param {QueueStructure} queue The queue instance.
+     */
+    constructor(queue: QueueStructure);
+    /**
+     *
+     * Save the queue.
+     * @returns {Awaitable<void>}
+     * @example
+     * ```ts
+     * await player.queue.utils.save();
+     * ```
+     */
+    save(): Awaitable<void>;
+    /**
+     *
+     * Destroy the queue.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * await player.queue.utils.destroy();
+     * ```
+     */
+    destroy(): Awaitable<boolean>;
+    /**
+     *
+     * Sync the queue.
+     * @param {boolean} [override=true] Whether to override the current queue or not.
+     * @param {boolean} [syncCurrent=false] Whether to sync the current track or not.
+     * @returns {Awaitable<void>}
+     * @example
+     * ```ts
+     * await player.queue.utils.sync();
+     * ```
+     */
+    sync(override?: boolean, syncCurrent?: boolean): Promise<void>;
+}
+
+/**
+ * Class representing a queue.
+ * @class Queue
+ */
+declare class Queue {
+    /**
+     * Tracks of the queue.
+     * @type {HoshimiTrack[]}
+     */
+    tracks: HoshimiTrack[];
+    /**
+     * Previous tracks of the queue.
+     * @type {Track[]}
+     */
+    history: Track[];
+    /**
+     * Current track of the queue.
+     * @type {Track | null}
+     */
+    current: Track | null;
+    /**
+     * The player instance.
+     * @type {PlayerStructure}
+     */
+    readonly player: PlayerStructure;
+    /**
+     * The queue utils instance.
+     * @type {QueueUtils}
+     * @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);
+    /**
+     * 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
+     * ```
+     */
+    get size(): number;
+    /**
+     * 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
+     * ```
+     */
+    get totalSize(): number;
+    /**
+     *
+     * 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
+     * ```
+     */
+    isEmpty(): boolean;
+    /**
+     *
+     * 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
+     * ```
+     */
+    build(track: LavalinkTrack | UnresolvedLavalinkTrack | HoshimiTrack, requester: TrackRequester): Promise<Track>;
+    /**
+     *
+     * 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
+     * ```
+     */
+    previous(remove?: boolean): Promise<Track | null>;
+    /**
+     *
+     * 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]
+     * ```
+     */
+    add(track: HoshimiTrack | HoshimiTrack[], position?: number): Promise<this>;
+    /**
+     *
+     * 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);
+     * ```
+     */
+    shift(): Promise<HoshimiTrack | null>;
+    /**
+     *
+     * 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]
+     * ```
+     */
+    unshift(...tracks: Track[]): Promise<this>;
+    /**
+     *
+     * 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]
+     * ```
+     */
+    shuffle(): Promise<this>;
+    /**
+     *
+     * 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
+     * ```
+     */
+    clear(): 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 {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     * await queue.add(track);
+     * await queue.add(track1);
+     * await queue.add(track2);
+     *
+     * console.log(queue.tracks); // [track, track1, track2]
+     * await queue.move(track1, 0);
+     * console.log(queue.tracks); // [track1, track, track2]
+     * ```
+     */
+    move(track: Track, to: 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 {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     * await queue.add(track);
+     * await queue.add(track1);
+     * await queue.add(track2);
+     *
+     * console.log(queue.tracks); // [track, track1, track2]
+     * await queue.splice(1, 1);
+     * console.log(queue.tracks); // [track, track2]
+     * ```
+     */
+    splice(start: number, deleteCount: number, tracks?: HoshimiTrack | HoshimiTrack[]): Promise<this>;
+    /**
+     *
+     * Convert the queue to a JSON object.
+     * @returns {QueueJson} The queue JSON object.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     * await queue.add(track);
+     *
+     * console.log(queue.toJSON()); // { tracks: [track], history: [], current: null }
+     * ```
+     */
+    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 {
     /**
-     * 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;
-    /**
-     * The last position received from Lavalink.
-     * @type {number}
-     */
-    lastPosition: number;
-    /**
-     * The timestamp when the last position change update happened.
-     * @type {number | null}
-     */
-    lastPositionUpdate: number | null;
-    /**
-     * The current calculated position of the player.
-     * @type {number}
-     */
-    position: number;
-    /**
-     * The timestamp when the player was created.
-     * @type {number}
-     */
-    createdTimestamp: number;
-    /**
-     * The ping of the player.
-     * @type {number}
-     */
-    ping: number;
+    readonly encoded?: string;
     /**
-     * The queue of the player.
-     * @type {QueueJson}
+     * The track info.
+     * @type {UnresolvedTrackInfo}
      */
-    queue: QueueJson;
+    readonly info: UnresolvedTrackInfo;
     /**
-     * The node of the player.
-     * @type {NodeJson}
+     * The plugin info of the track.
+     * @type {Partial<PluginInfo>}
      */
-    node: NodeJson;
+    readonly pluginInfo?: Partial<PluginInfo>;
     /**
-     * The filter settings of the player.
-     * @type {FilterSettings}
+     * The track user data.
+     * @type {TrackUserData | undefined}
      */
-    filters: FilterSettings;
-}
-/**
- * The lyrics methods for the player.
- */
-interface LyricsMethods {
+    userData?: TrackUserData;
     /**
-     *
-     * 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 requester of the track.
+     * @type {TrackRequester | undefined}
      */
-    current(skipSource?: boolean): Promise<LyricsResult | null>;
+    requester: TrackRequester;
     /**
-     *
-     * 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.
+     * 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");
-     * const track = player.queue.current;
-     * const lyrics = await player.lyrics.get(track);
-     * ```
-     */
-    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
-    /**
+     * const track = new UnresolvedTrack({
+     * 	encoded: "base64",
+     * 	info: {
+     * 		title: "Track Title",
+     * 	},
+     * 	// the rest of the track info
+     * }, requester);
      *
-     * 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();
+     * 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.
@@ -3954,9 +4436,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 {
     /**
@@ -3976,9 +4458,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.
@@ -4381,6 +4863,11 @@ interface NodeInfo {
      * @type {NodeInfoPlugin[]}
      */
     plugins: NodeInfoPlugin[];
+    /**
+     * Whether the node is a Nodelink instance.
+     * @type {boolean
+     */
+    isNodelink: boolean;
 }
 /**
  * The node options.
@@ -4648,7 +5135,7 @@ declare class Node {
     readonly nodeManager: NodeManagerStructure;
     /**
      * The lyrics manager for the node.
-     * @type {LyricsManager}
+     * @type {LyricsManagerStructure}
      */
     readonly lyricsManager: LyricsManagerStructure;
     /**
@@ -4741,6 +5228,23 @@ declare class Node {
      * ```
      */
     get id(): string;
+    /**
+     *
+     * Check if the node is a Nodelink node.
+     * @returns {boolean} True if the node is a Nodelink node, false otherwise.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) {
+     * 	 if (node.isNodelink()) {
+     * 		console.log("The node is a Nodelink node");
+     *   } else {
+     *       console.log("The node is a Lavalink node");
+     *   }
+     * }
+     * ```
+     */
+    isNodelink(): boolean;
     /**
      * The socket address to connect the node.
      * @type {string}
@@ -4879,19 +5383,18 @@ declare class Node {
     /**
      *
      * Update the session for the node
-     * @param {boolean} resuming Enable resuming for the session.
-     * @param {number | null} timeout The timeout for the session.
+     * @param {SessionResumingOptions} options The session resuming options.
      * @returns {Promise<LavalinkSession | null>}
      * @example
      * ```ts
      * const node = manager.nodeManager.get("node1");
      * if (node) {
-     * 	const session = await node.updateSession(true, 60);
+     * 	const session = await node.updateSession({ resuming: true, timeout: 30000 });
      * 	console.log(session); // the lavalink session
      * }
      * ```
      */
-    updateSession(resuming: boolean, timeout?: number | null): Promise<LavalinkSession | null>;
+    updateSession(options: SessionResumingOptions): Promise<LavalinkSession | null>;
     /**
      * Reconnect the node.
      * @returns {void}
@@ -5081,7 +5584,12 @@ declare enum SearchEngines {
      * Play voice using text to speech.
      * @description Provided by skybot-lavalink-plugin plugin.
      */
-    TextToSpeech = "speak"
+    TextToSpeech = "speak",
+    /**
+     * Search via http url.
+     * @description Provided by lavalink.
+     */
+    HTTP = "http"
 }
 /**
  * The debug levels for the manager.
@@ -5115,7 +5623,7 @@ declare enum DebugLevels {
 /**
  * The events for the manager.
  */
-declare enum Events {
+declare enum EventNames {
     /**
      * Emitted when the manager emits a debug message.
      */
@@ -5168,6 +5676,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.
      */
@@ -5236,7 +5748,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.
@@ -5335,6 +5855,11 @@ interface HoshimiOptions {
      * @type {HoshimiRestOptions}
      */
     restOptions?: HoshimiRestOptions;
+    /**
+     * The player options to use.
+     * @type {HoshimiPlayerOptions}
+     */
+    playerOptions?: HoshimiPlayerOptions;
 }
 /**
  * The events for the manager.
@@ -5417,6 +5942,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.
@@ -5678,7 +6209,7 @@ interface ChannelDeletePacket {
 /**
  * Make a function awaitable by returning a promise or the value.
  */
-type Awaitable<T> = T | Promise<T>;
+type Awaitable<T> = Promise<T> | T;
 /**
  * Create a type that infers the value of a key from an object.
  */
@@ -5693,6 +6224,10 @@ type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
  * Create a type that can be a rest or an array.
  */
 type RestOrArray<T> = T[] | [T[]];
+/**
+ * Conditional type to check if T is true, then A, else B or A | null.
+ */
+type If<T extends boolean, A, B = null> = T extends true ? A : B extends null ? A | null : B;
 /**
  * Make a type required.
  */
@@ -5735,19 +6270,43 @@ type GatewayPackets = VoicePacket | VoiceServer | VoiceState | ChannelDeletePack
  * The required options for the manager.
  */
 type RequiredOptions = DeepRequired<HoshimiOptions>;
-/**
- * The events for the manager.
- * This allows to extend the events.
- */
-type RawEvents = {
-    [K in keyof HoshimiEvents]: HoshimiEvents[K];
-};
 /**
  * Class representing the Hoshimi manager.
  * @class Hoshimi
- * @extends {EventEmitter<RawEvents>}
+ * @extends {EventEmitter<HoshimiEvents>}
+ * @example
+ * ```ts
+ * import { Hoshimi, SearchEngines } from "hoshimi";
+ *
+ * const manager = new Hoshimi({ // or via createHoshimi() function
+ *  sendPayload: async (guildId, payload) => {
+ *      const guild = await <Client>.guilds.fetch(guildId);
+ *      if (!guild) return;
+ *
+ *      guild.shard.send(payload); // Adjust this line based on your library's method to send payloads
+ *  },
+ * 	nodes: [
+ * 		{
+ * 			host: "localhost",
+ * 			port: 2333,
+ *          password: "youshallnotpass",
+ * 			secure: false,
+ * 		},
+ *     ],
+ * });
+ *
+ * manager.on("nodeReady", (node) => console.log(`Node ${node.id} is ready.`));
+ * manager.on("playerCreate", (player) => console.log(`Player created for guild ${player.guildId}.`));
+ * manager.on("error", (error) => console.error("An error occurred:", error));
+ *
+ * <Client>.on("ready", () => {
+ *   manager.init({ id: <Client>.user.id, username: <Client>.user.username });
+ * });
+ *
+ * console.log(manager); // The manager instance
+ * ```
  */
-declare class Hoshimi extends EventEmitter<RawEvents> {
+declare class Hoshimi extends EventEmitter<HoshimiEvents> {
     /**
      * The options for the manager.
      * @type {HoshimiOptions}
@@ -5774,6 +6333,7 @@ declare class Hoshimi extends EventEmitter<RawEvents> {
      * The constructor for the manager.
      * @param {HoshimiOptions} options The options for the manager.
      * @throws {ManagerError} If the options are not provided.
+     * @throws {OptionError} If the options are invalid.
      * @example
      * ```ts
      * const manager = new Hoshimi({
@@ -5799,10 +6359,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
@@ -5921,12 +6495,31 @@ declare class Hoshimi extends EventEmitter<RawEvents> {
  */
 declare function createHoshimi(...args: ConstructorParameters<typeof Hoshimi>): Hoshimi;
 
+/**
+ * Class representing a player storage.
+ * @class PlayerMemoryStorage
+ * @extends {PlayerStorageAdapter}
+ */
+declare class PlayerMemoryStorage<K extends StorageKeys = StorageKeys, V extends StorageValues<K> = StorageValues<K>> extends PlayerStorageAdapter {
+    get<K extends StorageKeys, V extends StorageValues<K>>(key: K): Awaitable<V | undefined>;
+    set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): Awaitable<void>;
+    has<K extends StorageKeys>(key: K): Awaitable<boolean>;
+    delete<K extends StorageKeys>(key: K): Awaitable<boolean>;
+    keys<K extends StorageKeys[]>(): Awaitable<K[]>;
+    values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<V[]>;
+    entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<[K, V][]>;
+    all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<Record<K[number], V>>;
+    clear(): Awaitable<void>;
+    size(): Awaitable<number>;
+    buildKey(...parts: RestOrArray<string>): string;
+}
+
 /**
  * Class representing a memory storage manager.
  * @class MemoryAdapter
- * @extends {StorageAdapter}
+ * @extends {QueueStorageAdapter}
  */
-declare class MemoryAdapter<T extends QueueJson = QueueJson> extends StorageAdapter<T> {
+declare class QueueMemoryStorage<T extends QueueJson = QueueJson> extends QueueStorageAdapter<T> {
     get(key: string): T | undefined;
     set(key: string, value: T): void;
     delete(key: string): boolean;
@@ -5934,6 +6527,108 @@ declare class MemoryAdapter<T extends QueueJson = QueueJson> extends StorageAdap
     has(key: string): boolean;
     parse(value: unknown): T;
     stringify<R = string>(value: unknown): R;
+    buildKey(...parts: RestOrArray<string>): string;
 }
 
-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 };
+/**
+ * The auto output record type.
+ */
+type AutoOutputRecord = Record<AudioOutput, Required<ChannelMixSettings>>;
+/**
+ * The user agent for Hoshimi.
+ * @type {UserAgent}
+ */
+declare const HoshimiAgent: UserAgent;
+/**
+ * The url regex for Hoshimi.
+ * @type {RegExp}
+ */
+declare const UrlRegex: RegExp;
+/**
+ * The valid search engines for Hoshimi.
+ * @type {SearchEngines[]}
+ */
+declare const ValidEngines: SearchEngines[];
+/**
+ * The valid sources for Hoshimi.
+ * @type {Map<SourceNames, SearchEngines>}
+ */
+declare const ValidSources: Map<SourceNames, SearchEngines>;
+/**
+ * The audio output data for Hoshimi.
+ * @type {Readonly<Record<AudioOutput, Required<ChannelMixSettings>>>}
+ */
+declare const AudioOutputData: Readonly<AutoOutputRecord>;
+/**
+ * The default filter presets.
+ */
+declare const DefaultFilterPreset: Readonly<{
+    Karaoke: {
+        level: number;
+        monoLevel: number;
+        filterBand: number;
+        filterWidth: number;
+    };
+    Vaporwave: {
+        speed: number;
+        pitch: number;
+        rate: number;
+    };
+    Nightcore: {
+        speed: number;
+        pitch: number;
+        rate: number;
+    };
+    Lowpass: {
+        smoothing: number;
+    };
+    Tremolo: {
+        frequency: number;
+        depth: number;
+    };
+    Vibrato: {
+        frequency: number;
+        depth: number;
+    };
+    Distortion: {
+        cosOffset: number;
+        sinOffset: number;
+        tanOffset: number;
+        offset: number;
+        scale: number;
+        cosScale: number;
+        sinScale: number;
+        tanScale: number;
+    };
+    DSPXHighPass: {
+        boostFactor: number;
+        cutoffFrequency: number;
+    };
+    DSPXLowPass: {
+        boostFactor: number;
+        cutoffFrequency: number;
+    };
+    DSPXNormalization: {
+        adaptive: boolean;
+        maxAmplitude: number;
+    };
+    DSPXEcho: {
+        decay: number;
+        echoLength: number;
+    };
+    PluginEcho: {
+        decay: number;
+        delay: number;
+    };
+    PluginReverb: {
+        delays: number[];
+        gains: number[];
+    };
+}>;
+/**
+ * The default filter settings.
+ * @type {Readonly<FilterSettings>} DefaultFilters
+ */
+declare const DefaultPlayerFilters: Readonly<FilterSettings>;
+
+export { AudioOutput, AudioOutputData, type Awaitable, type ChannelDelete, type ChannelDeletePacket, type ChannelMixSettings, type ClientData, type CustomizablePlayerStorage, type CustomizableStructures, type CustomizableTrack, DSPXPluginFilter, DebugLevels, type DecodeMethods, type DeepRequired, DefaultFilterPreset, DefaultPlayerFilters, DestroyReasons, type DistortionSettings, type EQBandSettings, type EchoSettings, type EnabledDSPXPluginFilters, type EnabledLavalinkFilters, type EnabledPlayerFilters, EventNames, type Exception, type FetchOptions, FilterManager, type FilterManagerStructure, type FilterPluginPassSettings, type FilterSettings, FilterType, type FreqSettings, type GatewayPayload, type GatewaySendPayload, Hoshimi, HoshimiAgent, type HoshimiEvents, type HoshimiNodeOptions, type HoshimiOptions, type HoshimiPlayerOptions, type HoshimiQueueOptions, type HoshimiRestOptions, type HoshimiTrack, HttpMethods, HttpStatusCodes, type If, 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, Node, type NodeCpu, type NodeDestroyInfo, NodeDestroyReasons, type NodeDisconnectInfo, NodeError, type NodeFrameStats, type NodeIdentifier, type NodeInfo, type NodeInfoGit, type NodeInfoPlugin, type NodeInfoVersion, type NodeJson, NodeManagerError, 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, PlayerMemoryStorage, type PlayerOptions, PlayerStorageAdapter, type PlayerStructure, type PlayerUpdate, type PlayerUpdateState, type PlayerVoice, type Playlist, type PlaylistInfo, type PluginFilterSettings, type PluginInfo, PluginInfoType, PluginNames, type QueryResult, Queue, type QueueJson, QueueMemoryStorage, QueueStorageAdapter, type QueueStructure, type Ready, ResolveError, Rest, type RestEndpoint, type RestOptions, type RestOrArray, RestPathType, RestRoutes, type RestStructure, type ResumableHeaders, type RotationSettings, SearchEngines, type SearchOptions, type SearchQuery, type SessionResumingOptions, Severity, SourceNames, State, type Stats, StorageError, type StorageKeys, type StorageValues, 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, UrlRegex, type UserAgent, ValidEngines, ValidSources, type VoiceChannelUpdate, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent, WebsocketCloseCodes, createHoshimi };