magmastream 2.10.2-dev.4 → 2.10.2

package/dist/structures/Manager.d.ts

@@ -1,259 +0,0 @@
-import { Collection } from "@discordjs/collection";
-import { GatewayVoiceStateUpdate } from "discord-api-types/v10";
-import { EventEmitter } from "events";
-import { Node } from "./Node";
-import { Player } from "./Player";
-import { Redis as RedisClient } from "ioredis";
-import { AnyGuild, AnyUser, DiscordVoiceState, ManagerEvents, ManagerInitOptions, ManagerOptions, NodeOptions, PlayerOptions, SearchQuery, SearchResult, StandaloneManagerOptions, TrackData, VoicePacket, VoiceServer } from "./Types";
-/**
- * The main hub for interacting with Lavalink and using Magmastream.
- */
-export declare class Manager extends EventEmitter {
-    /** The map of players. */
-    readonly players: Collection<string, Player>;
-    /** The map of nodes. */
-    readonly nodes: Collection<string, Node>;
-    /** The options that were set. */
-    readonly options: ManagerOptions;
-    initiated: boolean;
-    redis?: RedisClient;
-    private _send;
-    private _getUser?;
-    private _getGuild?;
-    private loadedPlugins;
-    /**
-     * Initiates the Manager class.
-     * @param options
-     * @param options.enabledPlugins - An array of enabledPlugins to load.
-     * @param options.nodes - An array of node options to create nodes from.
-     * @param options.playNextOnEnd - Whether to automatically play the first track in the queue when the player is created.
-     * @param options.autoPlaySearchPlatforms - The search platform autoplay will use. Fallback to Youtube if not found.
-     * @param options.enablePriorityMode - Whether to use the priority when selecting a node to play on.
-     * @param options.clientName - The name of the client to send to Lavalink.
-     * @param options.defaultSearchPlatform - The default search platform to use when searching for tracks.
-     * @param options.useNode - The strategy to use when selecting a node to play on.
-     * @param options.trackPartial - The partial track search results to use when searching for tracks. This partials will always be presented on each track.
-     * @param options.eventBatchDuration - The duration to wait before processing the collected player state events.
-     * @param options.eventBatchInterval - The interval to wait before processing the collected player state events.
-     */
-    constructor(options: StandaloneManagerOptions);
-    constructor(options: ManagerOptions, isWrapper: true);
-    /**
-     * Initiates the Manager.
-     * @param clientId - The Discord client ID (only required when not using any of the magmastream wrappers).
-     * @param clusterId - The cluster ID which runs the current process (required).
-     * @returns The manager instance.
-     */
-    init(options?: ManagerInitOptions): Promise<this>;
-    /**
-     * Searches the enabled sources based off the URL or the `source` property.
-     * @param query
-     * @param requester
-     * @returns The search result.
-     */
-    search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
-    /**
-     * Returns a player or undefined if it does not exist.
-     * @param guildId The guild ID of the player to retrieve.
-     * @returns The player if it exists, undefined otherwise.
-     */
-    getPlayer(guildId: string): Player | undefined;
-    /**
-     * Creates a player or returns one if it already exists.
-     * @param options The options to create the player with.
-     * @returns The created player.
-     */
-    create(options: PlayerOptions): Player;
-    /**
-     * Destroys a player.
-     * @param guildId The guild ID of the player to destroy.
-     * @returns A promise that resolves when the player has been destroyed.
-     */
-    destroy(guildId: string): Promise<void>;
-    /**
-     * Creates a new node or returns an existing one if it already exists.
-     * @param options - The options to create the node with.
-     * @returns The created node.
-     */
-    createNode(options: NodeOptions): Node;
-    /**
-     * Destroys a node if it exists. Emits a debug event if the node is found and destroyed.
-     * @param identifier - The identifier of the node to destroy.
-     * @returns {void}
-     * @emits {debug} - Emits a debug message indicating the node is being destroyed.
-     */
-    destroyNode(identifier: string): Promise<void>;
-    /**
-     * Attaches an event listener to the manager.
-     * @param event The event to listen for.
-     * @param listener The function to call when the event is emitted.
-     * @returns The manager instance for chaining.
-     */
-    on<T extends keyof ManagerEvents>(event: T, listener: (...args: ManagerEvents[T]) => void): this;
-    /**
-     * Updates the voice state of a player based on the provided data.
-     * @param data - The data containing voice state information, which can be a VoicePacket, VoiceServer, or VoiceState.
-     * @returns A promise that resolves when the voice state update is handled.
-     * @emits {debug} - Emits a debug message indicating the voice state is being updated.
-     */
-    updateVoiceState(data: VoicePacket | VoiceServer | DiscordVoiceState): Promise<void>;
-    /**
-     * Decodes an array of base64 encoded tracks and returns an array of TrackData.
-     * Emits a debug event with the tracks being decoded.
-     * @param tracks - An array of base64 encoded track strings.
-     * @returns A promise that resolves to an array of TrackData objects.
-     * @throws Will throw an error if no nodes are available or if the API request fails.
-     */
-    decodeTracks(tracks: string[]): Promise<TrackData[]>;
-    /**
-     * Decodes a base64 encoded track and returns a TrackData.
-     * @param track - The base64 encoded track string.
-     * @returns A promise that resolves to a TrackData object.
-     * @throws Will throw an error if no nodes are available or if the API request fails.
-     */
-    decodeTrack(track: string): Promise<TrackData>;
-    /**
-     * Saves player states.
-     * @param {string} guildId - The guild ID of the player to save
-     */
-    savePlayerState(guildId: string): Promise<void>;
-    /**
-     * Sleeps for a specified amount of time.
-     * @param ms The amount of time to sleep in milliseconds.
-     * @returns A promise that resolves after the specified amount of time.
-     */
-    private sleep;
-    private restorePlayerFromState;
-    private restoreQueue;
-    private restorePreviousQueue;
-    private restoreRepeatState;
-    private restorePlayerData;
-    private restoreFilters;
-    /**
-     * Loads player states from the JSON file.
-     * @param nodeId The ID of the node to load player states from.
-     * @returns A promise that resolves when the player states have been loaded.
-     */
-    loadPlayerStates(nodeId: string): Promise<void>;
-    /**
-     * Returns the node to use based on the configured `useNode` and `enablePriorityMode` options.
-     * If `enablePriorityMode` is true, the node is chosen based on priority, otherwise it is chosen based on the `useNode` option.
-     * If `useNode` is "leastLoad", the node with the lowest load is chosen, if it is "leastPlayers", the node with the fewest players is chosen.
-     * If `enablePriorityMode` is false and `useNode` is not set, the node with the lowest load is chosen.
-     * @returns {Node} The node to use.
-     */
-    get useableNode(): Node;
-    /**
-     * Handles the shutdown of the process by saving all active players' states.
-     * This function is called when the process is about to exit.
-     * It iterates through all players and calls {@link savePlayerState} to save their states.
-     * After saving, it exits the process.
-     * @param stopProcess - A function to stop the process.
-     */
-    handleShutdown(stopProcess?: () => Promise<void>): Promise<void>;
-    /**
-     * Parses a YouTube title into a clean title and author.
-     * @param title - The original title of the YouTube video.
-     * @param originalAuthor - The original author of the YouTube video.
-     * @returns An object with the clean title and author.
-     */
-    private parseYouTubeTitle;
-    /**
-     * Balances brackets in a given string by ensuring all opened brackets are closed correctly.
-     * @param str - The input string that may contain unbalanced brackets.
-     * @returns A new string with balanced brackets.
-     */
-    private balanceBrackets;
-    /**
-     * Escapes a string by replacing special regex characters with their escaped counterparts.
-     * @param string - The string to escape.
-     * @returns The escaped string.
-     */
-    /**
-     * Checks if the given data is a voice update.
-     * @param data The data to check.
-     * @returns Whether the data is a voice update.
-     */
-    private isVoiceUpdate;
-    /**
-     * Determines if the provided update is a valid voice update.
-     * A valid update must contain either a token or a session_id.
-     *
-     * @param update - The voice update data to validate, which can be a VoicePacket, VoiceServer, or VoiceState.
-     * @returns {boolean} - True if the update is valid, otherwise false.
-     */
-    private isValidUpdate;
-    /**
-     * Handles a voice server update by updating the player's voice state and sending the voice state to the Lavalink node.
-     * @param player The player for which the voice state is being updated.
-     * @param update The voice server data received from Discord.
-     * @returns A promise that resolves when the voice state update is handled.
-     * @emits {debug} - Emits a debug message indicating the voice state is being updated.
-     */
-    private handleVoiceServerUpdate;
-    /**
-     * Handles a voice state update by updating the player's voice channel and session ID if provided, or by disconnecting and destroying the player if the channel ID is null.
-     * @param player The player for which the voice state is being updated.
-     * @param update The voice state data received from Discord.
-     * @emits {playerMove} - Emits a player move event if the channel ID is provided and the player is currently connected to a different voice channel.
-     * @emits {playerDisconnect} - Emits a player disconnect event if the channel ID is null.
-     */
-    private handleVoiceStateUpdate;
-    /**
-     * Cleans up an inactive player by removing its state data.
-     * This is done to prevent stale state data from accumulating.
-     * @param guildId The guild ID of the player to clean up.
-     */
-    cleanupInactivePlayer(guildId: string): Promise<void>;
-    /**
-     * Loads the enabled plugins.
-     */
-    private loadPlugins;
-    /**
-     * Unloads the enabled plugins.
-     */
-    private unloadPlugins;
-    /**
-     * Clears all player states from the file system.
-     * This is done to prevent stale state files from accumulating on the file system.
-     */
-    private clearAllStoredPlayers;
-    /**
-     * Returns the nodes that has the least load.
-     * The load is calculated by dividing the lavalink load by the number of cores.
-     * The result is multiplied by 100 to get a percentage.
-     * @returns {Collection<string, Node>}
-     */
-    private get leastLoadNode();
-    /**
-     * Returns the nodes that have the least amount of players.
-     * Filters out disconnected nodes and sorts the remaining nodes
-     * by the number of players in ascending order.
-     * @returns {Collection<string, Node>} A collection of nodes sorted by player count.
-     */
-    private get leastPlayersNode();
-    /**
-     * Returns a node based on priority.
-     * The nodes are sorted by priority in descending order, and then a random number
-     * between 0 and 1 is generated. The node that has a cumulative weight greater than or equal to the
-     * random number is returned.
-     * If no node has a cumulative weight greater than or equal to the random number, the node with the
-     * lowest load is returned.
-     * @returns {Node} The node to use.
-     */
-    private get priorityNode();
-    protected send(packet: GatewayVoiceStateUpdate): unknown;
-    protected getUserFromCache(id: string): AnyUser | undefined;
-    protected getGuildFromCache(id: string): AnyGuild | undefined;
-    sendPacket(packet: GatewayVoiceStateUpdate): unknown;
-    /**
-     * Resolves a PortableUser or ID to a real user object.
-     * Can be overridden by wrapper managers to return wrapper-specific User classes.
-     */
-    resolveUser(user: AnyUser | string): Promise<AnyUser>;
-    /**
-     * Resolves a Guild ID to a real guild object.
-     * Can be overridden by wrapper managers to return wrapper-specific Guild classes.
-     */
-    resolveGuild(guildId: string): AnyGuild;
-}

package/dist/structures/Node.d.ts

@@ -1,390 +0,0 @@
-import { Manager } from "./Manager";
-import { Player } from "./Player";
-import { Rest } from "./Rest";
-import WebSocket from "ws";
-import { LavalinkInfo, Lyrics, NodeLinkGetLyrics, NodeOptions, NodeStats, PlayerEvent, PlayerEvents, Track, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, WebSocketClosedEvent } from "./Types";
-import { SponsorBlockSegment } from "./Enums";
-export declare class Node {
-    manager: Manager;
-    options: NodeOptions;
-    /** The socket for the node. */
-    socket: WebSocket | null;
-    /** The stats for the node. */
-    stats: NodeStats;
-    /** The manager for the node */
-    /** The node's session ID. */
-    sessionId: string | null;
-    /** The REST instance. */
-    readonly rest: Rest;
-    /** Actual Lavalink information of the node. */
-    info: LavalinkInfo | null;
-    /** Whether the node is a NodeLink. */
-    isNodeLink: boolean;
-    private reconnectTimeout?;
-    private reconnectAttempts;
-    private redisPrefix?;
-    private sessionIdsMap;
-    /**
-     * Creates an instance of Node.
-     * @param manager - The manager for the node.
-     * @param options - The options for the node.
-     */
-    constructor(manager: Manager, options: NodeOptions);
-    /**
-     * Checks if the Node is currently connected.
-     * This method returns true if the Node has an active WebSocket connection, indicating it is ready to receive and process commands.
-     */
-    get connected(): boolean;
-    /** Returns the full address for this node, including the host and port. */
-    get address(): string;
-    private getCompositeKey;
-    private getRedisSessionIdsKey;
-    private getNodeSessionsDir;
-    private getNodeSessionPath;
-    /**
-     * Loads session IDs from the sessionIds.json file if it exists.
-     * The session IDs are used to resume sessions for each node.
-     *
-     * The session IDs are stored in the sessionIds.json file as a composite key
-     * of the node identifier and cluster ID. This allows multiple clusters to
-     * be used with the same node identifier.
-     */
-    loadSessionIds(): Promise<void>;
-    /**
-     * Updates the session ID in the sessionIds.json file.
-     *
-     * This method is called after the session ID has been updated, and it
-     * writes the new session ID to the sessionIds.json file.
-     *
-     * @remarks
-     * The session ID is stored in the sessionIds.json file as a composite key
-     * of the node identifier and cluster ID. This allows multiple clusters to
-     * be used with the same node identifier.
-     */
-    updateSessionId(): Promise<void>;
-    private updateSessionIdFile;
-    private updateSessionIdRedis;
-    /**
-     * Connects to the Node.
-     *
-     * @remarks
-     * If the node is already connected, this method will do nothing.
-     * If the node has a session ID, it will be sent in the headers of the WebSocket connection.
-     * If the node has no session ID but the `enableSessionResumeOption` option is true, it will use the session ID
-     * stored in the sessionIds.json file if it exists.
-     */
-    connect(): Promise<void>;
-    /**
-     * Destroys the node and cleans up associated resources.
-     *
-     * This method emits a debug event indicating that the node is being destroyed and attempts
-     * to automatically move all players connected to the node to a usable one. It then closes
-     * the WebSocket connection, removes all event listeners, and clears the reconnect timeout.
-     * Finally, it emits a "nodeDestroy" event and removes the node from the manager.
-     *
-     * @returns {Promise<void>} A promise that resolves when the node and its resources have been destroyed.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Attempts to reconnect to the node if the connection is lost.
-     *
-     * This method is called when the WebSocket connection is closed
-     * unexpectedly. It will attempt to reconnect to the node after a
-     * specified delay, and will continue to do so until the maximum
-     * number of retry attempts is reached or the node is manually destroyed.
-     * If the maximum number of retry attempts is reached, an error event
-     * will be emitted and the node will be destroyed.
-     *
-     * @returns {Promise<void>} - Resolves when the reconnection attempt is scheduled.
-     * @emits {debug} - Emits a debug event indicating the node is attempting to reconnect.
-     * @emits {nodeReconnect} - Emits a nodeReconnect event when the node is attempting to reconnect.
-     * @emits {nodeError} - Emits an error event if the maximum number of retry attempts is reached.
-     * @emits {nodeDestroy} - Emits a nodeDestroy event if the maximum number of retry attempts is reached.
-     */
-    private reconnect;
-    /**
-     * Upgrades the node to a NodeLink.
-     *
-     * @param request - The incoming message.
-     */
-    private upgrade;
-    /**
-     * Handles the "open" event emitted by the WebSocket connection.
-     *
-     * This method is called when the WebSocket connection is established.
-     * It clears any existing reconnect timeouts, emits a debug event
-     * indicating the node is connected, and emits a "nodeConnect" event
-     * with the node as the argument.
-     */
-    protected open(): void;
-    /**
-     * Handles the "close" event emitted by the WebSocket connection.
-     *
-     * This method is called when the WebSocket connection is closed.
-     * It emits a "nodeDisconnect" event with the node and the close event as arguments,
-     * and a debug event indicating the node is disconnected.
-     * It then attempts to move all players connected to that node to a useable one.
-     * If the close event was not initiated by the user, it will also attempt to reconnect.
-     *
-     * @param {number} code The close code of the WebSocket connection.
-     * @param {string} reason The reason for the close event.
-     * @returns {Promise<void>} A promise that resolves when the disconnection is handled.
-     */
-    protected close(code: number, reason: string): Promise<void>;
-    /**
-     * Handles the "error" event emitted by the WebSocket connection.
-     *
-     * This method is called when an error occurs on the WebSocket connection.
-     * It emits a "nodeError" event with the node and the error as arguments and
-     * a debug event indicating the error on the node.
-     * @param {Error} error The error that occurred.
-     */
-    protected error(error: Error): void;
-    /**
-     * Handles incoming messages from the Lavalink WebSocket connection.
-     * @param {Buffer | string} d The message received from the WebSocket connection.
-     * @returns {Promise<void>} A promise that resolves when the message is handled.
-     * @emits {debug} - Emits a debug event with the message received from the WebSocket connection.
-     * @emits {nodeError} - Emits a nodeError event if an unexpected op is received.
-     * @emits {nodeRaw} - Emits a nodeRaw event with the raw message received from the WebSocket connection.
-     * @private
-     */
-    protected message(d: Buffer | string): Promise<void>;
-    /**
-     * Handles an event emitted from the Lavalink node.
-     * @param {PlayerEvent & PlayerEvents} payload The event emitted from the node.
-     * @returns {Promise<void>} A promise that resolves when the event has been handled.
-     * @private
-     */
-    protected handleEvent(payload: PlayerEvent & PlayerEvents): Promise<void>;
-    /**
-     * Emitted when a new track starts playing.
-     * @param {Player} player The player that started playing the track.
-     * @param {Track} track The track that started playing.
-     * @param {TrackStartEvent} payload The payload of the event emitted by the node.
-     * @private
-     */
-    protected trackStart(player: Player, track: Track, payload: TrackStartEvent): void;
-    /**
-     * Emitted when a track ends playing.
-     * @param {Player} player - The player that the track ended on.
-     * @param {Track} track - The track that ended.
-     * @param {TrackEndEvent} payload - The payload of the event emitted by the node.
-     * @private
-     */
-    trackEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
-    /**
-     * Handles autoplay logic for a player.
-     * This method is responsible for selecting an appropriate method of autoplay
-     * and executing it. If autoplay is not enabled or all attempts have failed,
-     * it will return false.
-     * @param {Player} player - The player to handle autoplay for.
-     * @param {number} attempt - The current attempt number of the autoplay.
-     * @returns {Promise<boolean>} A promise that resolves to a boolean indicating if autoplay was successful.
-     * @private
-     */
-    private handleAutoplay;
-    /**
-     * Handles the scenario when a track fails to play or load.
-     * Shifts the queue to the next track and emits a track end event.
-     * If there is no next track, handles the queue end scenario.
-     * If autoplay is enabled, plays the next track.
-     *
-     * @param {Player} player - The player instance associated with the track.
-     * @param {Track} track - The track that failed.
-     * @param {TrackEndEvent} payload - The event payload containing details about the track end.
-     * @returns {Promise<void>} A promise that resolves when the track failure has been processed.
-     * @private
-     */
-    private handleFailedTrack;
-    /**
-     * Handles the scenario when a track is repeated.
-     * Shifts the queue to the next track and emits a track end event.
-     * If there is no next track, handles the queue end scenario.
-     * If autoplay is enabled, plays the next track.
-     *
-     * @param {Player} player - The player instance associated with the track.
-     * @param {Track} track - The track that is repeated.
-     * @param {TrackEndEvent} payload - The event payload containing details about the track end.
-     * @returns {Promise<void>} A promise that resolves when the repeated track has been processed.
-     * @private
-     */
-    private handleRepeatedTrack;
-    /**
-     * Plays the next track in the queue.
-     * Updates the queue by shifting the current track to the previous track
-     * and plays the next track if autoplay is enabled.
-     *
-     * @param {Player} player - The player associated with the track.
-     * @param {Track} track - The track that has ended.
-     * @param {TrackEndEvent} payload - The event payload containing additional data about the track end event.
-     * @returns {void}
-     * @private
-     */
-    private playNextTrack;
-    /**
-     * Handles the event when a queue ends.
-     * If autoplay is enabled, attempts to play the next track in the queue using the autoplay logic.
-     * If all attempts fail, resets the player state and emits the `queueEnd` event.
-     * @param {Player} player - The player associated with the track.
-     * @param {Track} track - The track that has ended.
-     * @param {TrackEndEvent} payload - The event payload containing additional data about the track end event.
-     * @returns {Promise<void>} A promise that resolves when the queue end processing is complete.
-     */
-    queueEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
-    /**
-     * Fetches the lyrics of a track from the Lavalink node.
-     *
-     * If the node is a NodeLink, it will use the `NodeLinkGetLyrics` method to fetch the lyrics.
-     *
-     * Requires the `lavalyrics-plugin` to be present in the Lavalink node.
-     * Requires the `lavasrc-plugin` or `java-lyrics-plugin` to be present in the Lavalink node.
-     *
-     * @param {Track} track - The track to fetch the lyrics for.
-     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @param {string} [language="en"] - The language of the lyrics.
-     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
-     */
-    getLyrics(track: Track, skipTrackSource?: boolean, language?: string): Promise<Lyrics | NodeLinkGetLyrics>;
-    /**
-     * Subscribes to lyrics for a player.
-     * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
-     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @returns {Promise<unknown>} A promise that resolves when the subscription is complete.
-     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
-     */
-    lyricsSubscribe(guildId: string, skipTrackSource?: boolean): Promise<unknown>;
-    /**
-     * Unsubscribes from lyrics for a player.
-     * @param {string} guildId - The ID of the guild to unsubscribe from lyrics for.
-     * @returns {Promise<unknown>} A promise that resolves when the unsubscription is complete.
-     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
-     */
-    lyricsUnsubscribe(guildId: string): Promise<unknown>;
-    /**
-     * Handles the event when a track becomes stuck during playback.
-     * Stops the current track and emits a `trackStuck` event.
-     *
-     * @param {Player} player - The player associated with the track that became stuck.
-     * @param {Track} track - The track that became stuck.
-     * @param {TrackStuckEvent} payload - The event payload containing additional data about the track stuck event.
-     * @returns {void}
-     * @protected
-     */
-    protected trackStuck(player: Player, track: Track, payload: TrackStuckEvent): Promise<void>;
-    /**
-     * Handles the event when a track has an error during playback.
-     * Stops the current track and emits a `trackError` event.
-     *
-     * @param {Player} player - The player associated with the track that had an error.
-     * @param {Track} track - The track that had an error.
-     * @param {TrackExceptionEvent} payload - The event payload containing additional data about the track error event.
-     * @returns {void}
-     * @protected
-     */
-    protected trackError(player: Player, track: Track, payload: TrackExceptionEvent): Promise<void>;
-    /**
-     * Emitted when the WebSocket connection for a player closes.
-     * The payload of the event will contain the close code and reason if provided.
-     * @param {Player} player - The player associated with the WebSocket connection.
-     * @param {WebSocketClosedEvent} payload - The event payload containing additional data about the WebSocket close event.
-     */
-    protected socketClosed(player: Player, payload: WebSocketClosedEvent): void;
-    /**
-     * Emitted when the segments for a track are loaded.
-     * The payload of the event will contain the segments.
-     * @param {Player} player - The player associated with the segments.
-     * @param {Track} track - The track associated with the segments.
-     * @param {SponsorBlockSegmentsLoaded} payload - The event payload containing additional data about the segments loaded event.
-     */
-    private sponsorBlockSegmentLoaded;
-    /**
-     * Emitted when a segment of a track is skipped using the sponsorblock plugin.
-     * The payload of the event will contain the skipped segment.
-     * @param {Player} player - The player associated with the skipped segment.
-     * @param {Track} track - The track associated with the skipped segment.
-     * @param {SponsorBlockSegmentSkipped} payload - The event payload containing additional data about the segment skipped event.
-     */
-    private sponsorBlockSegmentSkipped;
-    /**
-     * Emitted when chapters for a track are loaded using the sponsorblock plugin.
-     * The payload of the event will contain the chapters.
-     * @param {Player} player - The player associated with the chapters.
-     * @param {Track} track - The track associated with the chapters.
-     * @param {SponsorBlockChaptersLoaded} payload - The event payload containing additional data about the chapters loaded event.
-     */
-    private sponsorBlockChaptersLoaded;
-    /**
-     * Emitted when a chapter of a track is started using the sponsorblock plugin.
-     * The payload of the event will contain the started chapter.
-     * @param {Player} player - The player associated with the started chapter.
-     * @param {Track} track - The track associated with the started chapter.
-     * @param {SponsorBlockChapterStarted} payload - The event payload containing additional data about the chapter started event.
-     */
-    private sponsorBlockChapterStarted;
-    /**
-     * Emitted when lyrics for a track are found.
-     * The payload of the event will contain the lyrics.
-     * @param {Player} player - The player associated with the lyrics.
-     * @param {Track} track - The track associated with the lyrics.
-     * @param {LyricsFoundEvent} payload - The event payload containing additional data about the lyrics found event.
-     */
-    private lyricsFound;
-    /**
-     * Emitted when lyrics for a track are not found.
-     * The payload of the event will contain the track.
-     * @param {Player} player - The player associated with the lyrics.
-     * @param {Track} track - The track associated with the lyrics.
-     * @param {LyricsNotFoundEvent} payload - The event payload containing additional data about the lyrics not found event.
-     */
-    private lyricsNotFound;
-    /**
-     * Emitted when a line of lyrics for a track is received.
-     * The payload of the event will contain the lyrics line.
-     * @param {Player} player - The player associated with the lyrics line.
-     * @param {Track} track - The track associated with the lyrics line.
-     * @param {LyricsLineEvent} payload - The event payload containing additional data about the lyrics line event.
-     */
-    private lyricsLine;
-    /**
-     * Fetches Lavalink node information.
-     * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.
-     */
-    fetchInfo(): Promise<LavalinkInfo>;
-    /**
-     * Gets the current sponsorblock segments for a player.
-     * @param {Player} player - The player to get the sponsorblocks for.
-     * @returns {Promise<SponsorBlockSegment[]>} A promise that resolves to the sponsorblock segments.
-     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
-     */
-    getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
-    /**
-     * Sets the sponsorblock segments for a player.
-     * @param {Player} player - The player to set the sponsor blocks for.
-     * @param {SponsorBlockSegment[]} segments - The sponsorblock segments to set. Defaults to `[SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]` if not provided.
-     * @returns {Promise<void>} The promise is resolved when the operation is complete.
-     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
-     * @throws {RangeError} If no segments are provided.
-     * @throws {SyntaxError} If an invalid sponsorblock is provided.
-     * @example
-     * ```ts
-     * // use it on the player via player.setSponsorBlock();
-     * player.setSponsorBlock([SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]);
-     * ```
-     */
-    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
-    /**
-     * Deletes the sponsorblock segments for a player.
-     * @param {Player} player - The player to delete the sponsorblocks for.
-     * @returns {Promise<void>} The promise is resolved when the operation is complete.
-     * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
-     */
-    deleteSponsorBlock(player: Player): Promise<void>;
-    /**
-     * Creates a README.md or README.txt file in the magmastream directory
-     * if it doesn't already exist. This file is used to store player data
-     * for autoresume and other features.
-     * @private
-     */
-    private createReadmeFile;
-}