hoshimi 0.3.3 → 0.3.5

package/dist/index.d.mts

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