magmastream 2.9.3-dev.3 → 2.9.3-dev.30

package/dist/structures/Node.d.ts

@@ -0,0 +1,390 @@
+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;
+}