hoshimi 0.3.5 → 0.3.6

package/dist/index.d.mts

@@ -41,6 +41,14 @@ declare class NodeError extends Error {
 declare class StorageError extends Error {
     constructor(message: string);
 }
+/**
+ * Error class for the node manager.
+ * @class NodeManagerError
+ * @extends {Error}
+ */
+declare class NodeManagerError extends Error {
+    constructor(message: string);
+}
 /**
  * Error class for resolving tracks.
  * @class ResolveError
@@ -648,2328 +656,2686 @@ interface EnabledDSPXPluginFilters {
 }
 
 /**
- * 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 methods for http requests
  */
-declare abstract class StorageAdapter<T extends QueueJson = QueueJson> {
+declare enum HttpMethods {
     /**
-     *
-     * 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 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}
      */
-    abstract get(key: string): Awaitable<T | undefined>;
+    Get = "GET",
     /**
-     *
-     * 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 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}
      */
-    abstract set(key: string, value: T): Awaitable<void>;
+    Post = "POST",
     /**
-     *
-     * 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
-     * ```
+     * 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}
      */
-    abstract delete(key: string): Awaitable<boolean>;
+    Put = "PUT",
     /**
-     * Clear the storage.
-     * @returns {Awaitable<void>} Scary, right?
-     * @example
-     * ```ts
-     * await storage.clear();
-     * ```
+     * 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}
      */
-    abstract clear(): Awaitable<void>;
+    Patch = "PATCH",
     /**
-     * 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 DELETE method deletes the specified resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE
+     * @type {string}
      */
-    abstract has(key: string): Awaitable<boolean>;
+    Delete = "DELETE",
     /**
-     *
-     * Parse the value.
-     * @param {unknown} value The value to parse.
-     * @returns {T} The parsed value.
-     * @example
-     * ```ts
-     * const parsed = await storage.parse<{ key: string }>("{'key':'value'}");
-     * console.log(parsed); // { key: "value" }
-     * ```
+     * 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}
      */
-    abstract parse(value: unknown): Awaitable<T>;
+    Head = "HEAD"
+}
+declare enum RestPathType {
     /**
-     *
-     * Stringify the value.
-     * @param {unknown} value The value to stringify.
-     * @returns {R} The stringified value.
-     * @example
-     * ```ts
-     * const stringified = await storage.stringify({ key: "value" });
-     * console.log(stringified); // "{'key':'value'}"
-     * ```
+     * The raw path of the request.
+     * @type {string}
      */
-    abstract stringify<R = string>(value: unknown): Awaitable<R>;
+    Raw = "/",
+    /**
+     * The versioned path v4 of the request.
+     * @type {string}
+     */
+    V4 = "/v4"
 }
-
 /**
- * The queue options.
+ * The status codes for the REST.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
  */
-interface HoshimiQueueOptions {
+declare enum HttpStatusCodes {
     /**
-     * The maximum amount of tracks that can be saved in the queue.
+     * The request has succeeded.
      * @type {number}
-     * @default 25
      */
-    maxHistory?: number;
+    OK = 200,
     /**
-     *
-     * The function to use for autoplay.
-     * @param {Player} player The player.
-     * @param {HoshimiTrack | null} lastTrack The last track played.
+     * The request has been fulfilled and resulted in a new resource being created.
+     * @type {number}
      */
-    autoplayFn?(player: PlayerStructure, lastTrack: HoshimiTrack | null): Awaitable<void>;
+    Created = 201,
     /**
-     * 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 request has been accepted for processing, but the processing has not been completed.
+     * @type {number}
      */
-    autoPlay?: boolean;
+    Accepted = 202,
     /**
-     * The storage manager to use for the queue.
-     * @type {StorageAdapter}
-     * @default {MemoryAdapter}
+     * The server successfully processed the request, but is not returning any content.
+     * @type {number}
      */
-    storage?: StorageAdapter;
-}
-/**
- * The queue json.
- */
-interface QueueJson {
+    NoContent = 204,
     /**
-     * The tracks of the queue.
-     * @type {HoshimiTrack[]}
+     * The resource has been moved permanently to a new URI.
+     * @type {number}
      */
-    tracks: HoshimiTrack[];
+    MovedPermanently = 301,
     /**
-     * The previous tracks of the queue.
-     * @type {Track[]}
+     * The requested resource has been found at a different URI.
+     * @type {number}
      */
-    history: Track[];
+    Found = 302,
     /**
-     * The current track of the queue.
-     * @type {Track | null}
+     * The resource has not been modified since the last request.
+     * @type {number}
      */
-    current: Track | null;
-}
-
-/**
- * Partial Lavalink track type.
- */
-type PartialLavalinkTrack = Partial<Nullable<LavalinkTrack>>;
-/**
- * The base options for playing a track.
- */
-interface BasePlayOptions {
+    NotModified = 304,
     /**
-     * The position to start the track.
-     * @type {number | undefined}
+     * The request cannot be processed due to bad syntax.
+     * @type {number}
      */
-    position?: number;
+    BadRequest = 400,
     /**
-     * The position to end the track.
-     * @type {number | undefined}
+     * The request requires user authentication.
+     * @type {number}
      */
-    endTime?: number;
+    Unauthorized = 401,
     /**
-     * The pause state of the player.
-     * @type {boolean | undefined}
+     * The request was valid, but the server is refusing action.
+     * @type {number}
      */
-    paused?: boolean;
+    Forbidden = 403,
     /**
-     * The volume of the player.
-     * @type {number | undefined}
+     * The server cannot find the requested resource.
+     * @type {number}
      */
-    volume?: number;
+    NotFound = 404,
     /**
-     * The filters for the player.
-     * @type {Partial<FilterSettings> | undefined}
+     * The request method is known by the server but has been disabled and cannot be used.
+     * @type {number}
      */
-    filters?: Partial<FilterSettings>;
+    MethodNotAllowed = 405,
     /**
-     * The voice settings for the player.
-     * @type {LavalinkPlayerVoice | undefined}
+     * The server timed out waiting for the request.
+     * @type {number}
      */
-    voice?: LavalinkPlayerVoice;
-}
-/**
- * The types of loop modes.
- */
-declare enum LoopMode {
+    RequestTimeout = 408,
     /**
-     * Loop mode for repeating the current track.
+     * The request could not be completed due to a conflict with the current state of the resource.
+     * @type {number}
      */
-    Track = 1,
+    Conflict = 409,
     /**
-     * Loop mode for repeating the queue.
+     * The requested resource is no longer available and will not be available again.
+     * @type {number}
      */
-    Queue = 2,
+    Gone = 410,
     /**
-     * Loop mode for repeating nothing.
+     * The user has sent too many requests in a given amount of time.
+     * @type {number}
      */
-    Off = 3
-}
-/**
- * The types of player events.
- */
-declare enum PlayerEventType {
+    TooManyRequests = 429,
     /**
-     * Event type for when a track starts.
+     * A generic error message, given when no more specific message is suitable.
+     * @type {number}
      */
-    TrackStart = "TrackStartEvent",
+    InternalServerError = 500,
     /**
-     * Event type for when a track ends.
+     * The server does not recognize the request method or lacks the ability to fulfill it.
+     * @type {number}
      */
-    TrackEnd = "TrackEndEvent",
+    NotImplemented = 501,
     /**
-     * Event type for when a track encounters an exception.
+     * The server was acting as a gateway and received an invalid response.
+     * @type {number}
      */
-    TrackException = "TrackExceptionEvent",
+    BadGateway = 502,
     /**
-     * Event type for when a track gets stuck.
+     * The server is currently unavailable (overloaded or down).
+     * @type {number}
      */
-    TrackStuck = "TrackStuckEvent",
+    ServiceUnavailable = 503,
     /**
-     * Event type for when lyrics are found.
+     * The server did not receive a timely response from an upstream server.
+     * @type {number}
      */
-    LyricsFound = "LyricsFoundEvent",
+    GatewayTimeout = 504
+}
+/**
+ * The REST routes.
+ */
+declare const RestRoutes: {
     /**
-     * Event type for when lyrics are not found.
+     *
+     * Get the updated player endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @param {string} guildId The guild id of the player.
+     * @returns {RestEndpoint} The endpoint for updating the player.
      */
-    LyricsNotFound = "LyricsNotFoundEvent",
+    UpdatePlayer(sessionId: string, guildId: string): `/sessions/${string}/players/${string}`;
     /**
-     * Event type for when a lyrics line is sent.
+     *
+     * Get the update session endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @returns {RestEndpoint} The endpoint for updating the session.
      */
-    LyricsLine = "LyricsLineEvent",
+    UpdateSession(sessionId: string): `/sessions/${string}`;
     /**
-     * Event type for when the WebSocket connection is closed.
+     *
+     * Get the get players endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @returns {RestEndpoint} The endpoint for getting the players.
      */
-    WebsocketClosed = "WebSocketClosedEvent"
-}
-/**
- * The reasons a track can end.
- */
-declare enum TrackEndReason {
+    GetPlayers(sessionId: string): `/sessions/${string}/players`;
     /**
-     * The track ended normally.
+     *
+     * Get the current lyrics endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @param {string} guildId The guild id of the player.
+     * @returns {RestEndpoint} The endpoint for getting the current lyrics.
      */
-    Finished = "finished",
+    CurrentLyrics(sessionId: string, guildId: string): `/sessions/${string}/players/${string}/track/lyrics`;
     /**
-     * The track fails to load.
+     *
+     * Subscribe to lyrics endpoint.
+     * @param {string} sessionId The session id of the node.
+     * @param {string} guildId The guild id of the player.
+     * @returns {RestEndpoint} The endpoint for subscribing to lyrics.
      */
-    LoadFailed = "loadFailed",
+    SubscribeLyrics(sessionId: string, guildId: string): `/sessions/${string}/players/${string}/lyrics/subscribe`;
     /**
-     * The track was stopped.
+     * Get the lyrics endpoint.
+     * @type {RestEndpoint}
      */
-    Stopped = "stopped",
+    GetLyrics: "/lyrics";
     /**
-     * The track was replaced.
+     * Get the decode track endpoint.
+     * @type {RestEndpoint}
      */
-    Replaced = "replaced",
+    DecodeTrack: "/decodetrack";
     /**
-     * The track was cleaned up.
+     * Get the decode tracks endpoint.
+     * @type {RestEndpoint}
      */
-    Cleanup = "cleanup"
-}
-/**
- * The options for automatic player error handling.
- */
-interface ErrorPlayerActions {
+    DecodeTracks: "/decodetracks";
     /**
-     * Whether to automatically destroy the player on error.
-     * @type {boolean | undefined}
-     * @default false
+     * Get the load tracks endpoint.
+     * @type {RestEndpoint}
      */
-    autoDestroy?: boolean;
+    LoadTracks: "/loadtracks";
     /**
-     * Whether to automatically skip the track on error.
-     * @type {boolean | undefined}
-     * @default false
+     * Get the node info endpoint.
+     * @type {RestEndpoint}
      */
-    autoSkip?: boolean;
+    NodeInfo: "/info";
     /**
-     * Whether to automatically stop the player on error.
-     * @type {boolean | undefined}
-     * @default false
+     * Get the load lyrics endpoint.
+     * @type {RestEndpoint}
+     * @description Used in NodelinkLyricsManager, only for nodelink nodes.
      */
-    autoStop?: boolean;
-}
+    LoadLyrics: "/loadlyrics";
+    /**
+     * Get the connection endpoint.
+     * @type {RestEndpoint}
+     * @description Used for checking the connection status of the node, only for nodelink nodes.
+     */
+    Connection: "/connection";
+};
 /**
- * The options for error actions.
+ * The options for the REST.
  */
-interface DisconnectPlayerActions extends Pick<ErrorPlayerActions, "autoDestroy"> {
+interface RestOptions {
     /**
-     * Whether to automatically reconnect on disconnect.
-     * @type {boolean | undefined}
-     * @default false
+     * The endpoint for the REST.
+     * @type {RestEndpoint}
      */
-    autoReconnect?: boolean;
+    endpoint: RestEndpoint;
     /**
-     * Whether to automatically add tracks back to the queue on disconnect.
-     * @type {boolean | undefined}
-     * @default false
+     * The method for the REST.
+     * @type {HttpMethods}
      */
-    autoQueue?: boolean;
-}
-/**
- * The Hoshimi player options.
- */
-interface HoshimiPlayerOptions {
+    method?: HttpMethods;
     /**
-     *
-     * The function to use to get the requester data.
-     * @param {TrackRequester} requester The requester of the track.
+     * The headers for the REST.
+     * @type {Record<string, string>}
      */
-    requesterFn?<T extends TrackRequester = TrackRequester>(requester: TrackRequester): Awaitable<T>;
+    headers?: Record<string, string>;
     /**
-     * The options for handling errors.
-     * @type {ErrorPlayerActions | undefined}
+     * The body for the REST.
+     * @type {Record<string, unknown> | string | undefined}
      */
-    onError?: ErrorPlayerActions;
+    body?: Record<string, unknown> | string;
     /**
-     * The options for handling disconnects.
-     * @type {DisconnectPlayerActions | undefined}
+     * The query parameters for the REST.
+     * @type {Record<string, string>}
      */
-    onDisconnect?: DisconnectPlayerActions;
+    params?: Record<string, string>;
+    /**
+     * The path type for the REST.
+     * @type {RestPathType}
+     */
+    pathType?: RestPathType;
 }
 /**
- * The base interface for player events.
+ * The fetch options for the request.
  */
-interface PlayerEvent {
+interface FetchOptions extends Omit<RestOptions, "endpoint" | "body"> {
     /**
-     * The operation code for the event.
-     * @type {OpCodes.Event}
+     * The signal for the request.
      */
-    op: OpCodes.Event;
+    signal: AbortSignal;
     /**
-     * The guild ID associated with the event.
-     * @type {string}
+     * The stringified body for the request.
      */
-    guildId: string;
+    body?: string;
 }
 /**
- * The event for when a track starts playing.
+ * The error for the REST.
  */
-interface TrackStartEvent extends PlayerEvent {
+interface LavalinkRestError {
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackStart}
+     * The timestamp for the REST.
+     * @type {number}
      */
-    type: PlayerEventType.TrackStart;
+    timestamp: number;
     /**
-     * The track that started playing.
-     * @type {LavalinkTrack}
+     * The status for the REST.
+     * @type {number}
      */
-    track: LavalinkTrack;
-}
-/**
- * The event for when a track ends.
- */
-interface TrackEndEvent extends PlayerEvent {
+    status: number;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackEnd}
+     * The error for the REST.
+     * @type {string}
      */
-    type: PlayerEventType.TrackEnd;
+    error: string;
     /**
-     * The track that ended.
-     * @type {LavalinkTrack}
+     * The trace for the REST.
+     * @type {string}
      */
-    track: LavalinkTrack;
+    trace?: string;
     /**
-     * The reason the track ended.
-     * @type {TrackEndReason}
+     * The message for the REST.
+     * @type {string}
      */
-    reason: TrackEndReason;
+    message: string;
+    /**
+     * The path for the REST.
+     * @type {string}
+     */
+    path: string;
 }
 /**
- * The event for when a track gets stuck.
+ * The player response from the Lavalink REST API.
  */
-interface TrackStuckEvent extends PlayerEvent {
+interface LavalinkPlayer {
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackStuck}
+     * The guild ID associated with the player.
+     * @type {string}
      */
-    type: PlayerEventType.TrackStuck;
+    guildId: string;
     /**
-     * The track that got stuck.
+     * The track currently being played.
      * @type {LavalinkTrack}
      */
-    track: LavalinkTrack;
+    track?: LavalinkTrack;
     /**
-     * The threshold in milliseconds.
+     * The volume of the player.
      * @type {number}
      */
-    thresholdMs: number;
-}
-/**
- * The event for when a track encounters an exception.
- */
-interface TrackExceptionEvent extends PlayerEvent {
+    volume: number;
     /**
-     * The type of the event.
-     * @type {PlayerEventType.TrackException}
+     * Whether the player is paused.
+     * @type {boolean}
      */
-    type: PlayerEventType.TrackException;
+    paused: boolean;
     /**
-     * The exception that occurred.
-     * @type {Exception}
+     * The voice connection details.
+     * @type {LavalinkPlayerVoice}
      */
-    exception: Exception;
+    voice: LavalinkPlayerVoice;
+    /**
+     * The filter options applied to the player.
+     * @type {FilterSettings}
+     */
+    filters: FilterSettings;
+    /**
+     * The state of the player.
+     * @type {LavalinkPlayerState}
+     */
+    state: LavalinkPlayerState;
 }
 /**
- * The event for when the WebSocket connection is closed.
+ * The state of the player.
  */
-interface WebSocketClosedEvent extends PlayerEvent {
+interface LavalinkPlayerState {
     /**
-     * The type of the event.
-     * @type {PlayerEventType.WebsocketClosed}
+     * The time since the connection was established.
+     * @type {number}
      */
-    type: PlayerEventType.WebsocketClosed;
+    time: number;
     /**
-     * The close code.
+     * The position of the current track in milliseconds.
      * @type {number}
      */
-    code: number;
+    position: number;
     /**
-     * Whether the connection was closed by the remote.
+     * Whether the player is connected to the voice channel.
      * @type {boolean}
      */
-    byRemote: boolean;
+    connected: boolean;
     /**
-     * The reason for the closure.
-     * @type {string}
+     * The ping to the voice server in milliseconds.
+     * @type {number}
      */
-    reason: string;
+    ping: number;
 }
 /**
- * The event for when lyrics are found.
+ * The options to update the player.
  */
-interface LyricsFoundEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsFound}
-     */
-    type: PlayerEventType.LyricsFound;
+interface UpdatePlayerInfo {
     /**
-     * The guild id associated with the event.
+     * The guild id associated with the player.
      * @type {string}
      */
     guildId: string;
     /**
-     * The lyrics result of the event.
-     * @type {LyricsResult}
+     * The options to update the player.
+     * @type {LavalinkPlayOptions}
      */
-    lyrics: LyricsResult;
+    playerOptions: LavalinkPlayOptions;
+    /**
+     * Whether to replace the current track.
+     * @type {boolean | undefined}
+     * @default false
+     */
+    noReplace?: boolean;
 }
 /**
- * The event for when lyrics are not found.
+ * The updated session of the current session.
  */
-interface LyricsNotFoundEvent extends PlayerEvent {
+interface LavalinkSession {
     /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsNotFound}
+     * Whather the session is resuming.
+     * @type {boolean}
      */
-    type: PlayerEventType.LyricsNotFound;
+    resuming: boolean;
     /**
-     * The guild id associated with the event.
-     * @type {string}
+     * The timeout for the session.
+     * @type {number}
      */
-    guildId: string;
+    timeout: number;
 }
 /**
- * The event for when a lyrics line is sent.
+ * The rest options.
  */
-interface LyricsLineEvent extends PlayerEvent {
-    /**
-     * The type of the event.
-     * @type {PlayerEventType.LyricsLine}
-     */
-    type: PlayerEventType.LyricsLine;
+interface HoshimiRestOptions {
     /**
-     * The guild id associated with the event.
-     * @type {string}
-     */
-    guildId: string;
-    /**
-     * The line index of the lyrics line.
+     * The amount of time to wait for the player to resume. (in milliseconds)
      * @type {number}
+     * @default 10000
      */
-    lineIndex: number;
-    /**
-     * The lyrics line of the event.
-     * @type {LyricsLine}
-     */
-    line: LyricsLine;
-    /**
-     * Returns if the line was skipped.
-     * @type {boolean}
-     */
-    skipped: boolean;
+    resumeTimeout?: number;
 }
 /**
- * The update for the player state.
+ * The methods for decoding base64 encoded tracks.
  */
-interface PlayerUpdate {
-    /**
-     * The operation code for the update.
-     * @type {OpCodes.PlayerUpdate}
-     */
-    op: OpCodes.PlayerUpdate;
+interface DecodeMethods {
     /**
-     * The guild ID associated with the update.
-     * @type {string}
+     *
+     * 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
+     * ```
      */
-    guildId: string;
+    single(track: string, requester: TrackRequester): Promise<Track>;
     /**
-     * The state of the player.
-     * @type {PlayerUpdateState}
+     * 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
+     * ```
      */
-    state: PlayerUpdateState;
+    multiple(tracks: string[], requester: TrackRequester): Promise<Track[]>;
 }
-interface PlayerUpdateState {
+/**
+ * The options for resuming a session.
+ */
+interface SessionResumingOptions {
     /**
-     * Whether the player is connected.
+     * Whether the session is resuming.
      * @type {boolean}
      */
-    connected: boolean;
-    /**
-     * The position of the track.
-     * @type {number}
-     */
-    position: number;
-    /**
-     * The time of the update.
-     * @type {number}
-     */
-    time: number;
+    resuming: boolean;
     /**
-     * The ping of the player.
-     * @type {number}
+     * The timeout for resuming the session in milliseconds.
+     * @type {number | null | undefined}
      */
-    ping: number;
+    timeout?: number | null;
 }
 /**
- * The options for the player.
+ * The session of the node.
  */
-interface PlayerOptions {
-    /**
-     * Guild id of the player.
-     * @type {string}
-     */
-    guildId: string;
+type NullableLavalinkSession = PickNullable<LavalinkSession, "timeout">;
+/**
+ * The REST endpoint type.
+ */
+type RestEndpoint = `/${string}`;
+
+/**
+ * Class representing the DSPX Plugin filters for a player.
+ * @class DSPXPluginFilter
+ */
+declare class DSPXPluginFilter {
     /**
-     * Voice channel id of the player.
-     * @type {string}
+     * The filter manager instance.
+     * @type {FilterManagerStructure}
+     * @readonly
      */
-    voiceId: string;
+    readonly manager: FilterManagerStructure;
     /**
-     * Volume of the player.
-     * @type {number | undefined}
-     * @default 100
+     * Create a new DSPXPluginFilter instance.
+     * @param {FilterManagerStructure} manager The filter manager instance.
      */
-    volume?: number;
+    constructor(manager: FilterManagerStructure);
     /**
-     * Set if the player should be deafened.
-     * @type {boolean | undefined}
-     * @default true
+     *
+     * Set the low-pass filter with the given settings.
+     * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXLowPass] The settings for the low-pass filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the low-pass filter with custom settings
+     * await player.filterManager.dspxPlugin.setLowPass({ cutoffFrequency: 500, boostFactor: 1.5 });
+     * // Disable the low-pass filter
+     * await player.filterManager.dspxPlugin.setLowPass();
+     * ```
      */
-    selfDeaf?: boolean;
+    setLowPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
     /**
-     * Set if the player should be muted.
-     * @type {boolean | undefined}
-     * @default false
+     *
+     * Set the high-pass filter with the given settings.
+     * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXHighPass] The settings for the high-pass filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the high-pass filter with custom settings
+     * await player.filterManager.dspxPlugin.setHighPass({ cutoffFrequency: 2000, boostFactor: 0.8 });
+     * // Disable the high-pass filter
+     * await player.filterManager.dspxPlugin.setHighPass();
+     * ```
      */
-    selfMute?: boolean;
+    setHighPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
     /**
-     * Text channel id of the player.
-     * @type {string | undefined}
+     *
+     * Set the normalization filter with the given settings.
+     * @param {NormalizationSettings} [settings=DefaultFilter.DSPXNormalization] The settings for the normalization filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the normalization filter with custom settings
+     * await player.filterManager.dspxPlugin.setNormalization({ maxAmplitude: 0.9, adaptive: true });
+     * // Disable the normalization filter
+     * await player.filterManager.dspxPlugin.setNormalization();
+     * ```
      */
-    textId?: string;
+    setNormalization(settings?: Partial<NormalizationSettings>): Promise<this>;
     /**
-     * Lavalink node of the player.
-     * @type {NodeIdentifier}
+     *
+     * Set the echo filter with the given settings.
+     * @param {EchoSettings} [settings=DefaultFilter.DSPXEcho] The settings for the echo filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the echo filter with custom settings
+     * await player.filterManager.dspxPlugin.setEcho({ echoLength: 500, decay: 0.5, delay: 200 });
+     * // Disable the echo filter
+     * await player.filterManager.dspxPlugin.setEcho();
+     * ```
      */
-    node?: NodeIdentifier;
+    setEcho(settings?: Partial<EchoSettings>): Promise<this>;
 }
+
+type NonLengthEchoSettings = Omit$1<EchoSettings, "echoLength">;
 /**
- * The options for playing a track with Lavalink.
+ * Class representing Lavalink plugin filters.
+ * @class LavalinkPluginFilter
  */
-interface LavalinkPlayOptions extends BasePlayOptions {
+declare class LavalinkPluginFilter {
     /**
-     * Track to play.
-     * @type {PartialLavalinkTrack | undefined}
+     * The filter manager instance.
+     * @type {FilterManagerStructure}
+     * @private
+     * @readonly
      */
-    track?: PartialLavalinkTrack;
-}
-/**
- * The options for playing a track.
- */
-interface PlayOptions extends BasePlayOptions {
+    private readonly manager;
     /**
-     * Whether to replace the current track.
-     * @type {boolean | undefined}
-     * @default false
+     * Creates an instance of LavalinkPluginFilter.
+     * @param {FilterManagerStructure} filters - The filter manager instance.
      */
-    noReplace?: boolean;
+    constructor(filters: FilterManagerStructure);
     /**
-     * Track to play.
-     * @type {Track | UnresolvedTrack | undefined}
+     *
+     * Set the echo filter with the given settings.
+     * @param {Omit<EchoSettings, "echoLength">} [settings=DefaultFilter.PluginEcho] The settings for the echo filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the echo filter with custom settings
+     * await player.filterManager.lavalinkPlugin.setEcho({ decay: 0.5, delay: 200 });
+     * // Disable the echo filter
+     * await player.filterManager.lavalinkPlugin.setEcho();
+     * ```
      */
-    track?: Track | UnresolvedTrack;
-}
-interface PlayerVoice {
+    setEcho(settings?: Partial<NonLengthEchoSettings>): Promise<this>;
     /**
-     * The voice server token.
-     * @type {string}
+     *
+     * Set the reverb filter with the given settings.
+     * @param {Partial<LavalinkFilterPluginReverbSettings>} [settings=DefaultFilter.PluginReverb] The settings for the reverb filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not have the required plugin or filter enabled.
+     * @example
+     * ```ts
+     * // Set the reverb filter with custom settings
+     * await player.filterManager.lavalinkPlugin.setReverb({ delays: [50, 100, 150], gains: [0.5, 0.3, 0.2] });
+     * // Disable the reverb filter
+     * await player.filterManager.lavalinkPlugin.setReverb();
+     * ```
      */
-    token: string;
+    setReverb(settings?: Partial<LavalinkFilterPluginReverbSettings>): Promise<this>;
+}
+
+/**
+ * Class representing a filter manager for a player.
+ * @class FilterManager
+ */
+declare class FilterManager {
     /**
-     * The voice server endpoint.
-     * @type {string}
+     * The player this filter manager belongs to.
+     * @type {PlayerStructure}
+     * @public
+     * @readonly
      */
-    endpoint: string;
+    readonly player: PlayerStructure;
     /**
-     * The voice server session id.
-     * @type {string}
+     * The bands applied to the player.
+     * @type {EQBandSettings[]}
+     * @readonly
      */
-    sessionId: string;
+    readonly bands: EQBandSettings[];
     /**
-     * The voice server guild id.
-     * @type {string | undefined}
+     * The current filter settings applied to the player.
+     * @type {FilterSettings}
+     * @public
      */
-    connected?: boolean;
+    data: FilterSettings;
     /**
-     * The voice server ping.
-     * @type {number | undefined}
+     * The enabled filters for the player.
+     * @type {EnabledPlayerFilters}
      */
-    ping?: number;
-}
-/**
- * The JSON representation of the player.
- */
-interface PlayerJson {
+    filters: EnabledPlayerFilters;
     /**
-     * The guild id of the player.
-     * @type {string}
+     * The lavalink plugin filters manager.
+     * @type {LavalinkPluginFilter}
+     * @readonly
      */
-    guildId: string;
+    readonly plugin: LavalinkPluginFilter;
     /**
-     * The volume of the player.
-     * @type {number}
-     */
-    volume: number;
-    /**
-     * The self deaf state of the player.
-     * @type {boolean}
-     */
-    selfDeaf: boolean;
-    /**
-     * The self mute state of the player.
-     * @type {boolean}
-     */
-    selfMute: boolean;
-    /**
-     * The voice settings for the player.
-     * @type {LavalinkPlayerVoice}
-     */
-    voice: Nullable<LavalinkPlayerVoice>;
-    /**
-     * The loop mode of the player.
-     * @type {LoopMode}
-     */
-    loop: LoopMode;
-    /**
-     * The options for the player.
-     * @type {boolean}
-     */
-    options: PlayerOptions;
-    /**
-     * The paused state of the player.
-     * @type {boolean}
-     */
-    paused: boolean;
-    /**
-     * The playing state of the player.
-     * @type {boolean}
-     */
-    playing: boolean;
-    /**
-     * The voice channel id of the player.
-     * @type {string}
-     */
-    voiceId?: string;
-    /**
-     * The text channel id of the player.
-     * @type {string | undefined}
+     * The DSPX plugin filters manager.
+     * @type {DSPXPluginFilter}
+     * @readonly
      */
-    textId?: string;
+    readonly dspx: DSPXPluginFilter;
     /**
-     * The last position received from Lavalink.
-     * @type {number}
+     *
+     * Creates a new filter manager.
+     * @param {PlayerStructure} player The player this filter manager belongs to.
      */
-    lastPosition: number;
+    constructor(player: PlayerStructure);
     /**
-     * The timestamp when the last position change update happened.
-     * @type {number | null}
+     * Resets all filters to their default values.
+     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
+     * @example
+     * ```ts
+     * // Reset all filters
+     * await player.filterManager.reset();
+     * ```
      */
-    lastPositionUpdate: number | null;
+    reset(): Promise<this>;
     /**
-     * The current calculated position of the player.
-     * @type {number}
+     *
+     * Applies the current filters to the player.
+     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
+     * @example
+     * ```ts
+     * // Apply the current filters
+     * await player.filterManager.apply();
+     * ```
      */
-    position: number;
+    apply(): Promise<this>;
     /**
-     * The timestamp when the player was created.
-     * @type {number}
+     * Checks if the current filters are active.
+     * @param {TimescaleSettings} timescale The timescale settings to check against.
+     * @returns {void} Nothing!
+     * @example
+     * ```ts
+     * // Check the current filters
+     * player.filterManager.check();
+     * ```
      */
-    createdTimestamp: number;
+    check(timescale?: TimescaleSettings): void;
     /**
-     * The ping of the player.
-     * @type {number}
+     *
+     * Checks if a specific filter is active.
+     * @param {FilterType} filter The filter type to check.
+     * @returns {boolean} True if the filter is active, false otherwise.
+     * @example
+     * ```ts
+     * // Check if the nightcore filter is active
+     * const isNightcoreActive = player.filterManager.has(FilterType.Nightcore);
+     * console.log(isNightcoreActive); // true or false
+     * ```
      */
-    ping: number;
+    has(filter: FilterType): boolean;
     /**
-     * The queue of the player.
-     * @type {QueueJson}
+     *
+     * Sets the volume for the player.
+     * @param {number} volume The volume level to set (between 0 and 5).
+     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * @throws {PlayerError} If the volume is not a number between 0 and 5.
+     * @example
+     * ```ts
+     * // Set the volume to 2.5
+     * await player.filterManager.setVolume(2.5);
+     * ```
      */
-    queue: QueueJson;
+    setVolume(volume: number): Promise<this>;
     /**
-     * The node of the player.
-     * @type {NodeJson}
+     * Sets the audio output for the player.
+     * @param {AudioOutput} output The audio output to set.
+     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * @throws {PlayerError} If the output is not a valid AudioOutput value.
+     * @example
+     * ```ts
+     * // Set the audio output to mono
+     * await player.filterManager.setAudioOutput(AudioOutput.Mono);
+     * ```
      */
-    node: NodeJson;
+    setAudioOutput(output: AudioOutput): Promise<this>;
     /**
-     * The filter settings of the player.
-     * @type {FilterSettings}
+     *
+     * Sets the speed for the player.
+     * @param {number} speed The speed to set (default is 1).
+     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * @throws {PlayerError} If the node does not support the timescale filter.
+     * @example
+     * ```ts
+     * // Set the speed to 1.5
+     * await player.filterManager.setSpeed(1.5);
+     * ```
      */
-    filters: FilterSettings;
-}
-/**
- * The lyrics methods for the player.
- */
-interface LyricsMethods {
+    setSpeed(speed?: number): Promise<this>;
     /**
      *
-     * 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.
+     * Sets the rate for the player.
+     * @param {number} rate The rate to set (default is 1).
+     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * @throws {PlayerError} If the node does not support the timescale filter.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const lyrics = await player.lyricsManager.current();
+     * // Set the rate to 1.2
+     * await player.filterManager.setRate(1.2);
      * ```
      */
-    current(skipSource?: boolean): Promise<LyricsResult | null>;
+    setRate(rate?: number): Promise<this>;
     /**
      *
-     * 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.
+     * Sets the pitch for the player.
+     * @param {number} pitch The pitch
+     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * @throws {PlayerError} If the node does not support the timescale filter.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const track = player.queue.current;
-     * const lyrics = await player.lyrics.get(track);
+     * // Set the pitch to 0.8
+     * await player.filterManager.setPitch(0.8);
      * ```
      */
-    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    setPitch(pitch?: number): Promise<this>;
     /**
      *
-     * 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!
+     * Sets the EQ bands for the player.
+     * @param {RestOrArray<EQBandSettings>} bands The EQ band settings to set.
+     * @returns {Promise<this>} A promise that resolves to the instance of the manager.
+     * @throws {PlayerError} If the bands array is empty or contains invalid band settings.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * await player.lyrics.subscribe();
+     * // Set multiple EQ bands
+     * await player.filterManager.setEQBand(
+     *   { band: 0, gain: 0.5 },
+     *   { band: 1, gain: -0.3 },
+     * );
      * ```
      */
-    subscribe(skipSource?: boolean): Promise<void>;
+    setEQBand(...bands: RestOrArray<EQBandSettings>): Promise<this>;
     /**
      *
-     * Unsubscribe from the lyrics for a specific guild.
-     * @returns {Promise<void>} Let's stop the sing session!
+     * Clears all EQ bands for the player.
+     * @returns {Promise<this>} A promise that resolves to the instance of the manager.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * await player.lyrics.unsubscribe();
+     * // Clear all EQ bands
+     * await player.filterManager.clearEQBands();
      * ```
      */
-    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 {
+    clearEQBands(): Promise<this>;
     /**
-     * The node instance.
-     * @type {NodeStructure}
-     * @readonly
+     *
+     * Set the vibrato filter with the given settings.
+     * @param {TremoloSettings} [settings=DefaultFilterPreset.Vibrato] The settings for the vibrato filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the vibrato filter.
+     * @example
+     * ```ts
+     * // Set the vibrato filter
+     * await player.filterManager.setVibrato({ frequency: 4.0, depth: 0.5 });
+     * ```
      */
-    readonly node: NodeStructure;
+    setVibrato(settings?: Partial<TremoloSettings>): Promise<this>;
     /**
-     * Create a new LyricsManager instance.
-     * @param {NodeStructure} node The node instance.
+     *
+     * Set the tremolo filter with the given settings.
+     * @param {TremoloSettings} [settings=DefaultFilterPreset.Tremolo] The settings for the tremolo filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the tremolo filter.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * const lyricsManager = new LyricsManager(node);
+     * // Set the tremolo filter
+     * await player.filterManager.setTremolo({ frequency: 4.0, depth: 0.5 });
      * ```
      */
-    constructor(node: NodeStructure);
+    setTremolo(settings?: Partial<TremoloSettings>): Promise<this>;
     /**
      *
-     * 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.
+     * Set the low-pass filter with the given settings.
+     * @param {LowPassSettings} [settings=DefaultFilterPreset.Lowpass] The settings for the low-pass filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the low-pass filter.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const lyrics = await player.lyricsManager.current();
+     * // Set the low-pass filter
+     * await player.filterManager.setLowPass({ smoothing: 20.0 });
      * ```
      */
-    current(guildId: string, skipSource?: boolean): Promise<LyricsResult | null>;
+    setLowPass(settings?: Partial<LowPassSettings>): Promise<this>;
     /**
-     *
-     * 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.
+     * Set the nightcore filter with the given settings.
+     * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Nightcore] The settings for the nightcore filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the timescale filter.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * const lyrics = await node.lyricsManager.get(track);
+     * // Set the nightcore filter
+     * await player.filterManager.setNightcore();
      * ```
      */
-    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    setNightcore(settings?: Partial<TimescaleSettings>): Promise<this>;
     /**
      *
-     * 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!
+     * Set the vaporwave filter with the given settings.
+     * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Vaporwave] The settings for the vaporwave filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the timescale filter.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * await node.lyricsManager.subscribe("guildId");
+     * // Set the vaporwave filter
+     * await player.filterManager.setVaporwave();
      * ```
      */
-    subscribe(guildId: string, skipSource?: boolean): Promise<void>;
+    setVaporwave(settings?: Partial<TimescaleSettings>): Promise<this>;
     /**
      *
-     * 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!
+     * Set the karaoke filter with the given settings.
+     * @param {KaraokeSettings} [settings=DefaultFilterPreset.Karaoke] The settings for the karaoke filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the karaoke filter.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("nodeId");
-     * await node.lyricsManager.unsubscribe("guildId");
+     * // Set the karaoke filter
+     * await player.filterManager.setKaraoke({ level: -15.0, monoLevel: -20.0, filterBand: 220.0, filterWidth: 100.0 });
      * ```
      */
-    unsubscribe(guildId: string): Promise<void>;
-}
-
-/**
- * Represents a collection that extends the built-in Map class.
- * @template K The type of the keys in the collection.
- * @template V The type of the values in the collection.
- */
-declare class Collection<K, V> extends Map<K, V> {
-    /**
-     * Removes elements from the collection based on a filter function.
-     * @param fn The filter function that determines which elements to remove.
-     * @param thisArg The value to use as `this` when executing the filter function.
-     * @returns The number of elements removed from the collection.
-     * @example
-     * const collection = new Collection<number, string>();
-     * collection.set(1, 'one');
-     * collection.set(2, 'two');
-     * collection.set(3, 'three');
-     * const removedCount = collection.sweep((value, key) => key % 2 === 0);
-     * console.log(removedCount); // Output: 1
-     * console.log(collection.size); // Output: 2
-     */
-    sweep(fn: (value: V, key: K, collection: this) => unknown): number;
+    setKaraoke(settings?: Partial<KaraokeSettings>): Promise<this>;
     /**
-     * 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.
+     *
+     * Set the distortion filter with the given settings.
+     * @param {Partial<DistortionSettings>} [settings=DefaultFilterPreset.Distortion] The settings for the distortion filter.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the distortion filter.
      * @example
-     * 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']
+     * ```ts
+     * // Set the distortion filter
+     * await player.filterManager.setDistortion({ sinOffset: 0.5, sinScale: 2.0 });
+     * ```
      */
-    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    setDistortion(settings?: Partial<DistortionSettings>): 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.
+     * Set the timescale filter with the given settings.
+     * @param {Partial<TimescaleSettings>} settings The timescale settings to set.
+     * @returns {Promise<this>} The instance of the filter manager.
+     * @throws {PlayerError} If the node does not support the timescale filter.
      * @example
-     * 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']
+     * ```ts
+     * // Set the timescale filter
+     * await player.filterManager.setTimescale({ speed: 1.2, pitch: 0.8, rate: 1.0 });
+     * ```
      */
-    filter(fn: (value: V, key: K, collection: this) => boolean): V[];
+    setTimescale(settings: Partial<TimescaleSettings>): Promise<this>;
     /**
-     * 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.
+     * Convert the filter settings to a JSON object.
+     * @returns {FilterSettings} The filter settings as a JSON object.
      * @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
+     * ```ts
+     * // Convert filter settings to JSON
+     * const filterSettingsJSON = player.filterManager.toJSON();
+     * console.log(filterSettingsJSON); // { volume: 1, equalizer: [...], ... }
+     * ```
      */
-    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+    toJSON(): FilterSettings;
 }
 
 /**
- * Class representing a node manager.
- * @class NodeManager
+ * Type representing a nullable voice channel update.
  */
-declare class NodeManager {
+type NullableVoiceChannelUpdate = Partial<Nullable<VoiceChannelUpdate>>;
+/**
+ * Class representing a Hoshimi player.
+ * @class Player
+ */
+declare class Player {
     /**
-     * The manager for the node.
+     * The data for the player.
+     * @type {PlayerStorageAdapter}
+     * @readonly
+     */
+    readonly data: PlayerStorageAdapter;
+    /**
+     * The options for the player.
+     * @type {PlayerOptions}
+     * @readonly
+     */
+    readonly options: PlayerOptions;
+    /**
+     * The manager for the player.
      * @type {Hoshimi}
      * @readonly
      */
     readonly manager: Hoshimi;
     /**
-     * The nodes for the manager.
-     * @type {Collection<string, Node>}
+     * The queue for the player.
+     * @type {Queue}
      * @readonly
      */
-    readonly nodes: Collection<string, NodeStructure>;
+    readonly queue: QueueStructure;
+    /**
+     * The filter manager for the player.
+     * @type {FilterManager}
+     * @readonly
+     */
+    readonly filterManager: FilterManager;
+    /**
+     * The node for the player.
+     * @type {NodeStructure}
+     */
+    node: NodeStructure;
+    /**
+     * Check if the player is self deafened.
+     * @type {boolean}
+     */
+    selfDeaf: boolean;
+    /**
+     * Check if the player is self muted.
+     * @type {boolean}
+     */
+    selfMute: boolean;
+    /**
+     * Loop mode of the player.
+     * @type {LoopMode}
+     * @default LoopMode.Off
+     */
+    loop: LoopMode;
+    /**
+     * Check if the player is playing.
+     * @type {boolean}
+     * @default false
+     */
+    playing: boolean;
+    /**
+     * Check if the player is paused.
+     * @type {boolean}
+     * @default false
+     */
+    paused: boolean;
+    /**
+     * Check if the player is connected.
+     * @type {boolean}
+     * @default false
+     */
+    connected: boolean;
+    /**
+     * Volume of the player.
+     * @type {number}
+     * @default 100
+     */
+    volume: number;
+    /**
+     * Guild ig of the player.
+     * @type {string}
+     */
+    guildId: string;
+    /**
+     * Voice channel idof the player.
+     * @type {string | undefined}
+     */
+    voiceId: string | undefined;
+    /**
+     * Text channel id of the player.
+     * @type {string | undefined}
+     */
+    textId: string | undefined;
+    /**
+     * The ping of the player.
+     * @type {number}
+     */
+    ping: number;
+    /**
+     * The timestamp when the player was created.
+     * @type {number}
+     */
+    createdTimestamp: number;
+    /**
+     * The last position received from Lavalink.
+     * @type {number}
+     */
+    lastPosition: number;
+    /**
+     * The timestamp when the last position change update happened.
+     * @type {number | null}
+     */
+    lastPositionUpdate: number | null;
+    /**
+     * The current calculated position of the player.
+     * @type {number}
+     * @readonly
+     */
+    get position(): number;
+    /**
+     * The voice connection details.
+     * @type {PlayerVoice}
+     */
+    voice: Nullable<LavalinkPlayerVoice>;
     /**
      *
-     * The constructor for the node manager.
-     * @param {Hoshimi} manager The manager for the node.
+     * Create a new player.
+     * @param {Hoshimi} manager The manager for the player.
+     * @param {PlayOptions} options The options for the player.
      * @example
      * ```ts
-     * const manager = new Hoshimi();
-     * const nodeManager = new NodeManager(manager);
+     * const player = new Player(manager, {
+     * 	guildId: "guildId",
+     * 	voiceId: "voiceId",
+     * 	textId: "textId",
+     * 	selfDeaf: true,
+     * 	selfMute: false,
+     * 	volume: 100,
+     * });
      *
-     * console.log(nodeManager.nodes.size); // 0
+     * console.log(player.guildId); // guildId
+     * console.log(player.voiceId); // voiceId
+     * console.log(player.textId); // textId
+     */
+    constructor(manager: Hoshimi, options: PlayerOptions);
+    /**
+     * The lyrics methods for the player.
+     * @type {LyricsMethods}
+     * @readonly
+     */
+    readonly lyrics: LyricsMethods;
+    /**
+     *
+     * Check if the player is currently playing a track.
+     * @returns {boolean} Whether the player is currently playing a track.
+     */
+    isPlaying(): boolean;
+    /**
+     *
+     * Search for a track or playlist.
+     * @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
      * ```
      */
-    constructor(manager: Hoshimi);
+    search(options: SearchOptions): Promise<QueryResult>;
     /**
      *
-     * Delete the node.
-     * @param {NodeIdentifier} node The node or node id to delete.
-     * @returns {boolean} If the node was deleted.
+     * 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 node = manager.nodeManager.get("node1");
-     * if (node) manager.nodeManager.delete(node.id); // true if the node was deleted
+     * const player = manager.getPlayer("guildId");
+     * player.skip(2); // skip 2 tracks
+     * player.skip(); // skip 1 track
      * ```
      */
-    delete(node: NodeIdentifier): boolean;
+    skip(to?: number, throwError?: boolean): Promise<void>;
     /**
      *
-     * 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.
+     * 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 node = manager.nodeManager.get("node1");
-     * if (node) {
-     * 	console.log(node.id); // node1
-     * } else {
-     * 	console.log("Node not found");
-     * }
+     * const player = manager.getPlayer("guildId");
+     * player.seek(30000); // seek to 30 seconds
      * ```
      */
-    get(node: NodeIdentifier): NodeStructure | undefined;
+    seek(position: number): Promise<void>;
     /**
      *
-     * Create a new node.
-     * @param {NodeOptions} options The options for the node.
-     * @returns {NodeStructure} The created node.
+     * Disconnect the player from the voice channel.
+     * @returns {Promise<this>} The player instance.
      * @example
      * ```ts
-     * const node = manager.nodeManager.create({
-     * 	host: "localhost",
-     * 	port: 2333,
-     * 	password: "password",
-     * 	secure: false,
+     * const player = manager.getPlayer("guildId");
+     * player.disconnect();
+     * ```
+     */
+    disconnect(): Promise<this>;
+    /**
+     *
+     * 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);
+     * ```
+     */
+    destroy(reason?: DestroyReasons): Promise<boolean>;
+    /**
+     *
+     * 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,
      * });
+     * ```
+     */
+    play(options?: Partial<PlayOptions>): Promise<void>;
+    /**
+     * Connect the player to the voice channel.
+     * @returns {Promise<this>} The player instance.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.connect();
+     * ```
+     */
+    connect(): Promise<this>;
+    /**
      *
-     * console.log(node.id); // localhost:2333
+     * 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();
+     * ```
      */
-    create(options: NodeOptions): NodeStructure;
+    stop(destroy?: boolean): Promise<void>;
     /**
      *
-     * Destroy a node.
-     * @param {NodeIdentifier} node The node or node id to destroy.
-     * @returns {void}
+     * Pause or resume the player.
+     * @returns {Promise<void>}
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * player.setPaused();
+     * ```
+     */
+    setPaused(paused?: boolean): Promise<boolean>;
+    /**
+     *
+     * 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%
+     * ```
+     */
+    setVolume(volume: number): Promise<void>;
+    /**
+     *
+     * 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);
+     * ```
+     */
+    setLoop(mode: LoopMode): this;
+    /**
+     * 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" });
+     * ```
+     */
+    setVoice(options?: NullableVoiceChannelUpdate): Promise<void>;
+    /**
+     *
+     * 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");
+     * ```
+     */
+    move(node: NodeIdentifier): Promise<void>;
+    /**
+     * Update the player with new data.
+     * @param {NonGuildUpdatePlayerInfo} data The data to update the player with.
+     * @returns {Promise<LavalinkPlayer | null>} The updated player data.
+     * @example
+     * ```ts
+     * const player = manager.getPlayer("guildId");
+     * const updatedPlayer = await player.updatePlayer({ volume: 50 });
+     * console.log(updatedPlayer); // the updated player data
+     * ```
+     */
+    updatePlayer(data: NonGuildUpdatePlayerInfo): Promise<LavalinkPlayer | null>;
+    /**
+     *
+     * 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
+     * ```
+     */
+    toJSON(): PlayerJson;
+}
+/**
+ * Type representing the update player information without guildId.
+ */
+type NonGuildUpdatePlayerInfo = Omit<UpdatePlayerInfo, "guildId">;
+/**
+ * Interface representing the customizable player storage.
+ */
+interface CustomizablePlayerStorage {
+}
+
+/**
+ * Type representing the customizable player storage.
+ */
+type StorageKeys = keyof CustomizablePlayerStorage | (string & {});
+/**
+ * Type representing the customizable player storage values.
+ */
+type StorageValues<V extends StorageKeys = StorageKeys> = V extends keyof CustomizablePlayerStorage ? CustomizablePlayerStorage[V] : unknown;
+/**
+ * Class representing a player storage adapter.
+ * @abstract
+ * @class PlayerStorageAdapter
+ * @example
+ * ```ts
+ * class MyPlayerStorageAdapter extends PlayerStorageAdapter {};
+ *
+ * const storage = new MyPlayerStorageAdapter();
+ * await storage.set("key", "value");
+ *
+ * const value = await storage.get("key");
+ * console.log(value); // "value"
+ * ```
+ */
+declare abstract class PlayerStorageAdapter {
+    /**
+     * The namespace of the storage.
+     * @type {string}
+     * @default "hoshimiplayer"
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.destroy();
+     * console.log(storage.namespace); // "hoshimiplayer"
      * ```
      */
-    destroy(node: NodeIdentifier): void;
+    namespace: string;
     /**
      *
-     * Reconnect a node.
-     * @param {NodeIdentifier} node The node or node id to reconnect.
-     * @returns {void}
+     * 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 node = manager.nodeManager.get("node1");
-     * if (node) node.reconnect();
+     * const value = await storage.get("key");
+     * console.log(value); // "value"
      * ```
      */
-    reconnect(node: NodeIdentifier): void;
+    abstract get<K extends StorageKeys, V extends StorageValues<K>>(key: K): Awaitable<V | undefined>;
     /**
      *
-     * Disconnect a node.
-     * @param {NodeIdentifier} node The node or node id to disconnect.
-     * @returns {void}
+     * 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("node1");
-     * if (node) node.disconnect();
+     * await storage.set("key", "value");
      * ```
      */
-    disconnect(node: NodeIdentifier): void;
+    abstract set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): Awaitable<void>;
     /**
      *
-     * Connect a node.
-     * @param {NodeIdentifier} node The node or node id to connect.
-     * @returns {void}
+     * Delete the value using the key.
+     * @param {string} key The key to delete the value from.
+     * @returns {Awaitable<boolean>} Returns true if the key was deleted.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.connect();
+     * const success = await storage.delete("key");
+     * console.log(success); // true
      * ```
      */
-    connect(node: NodeIdentifier): void;
+    abstract delete<K extends StorageKeys>(key: K): Awaitable<boolean>;
     /**
-     *
-     * Get the least used node.
-     * @returns {NodeStructure} The least used node.
+     * Clear the storage.
+     * @returns {Awaitable<void>} Scary, right?
      * @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
-     * }
+     * await storage.clear();
      * ```
      */
-    getLeastUsed(sortType?: NodeSortTypes): NodeStructure;
+    abstract clear(): Awaitable<void>;
     /**
-     *
-     * Reconnect the nodes.
-     * @returns {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 node = manager.nodeManager.get("node1");
-     * if (node) node.reconnectAll();
+     * const exists = await storage.has("key");
+     * console.log(exists); // true
      * ```
      */
-    reconnectAll(): void;
+    abstract has<K extends StorageKeys>(key: K): Awaitable<boolean>;
     /**
-     * Disconnect the nodes.
-     * @returns {void}
+     * Get all keys in the storage.
+     * @returns {Awaitable<K[]>} The keys in the storage.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.disconnectAll();
+     * const keys = await storage.keys();
+     * console.log(keys); // ["key1", "key2"]
      * ```
      */
-    disconnectAll(): void;
+    abstract keys<K extends StorageKeys[]>(): Awaitable<K[]>;
     /**
-     * Connect the nodes.
-     * @returns {void}
+     * Get all values in the storage.
+     * @returns {Awaitable<V[]>} The values in the storage.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.connect();
+     * const values = await storage.values();
+     * console.log(values); // ["value1", "value2"]
      * ```
      */
-    connectAll(): void;
+    abstract values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<V[]>;
     /**
-     * Destroy the nodes.
-     * @returns {void}
+     * Get all entries in the storage.
+     * @returns {Awaitable<[K, V][]>} The entries in the storage.
      * @example
      * ```ts
-     * const node = manager.nodeManager.get("node1");
-     * if (node) node.destroy();
+     * const entries = await storage.entries();
+     * console.log(entries); // [["key1", "value1"], ["key2", "value2"]]
      * ```
      */
-    destroyAll(): void;
-}
-
-/**
- * The methods for http requests
- */
-declare enum HttpMethods {
-    /**
-     * The GET method requests a representation of the specified resource. Requests using GET should only retrieve data.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET
-     * @type {string}
-     */
-    Get = "GET",
-    /**
-     * The POST method is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST
-     * @type {string}
-     */
-    Post = "POST",
-    /**
-     * The PUT method replaces all current representations of the target resource with the request payload.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT
-     * @type {string}
-     */
-    Put = "PUT",
-    /**
-     * The PATCH method is used to apply partial modifications to a resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH
-     * @type {string}
-     */
-    Patch = "PATCH",
-    /**
-     * The DELETE method deletes the specified resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE
-     * @type {string}
-     */
-    Delete = "DELETE",
+    abstract entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<[K, V][]>;
     /**
-     * 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}
+     * Get all key-value pairs in the storage.
+     * @returns {Awaitable<Record<K[number], V>>} An object containing all key-value pairs in the storage, excluding internal keys.
+     * @example
+     * ```ts
+     * const all = await storage.all();
+     * console.log(all); // { key1: "value1", key2: "value2" }
+     * ```
      */
-    Head = "HEAD"
-}
-declare enum RestPathType {
+    abstract all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<Record<K[number], V>>;
     /**
-     * The raw path of the request.
-     * @type {string}
+     * Get the size of the storage.
+     * @returns {Awaitable<number>} The size of the storage.
+     * @example
+     * ```ts
+     * const size = await storage.size();
+     * console.log(size); // 2
+     * ```
      */
-    Raw = "/",
+    abstract size(): Awaitable<number>;
     /**
-     * The versioned path v4 of the request.
-     * @type {string}
+     *
+     * Build a key from the given parts.
+     * @param {string[]} parts The parts to build the key from.
+     * @returns {string} The built key.
+     * @example
+     * ```ts
+     * const key = storage.buildKey("part1", "part2", "part3");
+     * ```
      */
-    V4 = "/v4"
+    abstract buildKey(...parts: RestOrArray<string>): string;
 }
+
 /**
- * The status codes for the REST.
- * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+ * 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 enum HttpStatusCodes {
-    /**
-     * The request has succeeded.
-     * @type {number}
-     */
-    OK = 200,
-    /**
-     * The request has been fulfilled and resulted in a new resource being created.
-     * @type {number}
-     */
-    Created = 201,
-    /**
-     * The request has been accepted for processing, but the processing has not been completed.
-     * @type {number}
-     */
-    Accepted = 202,
-    /**
-     * The server successfully processed the request, but is not returning any content.
-     * @type {number}
-     */
-    NoContent = 204,
-    /**
-     * The resource has been moved permanently to a new URI.
-     * @type {number}
-     */
-    MovedPermanently = 301,
-    /**
-     * The requested resource has been found at a different URI.
-     * @type {number}
-     */
-    Found = 302,
-    /**
-     * The resource has not been modified since the last request.
-     * @type {number}
-     */
-    NotModified = 304,
-    /**
-     * The request cannot be processed due to bad syntax.
-     * @type {number}
-     */
-    BadRequest = 400,
-    /**
-     * The request requires user authentication.
-     * @type {number}
-     */
-    Unauthorized = 401,
-    /**
-     * The request was valid, but the server is refusing action.
-     * @type {number}
-     */
-    Forbidden = 403,
-    /**
-     * The server cannot find the requested resource.
-     * @type {number}
-     */
-    NotFound = 404,
-    /**
-     * The request method is known by the server but has been disabled and cannot be used.
-     * @type {number}
-     */
-    MethodNotAllowed = 405,
+declare abstract class QueueStorageAdapter<T extends QueueJson = QueueJson> {
     /**
-     * The server timed out waiting for the request.
-     * @type {number}
+     * The namespace of the storage.
+     * @type {string}
+     * @default "hoshimiqueue"
+     * @example
+     * ```ts
+     * console.log(storage.namespace); // "hoshimiqueue"
+     * ```
      */
-    RequestTimeout = 408,
+    namespace: string;
     /**
-     * The request could not be completed due to a conflict with the current state of the resource.
-     * @type {number}
+     *
+     * 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"
+     * ```
      */
-    Conflict = 409,
+    abstract get(key: string): Awaitable<T | undefined>;
     /**
-     * The requested resource is no longer available and will not be available again.
-     * @type {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");
+     * ```
      */
-    Gone = 410,
+    abstract set(key: string, value: T): Awaitable<void>;
     /**
-     * The user has sent too many requests in a given amount of time.
-     * @type {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
+     * ```
      */
-    TooManyRequests = 429,
+    abstract delete(key: string): Awaitable<boolean>;
     /**
-     * A generic error message, given when no more specific message is suitable.
-     * @type {number}
+     * Clear the storage.
+     * @returns {Awaitable<void>} Scary, right?
+     * @example
+     * ```ts
+     * await storage.clear();
+     * ```
      */
-    InternalServerError = 500,
+    abstract clear(): Awaitable<void>;
     /**
-     * The server does not recognize the request method or lacks the ability to fulfill it.
-     * @type {number}
+     * 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
+     * ```
      */
-    NotImplemented = 501,
+    abstract has(key: string): Awaitable<boolean>;
     /**
-     * The server was acting as a gateway and received an invalid response.
-     * @type {number}
+     *
+     * Parse the value.
+     * @param {unknown} value The value to parse.
+     * @returns {T} The parsed value.
+     * @example
+     * ```ts
+     * const parsed = await storage.parse<{ key: string }>("{'key':'value'}");
+     * console.log(parsed); // { key: "value" }
+     * ```
      */
-    BadGateway = 502,
+    abstract parse(value: unknown): Awaitable<T>;
     /**
-     * The server is currently unavailable (overloaded or down).
-     * @type {number}
+     *
+     * Stringify the value.
+     * @param {unknown} value The value to stringify.
+     * @returns {R} The stringified value.
+     * @example
+     * ```ts
+     * const stringified = await storage.stringify({ key: "value" });
+     * console.log(stringified); // "{'key':'value'}"
+     * ```
      */
-    ServiceUnavailable = 503,
+    abstract stringify<R = string>(value: unknown): Awaitable<R>;
     /**
-     * The server did not receive a timely response from an upstream server.
-     * @type {number}
+     *
+     * Build a key from the given parts.
+     * @param {string[]} parts The parts to build the key from.
+     * @returns {string} The built key.
+     * @example
+     * ```ts
+     * const key = storage.buildKey("part1", "part2", "part3");
+     * ```
      */
-    GatewayTimeout = 504
+    abstract buildKey(...parts: RestOrArray<string>): string;
 }
+
 /**
- * The options for the REST.
+ * The queue options.
  */
-interface RestOptions {
-    /**
-     * The endpoint for the REST.
-     * @type {string}
-     */
-    endpoint: `/${string}`;
-    /**
-     * The method for the REST.
-     * @type {HttpMethods}
-     */
-    method?: HttpMethods;
+interface HoshimiQueueOptions {
     /**
-     * The headers for the REST.
-     * @type {Record<string, string>}
+     * The maximum amount of tracks that can be saved in the queue.
+     * @type {number}
+     * @default 25
      */
-    headers?: Record<string, string>;
+    maxHistory?: number;
     /**
-     * The body for the REST.
-     * @type {Record<string, unknown> | string | undefined}
+     *
+     * The function to use for autoplay.
+     * @param {Player} player The player.
+     * @param {HoshimiTrack | null} lastTrack The last track played.
      */
-    body?: Record<string, unknown> | string;
+    autoplayFn?(player: PlayerStructure, lastTrack: HoshimiTrack | null): Awaitable<void>;
     /**
-     * The query parameters for the REST.
-     * @type {Record<string, string>}
+     * Enable the auto play for the queue. (By default, only supports `youtube` and `spotify`, add more with your own function)
+     * @type {boolean}
+     * @default false
      */
-    params?: Record<string, string>;
+    autoPlay?: boolean;
     /**
-     * The path type for the REST.
-     * @type {RestPathType}
+     * The storage manager to use for the queue.
+     * @type {QueueStorageAdapter}
+     * @default {MemoryAdapter}
      */
-    pathType?: RestPathType;
+    storage?: QueueStorageAdapter;
 }
 /**
- * The fetch options for the request.
+ * The queue json.
  */
-interface FetchOptions extends Omit<RestOptions, "endpoint" | "body"> {
+interface QueueJson {
     /**
-     * The signal for the request.
+     * The tracks of the queue.
+     * @type {HoshimiTrack[]}
      */
-    signal: AbortSignal;
+    tracks: HoshimiTrack[];
     /**
-     * The stringified body for the request.
+     * The previous tracks of the queue.
+     * @type {Track[]}
      */
-    body?: string;
+    history: Track[];
+    /**
+     * The current track of the queue.
+     * @type {Track | null}
+     */
+    current: Track | null;
 }
+
 /**
- * The error for the REST.
+ * Partial Lavalink track type.
  */
-interface LavalinkRestError {
+type PartialLavalinkTrack = Partial<Nullable<LavalinkTrack>>;
+/**
+ * The base options for playing a track.
+ */
+interface BasePlayOptions {
     /**
-     * The timestamp for the REST.
-     * @type {number}
+     * The position to start the track.
+     * @type {number | undefined}
      */
-    timestamp: number;
+    position?: number;
     /**
-     * The status for the REST.
-     * @type {number}
+     * The position to end the track.
+     * @type {number | undefined}
      */
-    status: number;
+    endTime?: number;
     /**
-     * The error for the REST.
-     * @type {string}
+     * The pause state of the player.
+     * @type {boolean | undefined}
      */
-    error: string;
+    paused?: boolean;
     /**
-     * The trace for the REST.
-     * @type {string}
+     * The volume of the player.
+     * @type {number | undefined}
      */
-    trace?: string;
+    volume?: number;
     /**
-     * The message for the REST.
-     * @type {string}
+     * The filters for the player.
+     * @type {Partial<FilterSettings> | undefined}
      */
-    message: string;
+    filters?: Partial<FilterSettings>;
     /**
-     * The path for the REST.
-     * @type {string}
+     * The voice settings for the player.
+     * @type {LavalinkPlayerVoice | undefined}
      */
-    path: string;
+    voice?: LavalinkPlayerVoice;
 }
 /**
- * The player response from the Lavalink REST API.
+ * The types of loop modes.
  */
-interface LavalinkPlayer {
+declare enum LoopMode {
     /**
-     * The guild ID associated with the player.
-     * @type {string}
+     * Loop mode for repeating the current track.
      */
-    guildId: string;
+    Track = 1,
     /**
-     * The track currently being played.
-     * @type {LavalinkTrack}
+     * Loop mode for repeating the queue.
      */
-    track?: LavalinkTrack;
+    Queue = 2,
     /**
-     * The volume of the player.
-     * @type {number}
+     * Loop mode for repeating nothing.
      */
-    volume: number;
+    Off = 3
+}
+/**
+ * The types of player events.
+ */
+declare enum PlayerEventType {
     /**
-     * Whether the player is paused.
-     * @type {boolean}
+     * Event type for when a track starts.
      */
-    paused: boolean;
+    TrackStart = "TrackStartEvent",
     /**
-     * The voice connection details.
-     * @type {LavalinkPlayerVoice}
+     * Event type for when a track ends.
      */
-    voice: LavalinkPlayerVoice;
+    TrackEnd = "TrackEndEvent",
     /**
-     * The filter options applied to the player.
-     * @type {FilterSettings}
+     * Event type for when a track encounters an exception.
      */
-    filters: FilterSettings;
+    TrackException = "TrackExceptionEvent",
     /**
-     * The state of the player.
-     * @type {LavalinkPlayerState}
+     * Event type for when a track gets stuck.
      */
-    state: LavalinkPlayerState;
-}
-/**
- * The state of the player.
- */
-interface LavalinkPlayerState {
+    TrackStuck = "TrackStuckEvent",
     /**
-     * The time since the connection was established.
-     * @type {number}
+     * Event type for when lyrics are found.
      */
-    time: number;
+    LyricsFound = "LyricsFoundEvent",
     /**
-     * The position of the current track in milliseconds.
-     * @type {number}
+     * Event type for when lyrics are not found.
      */
-    position: number;
+    LyricsNotFound = "LyricsNotFoundEvent",
     /**
-     * Whether the player is connected to the voice channel.
-     * @type {boolean}
+     * Event type for when a lyrics line is sent.
      */
-    connected: boolean;
+    LyricsLine = "LyricsLineEvent",
     /**
-     * The ping to the voice server in milliseconds.
-     * @type {number}
+     * Event type for when the WebSocket connection is closed.
      */
-    ping: number;
+    WebsocketClosed = "WebSocketClosedEvent"
 }
 /**
- * The options to update the player.
+ * The reasons a track can end.
  */
-interface UpdatePlayerInfo {
+declare enum TrackEndReason {
     /**
-     * The guild id associated with the player.
-     * @type {string}
+     * The track ended normally.
      */
-    guildId: string;
+    Finished = "finished",
     /**
-     * The options to update the player.
-     * @type {LavalinkPlayOptions}
+     * The track fails to load.
+     */
+    LoadFailed = "loadFailed",
+    /**
+     * The track was stopped.
+     */
+    Stopped = "stopped",
+    /**
+     * The track was replaced.
      */
-    playerOptions: LavalinkPlayOptions;
+    Replaced = "replaced",
     /**
-     * Whether to replace the current track.
-     * @type {boolean | undefined}
-     * @default false
+     * The track was cleaned up.
      */
-    noReplace?: boolean;
+    Cleanup = "cleanup"
 }
 /**
- * The updated session of the current session.
+ * The options for automatic player error handling.
  */
-interface LavalinkSession {
+interface ErrorPlayerActions {
     /**
-     * Whather the session is resuming.
-     * @type {boolean}
+     * Whether to automatically destroy the player on disconnect or error.
+     * @type {boolean | undefined}
+     * @default false
      */
-    resuming: boolean;
+    autoDestroy?: boolean;
     /**
-     * The timeout for the session.
-     * @type {number}
+     * Whether to automatically skip the track on error
+     * @type {boolean | undefined}
+     * @default false
      */
-    timeout: number;
-}
-/**
- * The rest options.
- */
-interface HoshimiRestOptions {
+    autoSkip?: boolean;
     /**
-     * The amount of time to wait for the player to resume. (in milliseconds)
-     * @type {number}
-     * @default 10000
+     * Whether to automatically stop the player on error.
+     * @type {boolean | undefined}
+     * @default false
      */
-    resumeTimeout?: number;
+    autoStop?: boolean;
 }
 /**
- * The methods for decoding base64 encoded tracks.
+ * The options for error actions.
  */
-interface DecodeMethods {
+interface DisconnectPlayerActions extends Pick<ErrorPlayerActions, "autoDestroy"> {
     /**
-     *
-     * 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 automatically reconnect on disconnect.
+     * @type {boolean | undefined}
+     * @default false
      */
-    single(track: string, requester: TrackRequester): Promise<Track>;
+    autoReconnect?: 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
-     * ```
+     * Whether to automatically add tracks back to the queue on disconnect.
+     * @type {boolean | undefined}
+     * @default false
      */
-    multiple(tracks: string[], requester: TrackRequester): Promise<Track[]>;
+    autoQueue?: boolean;
 }
 /**
- * The session of the node.
- */
-type NullableLavalinkSession = PickNullable<LavalinkSession, "timeout">;
-
-/**
- * Class representing the REST for the node.
- * @class Rest
+ * The Hoshimi player options.
  */
-declare class Rest {
-    /**
-     * The URL for the REST.
-     * @type {string}
-     */
-    readonly url: string;
+interface HoshimiPlayerOptions {
     /**
-     * The version for the REST.
-     * @type {string}
+     *
+     * The function to use to get the requester data.
+     * @param {TrackRequester} requester The requester of the track.
      */
-    readonly version: string;
+    requesterFn?<T extends TrackRequester = TrackRequester>(requester: TrackRequester): Awaitable<T>;
     /**
-     * The timeout for the REST.
-     * @type {number}
+     * The options for handling errors.
+     * @type {ErrorPlayerActions | undefined}
      */
-    readonly restTimeout: number;
+    onError?: ErrorPlayerActions;
     /**
-     * The user agent for the REST.
-     * @type {UserAgent}
+     * The options for handling disconnects.
+     * @type {DisconnectPlayerActions | undefined}
      */
-    readonly userAgent: UserAgent;
+    onDisconnect?: DisconnectPlayerActions;
     /**
-     * The node for the REST.
-     * @type {Node}
+     * The customizable player storage adapter.
+     * @type {PlayerStorageAdapter | undefined}
+     * @default {PlayerMemoryStorage}
      */
-    readonly node: NodeStructure;
+    storage?: PlayerStorageAdapter;
+}
+/**
+ * The base interface for player events.
+ */
+interface PlayerEvent<E extends PlayerEventType> {
     /**
-     *
-     * 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 type of the event.
+     * @type {E}
      */
-    constructor(node: NodeStructure);
+    type: E;
     /**
-     * The REST URL to make requests.
-     * @type {string}
+     * The operation code for the event.
+     * @type {OpCodes.Event}
      */
-    get restUrl(): string;
+    op: OpCodes.Event;
     /**
-     * The session id of the node.
+     * The guild id associated with the event.
      * @type {string}
      */
-    get sessionId(): string;
+    guildId: string;
+}
+/**
+ * The event for when a track starts playing.
+ */
+interface TrackStartEvent extends PlayerEvent<PlayerEventType.TrackStart> {
     /**
-     *
-     * 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 track that started playing.
+     * @type {LavalinkTrack}
      */
-    request<T>(options: RestOptions): Promise<T | null>;
+    track: LavalinkTrack;
+}
+/**
+ * The event for when a track ends.
+ */
+interface TrackEndEvent extends PlayerEvent<PlayerEventType.TrackEnd> {
     /**
-     *
-     * 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 track that ended.
+     * @type {LavalinkTrack}
      */
-    updatePlayer(data: Partial<UpdatePlayerInfo>): Promise<LavalinkPlayer | null>;
+    track: LavalinkTrack;
     /**
-     *
-     * 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 reason the track ended.
+     * @type {TrackEndReason}
      */
-    stopPlayer(guildId: string): Promise<LavalinkPlayer | null>;
+    reason: TrackEndReason;
+}
+/**
+ * The event for when a track gets stuck.
+ */
+interface TrackStuckEvent extends PlayerEvent<PlayerEventType.TrackStuck> {
     /**
-     *
-     * 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 track that got stuck.
+     * @type {LavalinkTrack}
      */
-    destroyPlayer(guildId: string): Promise<void>;
+    track: LavalinkTrack;
     /**
-     *
-     * 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 threshold in milliseconds.
+     * @type {number}
      */
-    updateSession(resuming: boolean, timeout?: number | null): Promise<LavalinkSession | null>;
+    thresholdMs: number;
 }
-
 /**
- * Class representing the DSPX Plugin filters for a player.
- * @class DSPXPluginFilter
+ * The event for when a track encounters an exception.
  */
-declare class DSPXPluginFilter {
+interface TrackExceptionEvent extends PlayerEvent<PlayerEventType.TrackException> {
     /**
-     * The filter manager instance.
-     * @type {FilterManagerStructure}
-     * @readonly
+     * The exception that occurred.
+     * @type {Exception}
      */
-    readonly manager: FilterManagerStructure;
+    exception: Exception;
+}
+/**
+ * The event for when the WebSocket connection is closed.
+ */
+interface WebSocketClosedEvent extends PlayerEvent<PlayerEventType.WebsocketClosed> {
     /**
-     * Create a new DSPXPluginFilter instance.
-     * @param {FilterManagerStructure} manager The filter manager instance.
+     * The close code.
+     * @type {number}
      */
-    constructor(manager: FilterManagerStructure);
+    code: number;
     /**
-     *
-     * 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.
+     * Whether the connection was closed by the remote.
+     * @type {boolean}
      */
-    setLowPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
+    byRemote: boolean;
     /**
-     *
-     * 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 reason for the closure.
+     * @type {string}
      */
-    setHighPass(settings?: Partial<FilterPluginPassSettings>): Promise<this>;
+    reason: string;
+}
+/**
+ * The event for when lyrics are found.
+ */
+interface LyricsFoundEvent extends PlayerEvent<PlayerEventType.LyricsFound> {
     /**
-     *
-     * 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 guild id associated with the event.
+     * @type {string}
      */
-    setNormalization(settings?: Partial<NormalizationSettings>): Promise<this>;
+    guildId: string;
     /**
-     *
-     * 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 lyrics result of the event.
+     * @type {LyricsResult}
      */
-    setEcho(settings?: Partial<EchoSettings>): Promise<this>;
+    lyrics: LyricsResult;
 }
-
-type NonLengthEchoSettings = Omit$1<EchoSettings, "echoLength">;
 /**
- * Class representing Lavalink plugin filters.
- * @class LavalinkPluginFilter
+ * The event for when lyrics are not found.
  */
-declare class LavalinkPluginFilter {
+interface LyricsNotFoundEvent extends PlayerEvent<PlayerEventType.LyricsNotFound> {
+}
+/**
+ * The event for when a lyrics line is sent.
+ */
+interface LyricsLineEvent extends PlayerEvent<PlayerEventType.LyricsLine> {
     /**
-     * The filter manager instance.
-     * @type {FilterManagerStructure}
-     * @private
-     * @readonly
+     * The guild id associated with the event.
+     * @type {string}
      */
-    private readonly manager;
+    guildId: string;
     /**
-     * Creates an instance of LavalinkPluginFilter.
-     * @param {FilterManagerStructure} filters - The filter manager instance.
+     * The line index of the lyrics line.
+     * @type {number}
      */
-    constructor(filters: FilterManagerStructure);
+    lineIndex: 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 lyrics line of the event.
+     * @type {LyricsLine}
      */
-    setEcho(settings?: Partial<NonLengthEchoSettings>): Promise<this>;
+    line: LyricsLine;
     /**
-     *
-     * 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.
+     * Returns if the line was skipped.
+     * @type {boolean}
      */
-    setReverb(settings?: Partial<LavalinkFilterPluginReverbSettings>): Promise<this>;
+    skipped: boolean;
 }
-
 /**
- * Class representing a filter manager for a player.
- * @class FilterManager
+ * The update for the player state.
  */
-declare class FilterManager {
+interface PlayerUpdate {
     /**
-     * The player this filter manager belongs to.
-     * @type {PlayerStructure}
-     * @public
-     * @readonly
+     * The operation code for the update.
+     * @type {OpCodes.PlayerUpdate}
      */
-    readonly player: PlayerStructure;
+    op: OpCodes.PlayerUpdate;
     /**
-     * The bands applied to the player.
-     * @type {EQBandSettings[]}
-     * @readonly
+     * The guild ID associated with the update.
+     * @type {string}
      */
-    readonly bands: EQBandSettings[];
+    guildId: string;
     /**
-     * The current filter settings applied to the player.
-     * @type {FilterSettings}
-     * @public
+     * The state of the player.
+     * @type {PlayerUpdateState}
      */
-    data: FilterSettings;
+    state: PlayerUpdateState;
+}
+interface PlayerUpdateState {
     /**
-     * The enabled filters for the player.
-     * @type {EnabledPlayerFilters}
+     * Whether the player is connected.
+     * @type {boolean}
      */
-    filters: EnabledPlayerFilters;
+    connected: boolean;
     /**
-     * The lavalink plugin filters manager.
-     * @type {LavalinkPluginFilter}
-     * @readonly
+     * The position of the track.
+     * @type {number}
      */
-    readonly plugin: LavalinkPluginFilter;
+    position: number;
     /**
-     * The DSPX plugin filters manager.
-     * @type {DSPXPluginFilter}
-     * @readonly
+     * The time of the update.
+     * @type {number}
      */
-    readonly dspx: DSPXPluginFilter;
+    time: number;
     /**
-     *
-     * Creates a new filter manager.
-     * @param {PlayerStructure} player The player this filter manager belongs to.
+     * The ping of the player.
+     * @type {number}
      */
-    constructor(player: PlayerStructure);
+    ping: number;
+}
+/**
+ * The options for the player.
+ */
+interface PlayerOptions {
     /**
-     * Resets all filters to their default values.
-     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
+     * Guild id of the player.
+     * @type {string}
      */
-    reset(): Promise<this>;
+    guildId: string;
     /**
-     *
-     * Applies the current filters to the player.
-     * @returns {Promise<this>} A promise that resolves to the instance of the filter manager.
+     * Voice channel id of the player.
+     * @type {string}
      */
-    apply(): Promise<this>;
+    voiceId: string;
     /**
-     * Checks if the current filters are active.
-     * @param {TimescaleSettings} timescale The timescale settings to check against.
-     * @returns {void} Nothing!
+     * Volume of the player.
+     * @type {number | undefined}
+     * @default 100
      */
-    check(timescale?: TimescaleSettings): void;
+    volume?: number;
     /**
-     *
-     * 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.
+     * Set if the player should be deafened.
+     * @type {boolean | undefined}
+     * @default true
      */
-    has(filter: FilterType): boolean;
+    selfDeaf?: boolean;
     /**
-     *
-     * 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.
+     * Set if the player should be muted.
+     * @type {boolean | undefined}
+     * @default false
      */
-    setVolume(volume: number): Promise<this>;
+    selfMute?: boolean;
     /**
-     * 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.
+     * Text channel id of the player.
+     * @type {string | undefined}
      */
-    setAudioOutput(output: AudioOutput): Promise<this>;
+    textId?: string;
     /**
-     *
-     * 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.
+     * Lavalink node of the player.
+     * @type {NodeIdentifier}
      */
-    setSpeed(speed?: number): Promise<this>;
+    node?: NodeIdentifier;
+}
+/**
+ * The options for playing a track with Lavalink.
+ */
+interface LavalinkPlayOptions extends BasePlayOptions {
     /**
-     *
-     * 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.
+     * Track to play.
+     * @type {PartialLavalinkTrack | undefined}
      */
-    setRate(rate?: number): Promise<this>;
+    track?: PartialLavalinkTrack;
+}
+/**
+ * The options for playing a track.
+ */
+interface PlayOptions extends BasePlayOptions {
     /**
-     *
-     * Sets the pitch for the player.
-     * @param {number} pitch The pitch
-     * @returns {Promise<this>} A promise that resolves to the player instance.
+     * Whether to replace the current track.
+     * @type {boolean | undefined}
+     * @default false
      */
-    setPitch(pitch?: number): Promise<this>;
+    noReplace?: boolean;
     /**
-     *
-     * 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.
+     * Track to play.
+     * @type {Track | UnresolvedTrack | undefined}
      */
-    setEQBand(...bands: RestOrArray<EQBandSettings>): Promise<this>;
+    track?: Track | UnresolvedTrack;
+}
+interface PlayerVoice {
     /**
-     *
-     * Clears all EQ bands for the player.
-     * @returns {Promise<this>} A promise that resolves to the instance of the manager.
+     * The voice server token.
+     * @type {string}
      */
-    clearEQBands(): Promise<this>;
+    token: string;
     /**
-     *
-     * Set the vibrato filter with the given settings.
-     * @param {TremoloSettings} [settings=DefaultFilterPreset.Vibrato] The settings for the vibrato filter.
-     * @returns {Promise<this>} The instance of the filter manager.
+     * The voice server endpoint.
+     * @type {string}
      */
-    setVibrato(settings?: Partial<TremoloSettings>): Promise<this>;
+    endpoint: string;
     /**
-     *
-     * 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.
+     * The voice server session id.
+     * @type {string}
+     */
+    sessionId: string;
+    /**
+     * The voice server guild id.
+     * @type {string | undefined}
+     */
+    connected?: boolean;
+    /**
+     * The voice server ping.
+     * @type {number | undefined}
+     */
+    ping?: number;
+}
+/**
+ * The JSON representation of the player.
+ */
+interface PlayerJson {
+    /**
+     * The guild id of the player.
+     * @type {string}
      */
-    setTremolo(settings?: Partial<TremoloSettings>): Promise<this>;
+    guildId: string;
     /**
-     *
-     * 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.
+     * The volume of the player.
+     * @type {number}
      */
-    setLowPass(settings?: Partial<LowPassSettings>): Promise<this>;
+    volume: number;
     /**
-     * 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.
+     * The self deaf state of the player.
+     * @type {boolean}
      */
-    setNightcore(settings?: Partial<TimescaleSettings>): Promise<this>;
+    selfDeaf: boolean;
     /**
-     *
-     * 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.
+     * The self mute state of the player.
+     * @type {boolean}
      */
-    setVaporwave(settings?: Partial<TimescaleSettings>): Promise<this>;
+    selfMute: boolean;
     /**
-     *
-     * 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.
+     * The voice settings for the player.
+     * @type {LavalinkPlayerVoice}
      */
-    setKaraoke(settings?: Partial<KaraokeSettings>): Promise<this>;
+    voice: Nullable<LavalinkPlayerVoice>;
     /**
-     *
-     * 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.
+     * The loop mode of the player.
+     * @type {LoopMode}
      */
-    setDistortion(settings?: Partial<DistortionSettings>): Promise<this>;
+    loop: LoopMode;
     /**
-     * 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.
+     * The options for the player.
+     * @type {boolean}
      */
-    setTimescale(settings: Partial<TimescaleSettings>): Promise<this>;
+    options: PlayerOptions;
     /**
-     * Convert the filter settings to a JSON object.
-     * @returns {FilterSettings} The filter settings as a JSON object.
+     * The paused state of the player.
+     * @type {boolean}
      */
-    toJSON(): FilterSettings;
-}
-
-/**
- * Type representing the customizable player storage.
- */
-type StorageKeys = keyof CustomizablePlayerStorage | (string & {});
-/**
- * Type representing the customizable player storage values.
- */
-type StorageValues<V extends StorageKeys = StorageKeys> = V extends keyof CustomizablePlayerStorage ? CustomizablePlayerStorage[V] : unknown;
-/**
- * Class representing a player storage.
- * @class PlayerStorage
- */
-declare class PlayerStorage<K extends StorageKeys = StorageKeys, V extends StorageValues<K> = StorageValues<K>> {
+    paused: boolean;
     /**
-     *
-     * 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 playing state of the player.
+     * @type {boolean}
      */
-    get<K extends StorageKeys, V extends StorageValues<K>>(key: K): V | undefined;
+    playing: boolean;
     /**
-     * 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 voice channel id of the player.
+     * @type {string}
      */
-    set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): void;
+    voiceId?: string;
     /**
-     * Check if the storage has a key.
-     * @param {K} key The key to check for.
-     * @returns {boolean} True if the storage has the key, false otherwise.
+     * The text channel id of the player.
+     * @type {string | undefined}
      */
-    has(key: K): boolean;
+    textId?: string;
     /**
-     * Delete a key from the storage.
-     * @param {K} key The key to delete.
-     * @returns {boolean} True if the key was deleted, false otherwise.
+     * The last position received from Lavalink.
+     * @type {number}
      */
-    delete(key: K): boolean;
+    lastPosition: number;
     /**
-     * Get all keys in the storage.
-     * @returns {K[]} The keys in the storage.
+     * The timestamp when the last position change update happened.
+     * @type {number | null}
      */
-    keys<K extends StorageKeys[]>(): K[];
+    lastPositionUpdate: number | null;
     /**
-     * Get all values in the storage.
-     * @returns {V[]} The values in the storage.
+     * The current calculated position of the player.
+     * @type {number}
      */
-    values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): V[];
+    position: number;
     /**
-     * Get all entries in the storage.
-     * @returns {[K, V][]} The entries in the storage.
+     * The timestamp when the player was created.
+     * @type {number}
      */
-    entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): [K, V][];
+    createdTimestamp: number;
     /**
-     *
-     * 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 ping of the player.
+     * @type {number}
      */
-    all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Record<K[number], V>;
+    ping: number;
     /**
-     * Clear the storage.
+     * The queue of the player.
+     * @type {QueueJson}
      */
-    clear(): void;
+    queue: QueueJson;
     /**
-     * Get the size of the storage.
-     * @returns {number} The number of entries in the storage.
+     * The node of the player.
+     * @type {NodeJson}
      */
-    get size(): number;
+    node: NodeJson;
+    /**
+     * The filter settings of the player.
+     * @type {FilterSettings}
+     */
+    filters: FilterSettings;
 }
-
-/**
- * Type representing a nullable voice channel update.
- */
-type NullableVoiceChannelUpdate = Partial<Nullable<VoiceChannelUpdate>>;
 /**
- * Class representing a Hoshimi player.
- * @class Player
+ * The lyrics methods for the player.
  */
-declare class Player {
-    /**
-     * The data for the player.
-     * @type {PlayerStorage}
-     * @readonly
-     */
-    readonly data: PlayerStorage;
+interface LyricsMethods {
     /**
-     * The options for the player.
-     * @type {PlayerOptions}
-     * @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.lyrics.current();
+     * ```
      */
-    readonly options: PlayerOptions;
+    current(skipSource?: boolean): Promise<LyricsResult | null>;
     /**
-     * The manager for the player.
-     * @type {Hoshimi}
-     * @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 manager: Hoshimi;
+    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
     /**
-     * The queue for the player.
-     * @type {Queue}
-     * @readonly
+     *
+     * 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();
+     * ```
      */
-    readonly queue: QueueStructure;
+    subscribe(skipSource?: boolean): Promise<void>;
     /**
-     * The filter manager for the player.
-     * @type {FilterManager}
-     * @readonly
+     *
+     * 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();
+     * ```
      */
-    readonly filterManager: FilterManager;
+    unsubscribe(): Promise<void>;
+}
+/**
+ * The voice channel update options.
+ */
+type VoiceChannelUpdate = Pick<PlayerOptions, "selfDeaf" | "voiceId" | "selfMute">;
+/**
+ * The voice settings for the player.
+ */
+type LavalinkPlayerVoice = Omit<PlayerVoice, "connected" | "ping">;
+
+/**
+ * Class representing a LyricsManager.
+ * @class LyricsManager
+ */
+declare class LyricsManager {
     /**
-     * The node for the player.
+     * The node instance.
      * @type {NodeStructure}
+     * @readonly
      */
-    node: NodeStructure;
-    /**
-     * Check if the player is self deafened.
-     * @type {boolean}
-     */
-    selfDeaf: boolean;
-    /**
-     * Check if the player is self muted.
-     * @type {boolean}
-     */
-    selfMute: boolean;
+    readonly node: NodeStructure;
     /**
-     * Loop mode of the player.
-     * @type {LoopMode}
-     * @default LoopMode.Off
+     * Create a new LyricsManager instance.
+     * @param {NodeStructure} node The node instance.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("nodeId");
+     * const lyricsManager = new LyricsManager(node);
+     * ```
      */
-    loop: LoopMode;
+    constructor(node: NodeStructure);
     /**
-     * Check if the player is playing.
-     * @type {boolean}
-     * @default false
+     *
+     * 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();
+     * ```
      */
-    playing: boolean;
+    current(guildId: string, skipSource?: boolean): Promise<LyricsResult | null>;
     /**
-     * Check if the player is paused.
-     * @type {boolean}
-     * @default false
+     *
+     * 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);
+     * ```
      */
-    paused: boolean;
-    /**
-     * Check if the player is connected.
-     * @type {boolean}
-     * @default false
+    get(track: Track, skipSource?: boolean): Promise<LyricsResult | null>;
+    /**
+     *
+     * Subscribe to the lyrics for a specific guild.
+     * @param {string} guildId The guild id to subscribe to.
+     * @param {boolean} skipSource Whether to skip the track source or not.
+     * @returns {Promise<void>} Let's start the sing session!
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("nodeId");
+     * await node.lyricsManager.subscribe("guildId");
+     * ```
      */
-    connected: boolean;
+    subscribe(guildId: string, skipSource?: boolean): Promise<void>;
     /**
-     * Volume of the player.
-     * @type {number}
-     * @default 100
+     *
+     * 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");
+     * ```
      */
-    volume: number;
+    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> {
     /**
-     * Guild ig of the player.
-     * @type {string}
+     * 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
      */
-    guildId: string;
+    sweep(fn: (value: V, key: K, collection: this) => unknown): number;
     /**
-     * Voice channel idof the player.
-     * @type {string | undefined}
+     * 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']
      */
-    voiceId: string | undefined;
+    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
     /**
-     * Text channel id of the player.
-     * @type {string | undefined}
+     * 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']
      */
-    textId: string | undefined;
+    filter(fn: (value: V, key: K, collection: this) => boolean): V[];
     /**
-     * The ping of the player.
-     * @type {number}
+     * 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
      */
-    ping: number;
+    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+}
+
+/**
+ * Class representing a node manager.
+ * @class NodeManager
+ */
+declare class NodeManager {
     /**
-     * The timestamp when the player was created.
-     * @type {number}
+     * The manager for the node.
+     * @type {Hoshimi}
+     * @readonly
      */
-    createdTimestamp: number;
+    readonly manager: Hoshimi;
     /**
-     * The last position received from Lavalink.
-     * @type {number}
+     * The nodes for the manager.
+     * @type {Collection<string, Node>}
+     * @readonly
      */
-    lastPosition: number;
+    readonly nodes: Collection<string, NodeStructure>;
     /**
-     * The timestamp when the last position change update happened.
-     * @type {number | null}
+     *
+     * 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
+     * ```
      */
-    lastPositionUpdate: number | null;
+    constructor(manager: Hoshimi);
     /**
-     * The current calculated position of the player.
-     * @type {number}
-     * @readonly
+     *
+     * 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
+     * ```
      */
-    get position(): number;
+    delete(node: NodeIdentifier): boolean;
     /**
-     * The voice connection details.
-     * @type {PlayerVoice}
+     *
+     * 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");
+     * }
+     * ```
      */
-    voice: Nullable<LavalinkPlayerVoice>;
+    get(node: NodeIdentifier): NodeStructure | undefined;
     /**
      *
-     * Create a new player.
-     * @param {Hoshimi} manager The manager for the player.
-     * @param {PlayOptions} options The options for the player.
+     * Create a new node.
+     * @param {NodeOptions} options The options for the node.
+     * @returns {NodeStructure} The created node.
      * @example
      * ```ts
-     * const player = new Player(manager, {
-     * 	guildId: "guildId",
-     * 	voiceId: "voiceId",
-     * 	textId: "textId",
-     * 	selfDeaf: true,
-     * 	selfMute: false,
-     * 	volume: 100,
+     * const node = manager.nodeManager.create({
+     * 	host: "localhost",
+     * 	port: 2333,
+     * 	password: "password",
+     * 	secure: false,
      * });
      *
-     * console.log(player.guildId); // guildId
-     * console.log(player.voiceId); // voiceId
-     * console.log(player.textId); // textId
+     * console.log(node.id); // localhost:2333
      */
-    constructor(manager: Hoshimi, options: PlayerOptions);
+    create(options: NodeOptions): NodeStructure;
     /**
-     * The lyrics methods for the player.
-     * @type {LyricsMethods}
-     * @readonly
+     *
+     * 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();
+     * ```
      */
-    readonly lyrics: LyricsMethods;
+    destroy(node: NodeIdentifier): void;
     /**
      *
-     * Search for a track or playlist.
-     * @param {SearchOptions} options The options for the search.
-     * @returns {Promise<QueryResult>} The search result.
+     * Reconnect a node.
+     * @param {NodeIdentifier} node The node or node id to reconnect.
+     * @returns {void}
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const result = await player.search({
-     * 	query: "track name",
-     * 	engine: SearchEngine.Youtube,
-     * 	requester: {},
-     * });
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.reconnect();
+     * ```
+     */
+    reconnect(node: NodeIdentifier): void;
+    /**
      *
-     * console.log(result) // the search result
+     * 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();
      * ```
      */
-    search(options: SearchOptions): Promise<QueryResult>;
+    disconnect(node: NodeIdentifier): void;
     /**
      *
-     * 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.
+     * Connect a node.
+     * @param {NodeIdentifier} node The node or node id to connect.
+     * @returns {void}
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.skip(2); // skip 2 tracks
-     * player.skip(); // skip 1 track
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.connect();
      * ```
      */
-    skip(to?: number, throwError?: boolean): Promise<void>;
+    connect(node: NodeIdentifier): void;
     /**
      *
-     * 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.
+     * Get the least used node.
+     * @returns {NodeStructure} The least used node.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.seek(30000); // seek to 30 seconds
+     * 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
+     * }
      * ```
      */
-    seek(position: number): Promise<void>;
+    getLeastUsed(sortType?: NodeSortTypes): NodeStructure;
     /**
      *
-     * Disconnect the player from the voice channel.
-     * @returns {Promise<this>} The player instance.
+     * Reconnect the nodes.
+     * @returns {void}
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.disconnect();
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.reconnectAll();
      * ```
      */
-    disconnect(): Promise<this>;
+    reconnectAll(): void;
     /**
-     *
-     * Destroy and disconnect the player.
-     * @param {DestroyReasons} [reason] The reason for destroying the player.
-     * @returns {Promise<void>}
+     * Disconnect the nodes.
+     * @returns {void}
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.destroy(DestroyReasons.Stop);
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.disconnectAll();
      * ```
      */
-    destroy(reason?: DestroyReasons): Promise<boolean>;
+    disconnectAll(): void;
     /**
-     *
-     * 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.
+     * Connect the nodes.
+     * @returns {void}
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     *
-     * player.play({
-     * 	track: track,
-     * 	noReplace: true,
-     * });
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.connect();
      * ```
      */
-    play(options?: Partial<PlayOptions>): Promise<void>;
+    connectAll(): void;
     /**
-     * Connect the player to the voice channel.
-     * @returns {Promise<this>} The player instance.
+     * Destroy the nodes.
+     * @returns {void}
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.connect();
+     * const node = manager.nodeManager.get("node1");
+     * if (node) node.destroy();
      * ```
      */
-    connect(): Promise<this>;
+    destroyAll(): void;
+}
+
+/**
+ * Class representing the REST for the node.
+ * @class Rest
+ */
+declare class Rest {
+    /**
+     * The URL for the REST.
+     * @type {string}
+     */
+    readonly url: string;
+    /**
+     * The version for the REST.
+     * @type {string}
+     */
+    readonly version: string;
+    /**
+     * The timeout for the REST.
+     * @type {number}
+     */
+    readonly restTimeout: number;
+    /**
+     * The user agent for the REST.
+     * @type {UserAgent}
+     */
+    readonly userAgent: UserAgent;
+    /**
+     * The node for the REST.
+     * @type {Node}
+     */
+    readonly node: NodeStructure;
     /**
      *
-     * Stop the player from playing.
-     * @param {boolean} [destroy=true] Whether to destroy the player or not.
-     * @returns {Promise<void>}
+     * Create a new REST.
+     * @param {NodeStructure} node The node for the REST.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.stop();
+     * 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
      * ```
      */
-    stop(destroy?: boolean): Promise<void>;
+    constructor(node: NodeStructure);
+    /**
+     * The REST URL to make requests.
+     * @type {string}
+     */
+    get restUrl(): string;
+    /**
+     * The session id of the node.
+     * @type {string}
+     */
+    get sessionId(): string;
     /**
      *
-     * Pause or resume the player.
-     * @returns {Promise<void>}
-     * @example
-     * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.setPaused();
-     * ```
+     * Make a request to the node.
+     * @param {RestOptions} options The options to make the request.
+     * @returns {Promise<T | null>} The response from the node.
      */
-    setPaused(paused?: boolean): Promise<boolean>;
+    request<T>(options: RestOptions): Promise<T | null>;
     /**
      *
-     * Set the volume of the player.
-     * @param {number} volume The volume to set.
-     * @returns {Promise<void>}
+     * Update the player data.
+     * @param {Partial<UpdatePlayerInfo>} data The player data to update.
+     * @returns {LavalinkPlayer | null} The updated player data.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.setVolume(50); // set the volume to 50%
+     * 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
      * ```
      */
-    setVolume(volume: number): Promise<void>;
+    updatePlayer(data: Partial<UpdatePlayerInfo>): Promise<LavalinkPlayer | null>;
     /**
      *
-     * Set the loop mode of the player.
-     * @param {LoopMode} mode The loop mode to set.
-     * @throws {PlayerError} If the loop mode is invalid.
+     * 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 = manager.getPlayer("guildId");
-     * player.setLoop(LoopMode.Track);
+     * const player = await node.rest.stopPlayer("guildId");
+     * if (player) console.log(player); // The lavalink player
      * ```
      */
-    setLoop(mode: LoopMode): this;
+    stopPlayer(guildId: string): Promise<LavalinkPlayer | null>;
     /**
-     * Set the voice of the player.
-     * @param {NullableVoiceChannelUpdate} options The voice state to set.
-     * @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
-     * const player = manager.getPlayer("guildId");
-     * player.setVoice({ voiceId: "newVoiceId" });
+     * await node.rest.destroyPlayer("guildId");
      * ```
+     * @example
      */
-    setVoice(options?: NullableVoiceChannelUpdate): Promise<void>;
+    destroyPlayer(guildId: string): Promise<void>;
     /**
      *
-     * 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.
+     * Update the session for the node
+     * @param {SessionResumingOptions} options The session resuming options.
+     * @returns {Promise<LavalinkSession | null>} The updated session data.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * player.move("newNodeId");
+     * const session = await node.rest.updateSession({ resuming: true, timeout: 30000 });
+     * if (session) console.log(session); // The lavalink session data
      * ```
      */
-    move(node: NodeIdentifier): Promise<void>;
-    /**
-     * Update the player with new data.
-     * @param {NonGuildUpdatePlayerInfo} data The data to update the player with.
-     * @returns {Promise<LavalinkPlayer | null>} The updated player data.
-     */
-    updatePlayer(data: NonGuildUpdatePlayerInfo): Promise<LavalinkPlayer | null>;
+    updateSession(options: SessionResumingOptions): Promise<LavalinkSession | null>;
     /**
      *
-     * Return the player as a json object.
-     * @returns {PlayerJson}
+     * Get all players for the current session.
+     * @returns {Promise<LavalinkPlayer[]>} The players for the current session.
      * @example
      * ```ts
-     * const player = manager.getPlayer("guildId");
-     * const json = player.toJSON();
-     * console.log(json); // the player as a json object
+     * const players = await node.rest.getPlayers();
+     * console.log(players); // The lavalink players for the current session
      * ```
      */
-    toJSON(): PlayerJson;
-}
-/**
- * Type representing the update player information without guildId.
- */
-type NonGuildUpdatePlayerInfo = Omit<UpdatePlayerInfo, "guildId">;
-/**
- * Interface representing the customizable player storage.
- */
-interface CustomizablePlayerStorage {
+    getPlayers(): Promise<LavalinkPlayer[]>;
 }
 
 /**
@@ -3006,6 +3372,8 @@ declare class QueueUtils {
     /**
      *
      * Sync the queue.
+     * @param {boolean} [override=true] Whether to override the current queue or not.
+     * @param {boolean} [syncCurrent=false] Whether to sync the current track or not.
      * @returns {Awaitable<void>}
      * @example
      * ```ts
@@ -3267,6 +3635,17 @@ declare class Queue {
      * @param {Track} track The track to move.
      * @param {number} to The position to move.
      * @returns {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     * await queue.add(track);
+     * await queue.add(track1);
+     * await queue.add(track2);
+     *
+     * console.log(queue.tracks); // [track, track1, track2]
+     * await queue.move(track1, 0);
+     * console.log(queue.tracks); // [track1, track, track2]
+     * ```
      */
     move(track: Track, to: number): Promise<this>;
     /**
@@ -3276,12 +3655,30 @@ declare class Queue {
      * @param {number} deleteCount The number of tracks to delete.
      * @param {Track | Track[]} [tracks] The tracks to add.
      * @returns {Promise<this>} The queue instance.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     * await queue.add(track);
+     * await queue.add(track1);
+     * await queue.add(track2);
+     *
+     * console.log(queue.tracks); // [track, track1, track2]
+     * await queue.splice(1, 1);
+     * console.log(queue.tracks); // [track, track2]
+     * ```
      */
     splice(start: number, deleteCount: number, tracks?: HoshimiTrack | HoshimiTrack[]): Promise<this>;
     /**
      *
      * Convert the queue to a JSON object.
      * @returns {QueueJson} The queue JSON object.
+     * @example
+     * ```ts
+     * const queue = player.queue;
+     * await queue.add(track);
+     *
+     * console.log(queue.toJSON()); // { tracks: [track], history: [], current: null }
+     * ```
      */
     toJSON(): QueueJson;
 }
@@ -4466,6 +4863,11 @@ interface NodeInfo {
      * @type {NodeInfoPlugin[]}
      */
     plugins: NodeInfoPlugin[];
+    /**
+     * Whether the node is a Nodelink instance.
+     * @type {boolean
+     */
+    isNodelink: boolean;
 }
 /**
  * The node options.
@@ -4733,7 +5135,7 @@ declare class Node {
     readonly nodeManager: NodeManagerStructure;
     /**
      * The lyrics manager for the node.
-     * @type {LyricsManager}
+     * @type {LyricsManagerStructure}
      */
     readonly lyricsManager: LyricsManagerStructure;
     /**
@@ -4826,6 +5228,23 @@ declare class Node {
      * ```
      */
     get id(): string;
+    /**
+     *
+     * Check if the node is a Nodelink node.
+     * @returns {boolean} True if the node is a Nodelink node, false otherwise.
+     * @example
+     * ```ts
+     * const node = manager.nodeManager.get("node1");
+     * if (node) {
+     * 	 if (node.isNodelink()) {
+     * 		console.log("The node is a Nodelink node");
+     *   } else {
+     *       console.log("The node is a Lavalink node");
+     *   }
+     * }
+     * ```
+     */
+    isNodelink(): boolean;
     /**
      * The socket address to connect the node.
      * @type {string}
@@ -4964,19 +5383,18 @@ declare class Node {
     /**
      *
      * Update the session for the node
-     * @param {boolean} resuming Enable resuming for the session.
-     * @param {number | null} timeout The timeout for the session.
+     * @param {SessionResumingOptions} options The session resuming options.
      * @returns {Promise<LavalinkSession | null>}
      * @example
      * ```ts
      * const node = manager.nodeManager.get("node1");
      * if (node) {
-     * 	const session = await node.updateSession(true, 60);
+     * 	const session = await node.updateSession({ resuming: true, timeout: 30000 });
      * 	console.log(session); // the lavalink session
      * }
      * ```
      */
-    updateSession(resuming: boolean, timeout?: number | null): Promise<LavalinkSession | null>;
+    updateSession(options: SessionResumingOptions): Promise<LavalinkSession | null>;
     /**
      * Reconnect the node.
      * @returns {void}
@@ -5166,7 +5584,12 @@ declare enum SearchEngines {
      * Play voice using text to speech.
      * @description Provided by skybot-lavalink-plugin plugin.
      */
-    TextToSpeech = "speak"
+    TextToSpeech = "speak",
+    /**
+     * Search via http url.
+     * @description Provided by lavalink.
+     */
+    HTTP = "http"
 }
 /**
  * The debug levels for the manager.
@@ -5200,7 +5623,7 @@ declare enum DebugLevels {
 /**
  * The events for the manager.
  */
-declare enum Events {
+declare enum EventNames {
     /**
      * Emitted when the manager emits a debug message.
      */
@@ -5786,7 +6209,7 @@ interface ChannelDeletePacket {
 /**
  * Make a function awaitable by returning a promise or the value.
  */
-type Awaitable<T> = T | Promise<T>;
+type Awaitable<T> = Promise<T> | T;
 /**
  * Create a type that infers the value of a key from an object.
  */
@@ -5801,6 +6224,10 @@ type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
  * Create a type that can be a rest or an array.
  */
 type RestOrArray<T> = T[] | [T[]];
+/**
+ * Conditional type to check if T is true, then A, else B or A | null.
+ */
+type If<T extends boolean, A, B = null> = T extends true ? A : B extends null ? A | null : B;
 /**
  * Make a type required.
  */
@@ -5843,19 +6270,43 @@ type GatewayPackets = VoicePacket | VoiceServer | VoiceState | ChannelDeletePack
  * The required options for the manager.
  */
 type RequiredOptions = DeepRequired<HoshimiOptions>;
-/**
- * The events for the manager.
- * This allows to extend the events.
- */
-type RawEvents = {
-    [K in keyof HoshimiEvents]: HoshimiEvents[K];
-};
 /**
  * Class representing the Hoshimi manager.
  * @class Hoshimi
- * @extends {EventEmitter<RawEvents>}
+ * @extends {EventEmitter<HoshimiEvents>}
+ * @example
+ * ```ts
+ * import { Hoshimi, SearchEngines } from "hoshimi";
+ *
+ * const manager = new Hoshimi({ // or via createHoshimi() function
+ *  sendPayload: async (guildId, payload) => {
+ *      const guild = await <Client>.guilds.fetch(guildId);
+ *      if (!guild) return;
+ *
+ *      guild.shard.send(payload); // Adjust this line based on your library's method to send payloads
+ *  },
+ * 	nodes: [
+ * 		{
+ * 			host: "localhost",
+ * 			port: 2333,
+ *          password: "youshallnotpass",
+ * 			secure: false,
+ * 		},
+ *     ],
+ * });
+ *
+ * manager.on("nodeReady", (node) => console.log(`Node ${node.id} is ready.`));
+ * manager.on("playerCreate", (player) => console.log(`Player created for guild ${player.guildId}.`));
+ * manager.on("error", (error) => console.error("An error occurred:", error));
+ *
+ * <Client>.on("ready", () => {
+ *   manager.init({ id: <Client>.user.id, username: <Client>.user.username });
+ * });
+ *
+ * console.log(manager); // The manager instance
+ * ```
  */
-declare class Hoshimi extends EventEmitter<RawEvents> {
+declare class Hoshimi extends EventEmitter<HoshimiEvents> {
     /**
      * The options for the manager.
      * @type {HoshimiOptions}
@@ -5882,6 +6333,7 @@ declare class Hoshimi extends EventEmitter<RawEvents> {
      * The constructor for the manager.
      * @param {HoshimiOptions} options The options for the manager.
      * @throws {ManagerError} If the options are not provided.
+     * @throws {OptionError} If the options are invalid.
      * @example
      * ```ts
      * const manager = new Hoshimi({
@@ -6043,12 +6495,31 @@ declare class Hoshimi extends EventEmitter<RawEvents> {
  */
 declare function createHoshimi(...args: ConstructorParameters<typeof Hoshimi>): Hoshimi;
 
+/**
+ * Class representing a player storage.
+ * @class PlayerMemoryStorage
+ * @extends {PlayerStorageAdapter}
+ */
+declare class PlayerMemoryStorage<K extends StorageKeys = StorageKeys, V extends StorageValues<K> = StorageValues<K>> extends PlayerStorageAdapter {
+    get<K extends StorageKeys, V extends StorageValues<K>>(key: K): Awaitable<V | undefined>;
+    set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): Awaitable<void>;
+    has<K extends StorageKeys>(key: K): Awaitable<boolean>;
+    delete<K extends StorageKeys>(key: K): Awaitable<boolean>;
+    keys<K extends StorageKeys[]>(): Awaitable<K[]>;
+    values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<V[]>;
+    entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<[K, V][]>;
+    all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<Record<K[number], V>>;
+    clear(): Awaitable<void>;
+    size(): Awaitable<number>;
+    buildKey(...parts: RestOrArray<string>): string;
+}
+
 /**
  * Class representing a memory storage manager.
  * @class MemoryAdapter
- * @extends {StorageAdapter}
+ * @extends {QueueStorageAdapter}
  */
-declare class MemoryAdapter<T extends QueueJson = QueueJson> extends StorageAdapter<T> {
+declare class QueueMemoryStorage<T extends QueueJson = QueueJson> extends QueueStorageAdapter<T> {
     get(key: string): T | undefined;
     set(key: string, value: T): void;
     delete(key: string): boolean;
@@ -6056,6 +6527,108 @@ declare class MemoryAdapter<T extends QueueJson = QueueJson> extends StorageAdap
     has(key: string): boolean;
     parse(value: unknown): T;
     stringify<R = string>(value: unknown): R;
+    buildKey(...parts: RestOrArray<string>): string;
 }
 
-export { AudioOutput, type Awaitable, type ChannelDelete, type ChannelDeletePacket, type ChannelMixSettings, type ClientData, type CustomizablePlayerStorage, type CustomizableStructures, type CustomizableTrack, DSPXPluginFilter, DebugLevels, type DecodeMethods, type DeepRequired, DestroyReasons, type DistortionSettings, type EQBandSettings, type EchoSettings, type EnabledDSPXPluginFilters, type EnabledLavalinkFilters, type EnabledPlayerFilters, Events, type Exception, type FetchOptions, FilterManager, type FilterManagerStructure, type FilterPluginPassSettings, type FilterSettings, FilterType, type FreqSettings, type GatewayPayload, type GatewaySendPayload, Hoshimi, type HoshimiEvents, type HoshimiNodeOptions, type HoshimiOptions, type 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 };
+/**
+ * The auto output record type.
+ */
+type AutoOutputRecord = Record<AudioOutput, Required<ChannelMixSettings>>;
+/**
+ * The user agent for Hoshimi.
+ * @type {UserAgent}
+ */
+declare const HoshimiAgent: UserAgent;
+/**
+ * The url regex for Hoshimi.
+ * @type {RegExp}
+ */
+declare const UrlRegex: RegExp;
+/**
+ * The valid search engines for Hoshimi.
+ * @type {SearchEngines[]}
+ */
+declare const ValidEngines: SearchEngines[];
+/**
+ * The valid sources for Hoshimi.
+ * @type {Map<SourceNames, SearchEngines>}
+ */
+declare const ValidSources: Map<SourceNames, SearchEngines>;
+/**
+ * The audio output data for Hoshimi.
+ * @type {Readonly<Record<AudioOutput, Required<ChannelMixSettings>>>}
+ */
+declare const AudioOutputData: Readonly<AutoOutputRecord>;
+/**
+ * The default filter presets.
+ */
+declare const DefaultFilterPreset: Readonly<{
+    Karaoke: {
+        level: number;
+        monoLevel: number;
+        filterBand: number;
+        filterWidth: number;
+    };
+    Vaporwave: {
+        speed: number;
+        pitch: number;
+        rate: number;
+    };
+    Nightcore: {
+        speed: number;
+        pitch: number;
+        rate: number;
+    };
+    Lowpass: {
+        smoothing: number;
+    };
+    Tremolo: {
+        frequency: number;
+        depth: number;
+    };
+    Vibrato: {
+        frequency: number;
+        depth: number;
+    };
+    Distortion: {
+        cosOffset: number;
+        sinOffset: number;
+        tanOffset: number;
+        offset: number;
+        scale: number;
+        cosScale: number;
+        sinScale: number;
+        tanScale: number;
+    };
+    DSPXHighPass: {
+        boostFactor: number;
+        cutoffFrequency: number;
+    };
+    DSPXLowPass: {
+        boostFactor: number;
+        cutoffFrequency: number;
+    };
+    DSPXNormalization: {
+        adaptive: boolean;
+        maxAmplitude: number;
+    };
+    DSPXEcho: {
+        decay: number;
+        echoLength: number;
+    };
+    PluginEcho: {
+        decay: number;
+        delay: number;
+    };
+    PluginReverb: {
+        delays: number[];
+        gains: number[];
+    };
+}>;
+/**
+ * The default filter settings.
+ * @type {Readonly<FilterSettings>} DefaultFilters
+ */
+declare const DefaultPlayerFilters: Readonly<FilterSettings>;
+
+export { AudioOutput, AudioOutputData, type Awaitable, type ChannelDelete, type ChannelDeletePacket, type ChannelMixSettings, type ClientData, type CustomizablePlayerStorage, type CustomizableStructures, type CustomizableTrack, DSPXPluginFilter, DebugLevels, type DecodeMethods, type DeepRequired, DefaultFilterPreset, DefaultPlayerFilters, DestroyReasons, type DistortionSettings, type EQBandSettings, type EchoSettings, type EnabledDSPXPluginFilters, type EnabledLavalinkFilters, type EnabledPlayerFilters, EventNames, type Exception, type FetchOptions, FilterManager, type FilterManagerStructure, type FilterPluginPassSettings, type FilterSettings, FilterType, type FreqSettings, type GatewayPayload, type GatewaySendPayload, Hoshimi, HoshimiAgent, type HoshimiEvents, type HoshimiNodeOptions, type HoshimiOptions, type HoshimiPlayerOptions, type HoshimiQueueOptions, type HoshimiRestOptions, type HoshimiTrack, HttpMethods, HttpStatusCodes, type If, type InferCustomStructure, type Inferable, type KaraokeSettings, type LavalinkFilterPluginEchoSettings, type LavalinkFilterPluginReverbSettings, type LavalinkFilterPluginSettings, type LavalinkPayload, type LavalinkPlayOptions, type LavalinkPlayer, type LavalinkPlayerState, type LavalinkPlayerVoice, LavalinkPluginFilter, type LavalinkRestError, type LavalinkSearchResponse, type LavalinkSession, type LavalinkTrack, LoadType, LoopMode, type LowPassSettings, type LyricsFoundEvent, type LyricsLine, type LyricsLineEvent, type LyricsManagerStructure, type LyricsMethods, type LyricsNotFoundEvent, type LyricsResult, ManagerError, Node, type NodeCpu, type NodeDestroyInfo, NodeDestroyReasons, type NodeDisconnectInfo, NodeError, type NodeFrameStats, type NodeIdentifier, type NodeInfo, type NodeInfoGit, type NodeInfoPlugin, type NodeInfoVersion, type NodeJson, NodeManagerError, type NodeManagerStructure, type NodeMemory, type NodeOptions, NodeSortTypes, type NodeStructure, type NormalizationSettings, type Nullable, type NullableLavalinkSession, type Omit$1 as Omit, OpCodes, OptionError, type PickNullable, type PickRequired, type PlayOptions, Player, PlayerError, type PlayerEvent, PlayerEventType, type PlayerJson, PlayerMemoryStorage, type PlayerOptions, PlayerStorageAdapter, type PlayerStructure, type PlayerUpdate, type PlayerUpdateState, type PlayerVoice, type Playlist, type PlaylistInfo, type PluginFilterSettings, type PluginInfo, PluginInfoType, PluginNames, type QueryResult, Queue, type QueueJson, QueueMemoryStorage, QueueStorageAdapter, type QueueStructure, type Ready, ResolveError, Rest, type RestEndpoint, type RestOptions, type RestOrArray, RestPathType, RestRoutes, type RestStructure, type ResumableHeaders, type RotationSettings, SearchEngines, type SearchOptions, type SearchQuery, type SessionResumingOptions, Severity, SourceNames, State, type Stats, StorageError, type StorageKeys, type StorageValues, Structures, type TimescaleSettings, Track, type TrackEndEvent, TrackEndReason, type TrackExceptionEvent, type TrackInfo, type TrackRequester, type TrackStartEvent, type TrackStuckEvent, type TrackUserData, type TremoloSettings, type UnresolvedLavalinkTrack, UnresolvedTrack, type UnresolvedTrackInfo, type UpdatePlayerInfo, UrlRegex, type UserAgent, ValidEngines, ValidSources, type VoiceChannelUpdate, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent, WebsocketCloseCodes, createHoshimi };