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

package/dist/structures/Node.js

@@ -31,7 +31,6 @@ class Node {
     reconnectTimeout;
     reconnectAttempts = 1;
     redisPrefix;
-    sessionIdsFilePath;
     sessionIdsMap = new Map();
     /**
      * Creates an instance of Node.
@@ -97,18 +96,10 @@ class Node {
         switch (this.manager.options.stateStorage.type) {
             case Enums_1.StateStorageType.Memory:
             case Enums_1.StateStorageType.JSON:
-                this.sessionIdsFilePath = path_1.default.join(process.cwd(), "magmastream", "sessionData", "sessionIds.json");
-                const configDir = path_1.default.dirname(this.sessionIdsFilePath);
-                if (!fs_1.default.existsSync(configDir)) {
-                    fs_1.default.mkdirSync(configDir, { recursive: true });
-                }
-                this.createSessionIdsFile();
                 this.createReadmeFile();
                 break;
             case Enums_1.StateStorageType.Redis:
-                this.redisPrefix = this.manager.options.stateStorage.redisConfig.prefix?.endsWith(":")
-                    ? this.manager.options.stateStorage.redisConfig.prefix
-                    : this.manager.options.stateStorage.redisConfig.prefix ?? "magmastream:";
+                this.redisPrefix = Utils_1.PlayerUtils.getRedisKey();
                 break;
         }
     }
@@ -125,16 +116,19 @@ class Node {
     get address() {
         return `${this.options.host}:${this.options.port}`;
     }
-    /**
-     * Creates the sessionIds.json file if it doesn't exist. This file is used to
-     * store the session IDs for each node. The session IDs are used to identify
-     * the node when resuming a session.
-     */
-    createSessionIdsFile() {
-        if (!fs_1.default.existsSync(this.sessionIdsFilePath)) {
-            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Creating sessionId file at: ${this.sessionIdsFilePath}`);
-            fs_1.default.writeFileSync(this.sessionIdsFilePath, Utils_1.JSONUtils.safe({}), "utf-8");
-        }
+    getCompositeKey() {
+        return `${this.options.identifier}::${this.manager.options.clusterId}`;
+    }
+    getRedisSessionIdsKey() {
+        return `${this.redisPrefix}node:sessionIds`;
+    }
+    getNodeSessionsDir() {
+        return path_1.default.join(process.cwd(), "magmastream", "sessionData", "nodeSessions");
+    }
+    getNodeSessionPath() {
+        const safeId = String(this.options.identifier).replace(/[^a-zA-Z0-9._-]/g, "_");
+        const clusterId = String(this.manager.options.clusterId ?? 0);
+        return path_1.default.join(this.getNodeSessionsDir(), `${safeId}__${clusterId}.txt`);
     }
     /**
      * Loads session IDs from the sessionIds.json file if it exists.
@@ -148,49 +142,43 @@ class Node {
         switch (this.manager.options.stateStorage.type) {
             case Enums_1.StateStorageType.Memory:
             case Enums_1.StateStorageType.JSON: {
-                if (fs_1.default.existsSync(this.sessionIdsFilePath)) {
-                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionIds from file: ${this.sessionIdsFilePath}`);
-                    const sessionIdsData = fs_1.default.readFileSync(this.sessionIdsFilePath, "utf-8");
-                    this.sessionIdsMap = new Map(Object.entries(JSON.parse(sessionIdsData)));
-                    const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                    if (this.sessionIdsMap.has(compositeKey)) {
-                        this.sessionId = this.sessionIdsMap.get(compositeKey);
-                    }
+                const dir = this.getNodeSessionsDir();
+                const filePath = this.getNodeSessionPath();
+                if (!fs_1.default.existsSync(dir))
+                    fs_1.default.mkdirSync(dir, { recursive: true });
+                if (!fs_1.default.existsSync(filePath)) {
+                    this.sessionId = null;
+                    return;
+                }
+                try {
+                    const raw = fs_1.default.readFileSync(filePath, "utf-8").trim();
+                    this.sessionId = raw.length ? raw : null;
+                    if (this.sessionId)
+                        this.sessionIdsMap.set(this.getCompositeKey(), this.sessionId);
+                }
+                catch {
+                    this.sessionId = null;
                 }
                 break;
             }
-            case Enums_1.StateStorageType.Redis:
-                const key = `${this.redisPrefix}node:sessionIds`;
-                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionIds from Redis key: ${key}`);
-                const currentRaw = await this.manager.redis.get(key);
-                if (currentRaw) {
-                    try {
-                        const sessionIds = JSON.parse(currentRaw);
-                        if (typeof sessionIds !== "object" || Array.isArray(sessionIds)) {
-                            throw new MagmastreamError_1.MagmaStreamError({
-                                code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_LOAD_FAILED,
-                                message: "Invalid sessionIds data type from Redis.",
-                                context: { sessionIds },
-                            });
-                        }
-                        this.sessionIdsMap = new Map(Object.entries(sessionIds));
-                        const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                        if (this.sessionIdsMap.has(compositeKey)) {
-                            this.sessionId = this.sessionIdsMap.get(compositeKey) || null;
-                            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Restored sessionId for ${compositeKey}: ${this.sessionId}`);
-                        }
-                    }
-                    catch (err) {
-                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to parse Redis sessionIds: ${err.message}`);
-                        this.sessionIdsMap = new Map();
+            case Enums_1.StateStorageType.Redis: {
+                const key = this.getRedisSessionIdsKey();
+                const compositeKey = this.getCompositeKey();
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionId from Redis hash: ${key} field: ${compositeKey}`);
+                try {
+                    const sid = await this.manager.redis.hget(key, compositeKey);
+                    this.sessionId = sid ?? null;
+                    if (this.sessionId) {
+                        this.sessionIdsMap.set(compositeKey, this.sessionId);
+                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Restored sessionId for ${compositeKey}: ${this.sessionId}`);
                     }
                 }
-                else {
-                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] No sessionIds found in Redis — creating new key.`);
-                    await this.manager.redis.set(key, Utils_1.JSONUtils.safe({}));
-                    this.sessionIdsMap = new Map();
+                catch (err) {
+                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to load sessionId from Redis hash: ${err.message}`);
+                    this.sessionId = null;
                 }
                 break;
+            }
         }
     }
     /**
@@ -207,84 +195,53 @@ class Node {
     async updateSessionId() {
         switch (this.manager.options.stateStorage.type) {
             case Enums_1.StateStorageType.Memory:
-            case Enums_1.StateStorageType.JSON: {
-                const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                const filePath = this.sessionIdsFilePath;
-                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionIds to file: ${filePath}`);
-                let updated = false;
-                let retries = 3;
-                while (!updated && retries > 0) {
-                    try {
-                        let fileData = {};
-                        if (fs_1.default.existsSync(filePath)) {
-                            try {
-                                const raw = fs_1.default.readFileSync(filePath, "utf-8");
-                                fileData = raw.trim() ? JSON.parse(raw) : {};
-                            }
-                            catch (err) {
-                                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to read/parse sessionIds.json: ${err.message}`);
-                                fileData = {};
-                            }
-                        }
-                        fileData[compositeKey] = this.sessionId;
-                        const tmpPath = `${filePath}.tmp`;
-                        fs_1.default.writeFileSync(tmpPath, Utils_1.JSONUtils.safe(fileData, 2), "utf-8");
-                        fs_1.default.renameSync(tmpPath, filePath);
-                        this.sessionIdsMap = new Map(Object.entries(fileData));
-                        updated = true;
-                    }
-                    catch (err) {
-                        retries--;
-                        if (retries === 0) {
-                            throw new MagmastreamError_1.MagmaStreamError({
-                                code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_UPDATE_FAILED,
-                                message: `Failed to update sessionIds after retries.`,
-                                cause: err instanceof Error ? err : undefined,
-                                context: { filePath, compositeKey, storage: "file" },
-                            });
-                        }
-                        await new Promise((r) => setTimeout(r, 50));
-                    }
-                }
-                break;
+            case Enums_1.StateStorageType.JSON:
+                return this.updateSessionIdFile();
+            case Enums_1.StateStorageType.Redis:
+                return this.updateSessionIdRedis();
+        }
+    }
+    async updateSessionIdFile() {
+        const dir = this.getNodeSessionsDir();
+        const filePath = this.getNodeSessionPath();
+        const tmpPath = `${filePath}.tmp`;
+        if (!fs_1.default.existsSync(dir))
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        if (this.sessionId) {
+            fs_1.default.writeFileSync(tmpPath, this.sessionId, "utf-8");
+            fs_1.default.renameSync(tmpPath, filePath);
+            this.sessionIdsMap.set(this.getCompositeKey(), this.sessionId);
+        }
+        else {
+            try {
+                if (fs_1.default.existsSync(filePath))
+                    fs_1.default.unlinkSync(filePath);
             }
-            case Enums_1.StateStorageType.Redis: {
-                const key = `${this.redisPrefix}node:sessionIds`;
-                const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionIds in Redis key: ${key}`);
-                let sessionIds = {};
-                try {
-                    const currentRaw = await this.manager.redis.get(key);
-                    if (currentRaw) {
-                        sessionIds = JSON.parse(currentRaw);
-                        if (typeof sessionIds !== "object" || Array.isArray(sessionIds)) {
-                            throw new Error("Invalid data type in Redis");
-                        }
-                    }
-                    else {
-                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Redis key not found — creating new sessionIds key.`);
-                        sessionIds = {};
-                    }
-                }
-                catch (err) {
-                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Corrupted Redis sessionIds, reinitializing: ${err.message}`);
-                    sessionIds = {};
-                }
-                try {
-                    sessionIds[compositeKey] = this.sessionId;
-                    this.sessionIdsMap = new Map(Object.entries(sessionIds));
-                    await this.manager.redis.set(key, Utils_1.JSONUtils.safe(sessionIds));
-                }
-                catch (err) {
-                    throw new MagmastreamError_1.MagmaStreamError({
-                        code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_UPDATE_FAILED,
-                        message: `Failed to update sessionIds in Redis.`,
-                        cause: err instanceof Error ? err : undefined,
-                        context: { key, compositeKey, storage: "redis" },
-                    });
-                }
-                break;
+            catch { }
+            this.sessionIdsMap.delete(this.getCompositeKey());
+        }
+    }
+    async updateSessionIdRedis() {
+        const key = this.getRedisSessionIdsKey();
+        const compositeKey = this.getCompositeKey();
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionId in Redis hash: ${key} field: ${compositeKey}`);
+        try {
+            if (this.sessionId) {
+                await this.manager.redis.hset(key, compositeKey, this.sessionId);
+                this.sessionIdsMap.set(compositeKey, this.sessionId);
             }
+            else {
+                await this.manager.redis.hdel(key, compositeKey);
+                this.sessionIdsMap.delete(compositeKey);
+            }
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_UPDATE_FAILED,
+                message: "Failed to update sessionId in Redis hash.",
+                cause: err instanceof Error ? err : undefined,
+                context: { key, compositeKey, storage: "redis-hash" },
+            });
         }
     }
     /**
@@ -305,12 +262,7 @@ class Node {
             "User-Id": this.manager.options.clientId,
             "Client-Name": this.manager.options.clientName,
         };
-        const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-        if (this.sessionId) {
-            headers["Session-Id"] = this.sessionId;
-        }
-        else if (this.options.enableSessionResumeOption && this.sessionIdsMap.has(compositeKey)) {
-            this.sessionId = this.sessionIdsMap.get(compositeKey) || null;
+        if (typeof this.sessionId === "string" && this.sessionId.length > 0) {
             headers["Session-Id"] = this.sessionId;
         }
         this.socket = new ws_1.default(`ws${this.options.useSSL ? "s" : ""}://${this.address}/v4/websocket`, { headers });
@@ -356,9 +308,7 @@ class Node {
         // Automove all players connected to that node
         const players = this.manager.players.filter((p) => p.node == this);
         if (players.size) {
-            for (const player of players.values()) {
-                await player.autoMoveNode();
-            }
+            await Promise.all(Array.from(players.values(), (player) => player.autoMoveNode()));
         }
         this.socket.close(1000, "destroy");
         this.socket.removeAllListeners();
@@ -537,10 +487,11 @@ class Node {
             case "ready":
                 this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Node message: ${Utils_1.JSONUtils.safe(payload, 2)}`);
                 this.rest.setSessionId(payload.sessionId);
+                const hadPreviousSession = this.sessionId && this.sessionId !== payload.sessionId;
                 this.sessionId = payload.sessionId;
                 await this.updateSessionId();
                 this.info = await this.fetchInfo();
-                if (payload.resumed) {
+                if (payload.resumed || !hadPreviousSession) {
                     await this.manager.loadPlayerStates(this.options.identifier);
                 }
                 if (this.options.enableSessionResumeOption) {
@@ -1222,8 +1173,12 @@ class Node {
      * @private
      */
     createReadmeFile() {
-        const readmeFilePath = path_1.default.join(process.cwd(), "magmastream", "README.md");
+        const baseDir = path_1.default.join(process.cwd(), "magmastream");
+        const readmeFilePath = path_1.default.join(baseDir, "README.md");
         const message = "Please do NOT delete the magmastream/ folder as it is used to store player data for autoresume etc.";
+        if (!fs_1.default.existsSync(baseDir)) {
+            fs_1.default.mkdirSync(baseDir, { recursive: true });
+        }
         if (!fs_1.default.existsSync(readmeFilePath)) {
             fs_1.default.writeFileSync(readmeFilePath, message, "utf-8");
             this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Created README file at: ${readmeFilePath}`);

package/dist/structures/Player.d.ts

@@ -0,0 +1,347 @@
+import { Filters } from "./Filters";
+import { Manager } from "./Manager";
+import { Node } from "./Node";
+import { AnyMessage, IQueue, Lyrics, PlayerOptions, PlayOptions, SearchQuery, SearchResult, Track, VoiceState } from "./Types";
+import { SponsorBlockSegment, StateTypes } from "./Enums";
+import { WebSocket } from "ws";
+export declare class Player {
+    options: PlayerOptions;
+    /** The Queue for the Player. */
+    queue: IQueue;
+    /** The filters applied to the audio. */
+    filters: Filters;
+    /** Whether the queue repeats the track. */
+    trackRepeat: boolean;
+    /** Whether the queue repeats the queue. */
+    queueRepeat: boolean;
+    /**Whether the queue repeats and shuffles after each song. */
+    dynamicRepeat: boolean;
+    /** The time the player is in the track. */
+    position: number;
+    /** Whether the player is playing. */
+    playing: boolean;
+    /** Whether the player is paused. */
+    paused: boolean;
+    /** The volume for the player */
+    volume: number;
+    /** The Node for the Player. */
+    node: Node;
+    /** The guild ID for the player. */
+    guildId: string;
+    /** The voice channel for the player. */
+    voiceChannelId: string | null;
+    /** The text channel for the player. */
+    textChannelId: string | null;
+    /**The now playing message. */
+    nowPlayingMessage?: AnyMessage;
+    /** The current state of the player. */
+    state: StateTypes;
+    /** The equalizer bands array. */
+    bands: number[];
+    /** The voice state object from Discord. */
+    voiceState: VoiceState;
+    /** The Manager. */
+    manager: Manager;
+    /** The autoplay state of the player. */
+    isAutoplay: boolean;
+    /** The number of times to try autoplay before emitting queueEnd. */
+    autoplayTries: number;
+    /** The cluster ID for the player. */
+    clusterId: number;
+    private readonly data;
+    private dynamicLoopInterval;
+    dynamicRepeatIntervalMs: number | null;
+    private static _manager;
+    /** Should only be used when the node is a NodeLink */
+    protected voiceReceiverWsClient: WebSocket | null;
+    protected isConnectToVoiceReceiver: boolean;
+    protected voiceReceiverReconnectTimeout: NodeJS.Timeout | null;
+    protected voiceReceiverAttempt: number;
+    protected voiceReceiverReconnectTries: number;
+    /**
+     * Creates a new player, returns one if it already exists.
+     * @param options The player options.
+     * @see https://docs.magmastream.com/main/introduction/getting-started
+     */
+    constructor(options: PlayerOptions);
+    /**
+     * Initializes the static properties of the Player class.
+     * @hidden
+     * @param manager The Manager to use.
+     */
+    static init(manager: Manager): void;
+    /**
+     * Set custom data.
+     * @param key - The key to set the data for.
+     * @param value - The value to set the data to.
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Retrieves custom data associated with a given key.
+     * @template T - The expected type of the data.
+     * @param {string} key - The key to retrieve the data for.
+     * @returns {T} - The data associated with the key, cast to the specified type.
+     */
+    get<T>(key: string): T;
+    /**
+     * Same as Manager#search() but a shortcut on the player itself.
+     * @param query
+     * @param requester
+     */
+    search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
+    /**
+     * Connects the player to the voice channel.
+     * @throws {RangeError} If no voice channel has been set.
+     * @returns {void}
+     */
+    connect(): void;
+    /**
+     * Disconnects the player from the voice channel.
+     * @returns {this} The player instance.
+     */
+    disconnect(): Promise<this>;
+    /**
+     * Destroys the player and clears the queue.
+     * @param {boolean} disconnect - Whether to disconnect the player from the voice channel.
+     * @returns {Promise<boolean>} - Whether the player was successfully destroyed.
+     * @emits {PlayerDestroy} - Emitted when the player is destroyed.
+     * @emits {PlayerStateUpdate} - Emitted when the player state is updated.
+     */
+    destroy(disconnect?: boolean): Promise<boolean>;
+    /**
+     * Sets the player voice channel.
+     * @param {string} channel - The new voice channel ID.
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the channel parameter is not a string.
+     */
+    setVoiceChannelId(channel: string): this;
+    /**
+     * Sets the player text channel.
+     *
+     * This method updates the text channel associated with the player. It also
+     * emits a player state update event indicating the change in the channel.
+     *
+     * @param {string} channel - The new text channel ID.
+     * @returns {this} - The player instance for method chaining.
+     * @throws {TypeError} If the channel parameter is not a string.
+     */
+    setTextChannelId(channel: string): this;
+    /**
+     * Sets the now playing message.
+     *
+     * @param message - The message of the now playing message.
+     * @returns The now playing message.
+     */
+    setNowPlayingMessage(message: AnyMessage): AnyMessage;
+    /**
+     * Plays the next track.
+     *
+     * If a track is provided, it will be played. Otherwise, the next track in the queue will be played.
+     * If the queue is not empty, but the current track has not finished yet, it will be replaced with the provided track.
+     *
+     * @param {object} [optionsOrTrack] - The track to play or the options to play with.
+     * @param {object} [playOptions] - The options to play with.
+     *
+     * @returns {Promise<void>}
+     */
+    play(): Promise<Player>;
+    play(track: Track): Promise<Player>;
+    play(options: PlayOptions): Promise<Player>;
+    play(track: Track, options: PlayOptions): Promise<Player>;
+    /**
+     * Sets the autoplay-state of the player.
+     *
+     * Autoplay is a feature that makes the player play a recommended
+     * track when the current track ends.
+     *
+     * @param {boolean} autoplayState - Whether or not autoplay should be enabled.
+     * @param {object} AutoplayUser - The user-object that should be used as the bot-user.
+     * @param {number} [tries=3] - The number of times the player should try to find a
+     * recommended track if the first one doesn't work.
+     * @returns {this} - The player instance.
+     */
+    setAutoplay<T = unknown>(autoplayState: boolean, AutoplayUser?: T, tries?: number): this;
+    /**
+     * Gets recommended tracks and returns an array of tracks.
+     * @param {Track} track - The track to find recommendations for.
+     * @returns {Promise<Track[]>} - Array of recommended tracks.
+     */
+    getRecommendedTracks(track: Track): Promise<Track[]>;
+    /**
+     * Sets the volume of the player.
+     * @param {number} volume - The new volume. Must be between 0 and 500 when using filter mode (100 = 100%).
+     * @returns {Promise<Player>} - The updated player.
+     * @throws {TypeError} If the volume is not a number.
+     * @throws {RangeError} If the volume is not between 0 and 500 when using filter mode (100 = 100%).
+     * @emits {PlayerStateUpdate} - Emitted when the volume is changed.
+     * @example
+     * player.setVolume(50);
+     */
+    setVolume(volume: number): Promise<this>;
+    /**
+     * Sets the sponsorblock for the player. This will set the sponsorblock segments for the player to the given segments.
+     * @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.
+     */
+    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    /**
+     * Gets the sponsorblock for the player.
+     * @returns {Promise<SponsorBlockSegment[]>} The sponsorblock segments.
+     */
+    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    /**
+     * Deletes the sponsorblock for the player. This will remove all sponsorblock segments that have been set for the player.
+     * @returns {Promise<void>}
+     */
+    deleteSponsorBlock(): Promise<void>;
+    /**
+     * Sets the track repeat mode.
+     * When track repeat is enabled, the current track will replay after it ends.
+     * Disables queueRepeat and dynamicRepeat modes if enabled.
+     *
+     * @param repeat - A boolean indicating whether to enable track repeat.
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the repeat parameter is not a boolean.
+     */
+    setTrackRepeat(repeat: boolean): this;
+    /**
+     * Sets the queue repeat.
+     * @param repeat Whether to repeat the queue or not
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the repeat parameter is not a boolean
+     */
+    setQueueRepeat(repeat: boolean): this;
+    /**
+     * Sets the queue to repeat and shuffles the queue after each song.
+     * @param repeat "true" or "false".
+     * @param ms After how many milliseconds to trigger dynamic repeat.
+     * @returns {this} - The player instance.
+     * @throws {TypeError} If the repeat parameter is not a boolean.
+     * @throws {RangeError} If the queue size is less than or equal to 1.
+     */
+    setDynamicRepeat(repeat: boolean, ms: number): Promise<this>;
+    /**
+     * Restarts the currently playing track from the beginning.
+     * If there is no track playing, it will play the next track in the queue.
+     * @returns {Promise<Player>} The current instance of the Player class for method chaining.
+     */
+    restart(): Promise<Player>;
+    /**
+     * Stops the player and optionally removes tracks from the queue.
+     * @param {number} [amount] The amount of tracks to remove from the queue. If not provided, removes the current track if it exists.
+     * @returns {Promise<this>} - The player instance.
+     * @throws {RangeError} If the amount is greater than the queue length.
+     */
+    stop(amount?: number): Promise<this>;
+    /**
+     * Skips the current track.
+     * @returns {this} - The player instance.
+     * @throws {Error} If there are no tracks in the queue.
+     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
+     */
+    pause(pause: boolean): Promise<this>;
+    /**
+     * Skips to the previous track in the queue.
+     * @returns {this} - The player instance.
+     * @throws {Error} If there are no previous tracks in the queue.
+     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
+     */
+    previous(addBackToQueue?: boolean): Promise<this>;
+    /**
+     * Seeks to a given position in the currently playing track.
+     * @param position - The position in milliseconds to seek to.
+     * @returns {this} - The player instance.
+     * @throws {Error} If the position is invalid.
+     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
+     */
+    seek(position: number): Promise<this>;
+    /**
+     * Returns the current repeat state of the player.
+     * @param player The player to get the repeat state from.
+     * @returns The repeat state of the player, or null if it is not repeating.
+     */
+    private getRepeatState;
+    /**
+     * Automatically moves the player to a usable node.
+     * @returns {Promise<Player | void>} - The player instance or void if not moved.
+     */
+    autoMoveNode(): Promise<Player | void>;
+    /**
+     * Moves the player to another node.
+     * @param {string} identifier - The identifier of the node to move to.
+     * @returns {Promise<Player>} - The player instance after being moved.
+     */
+    moveNode(identifier: string): Promise<Player>;
+    /**
+     * Retrieves the data associated with the player.
+     * @returns {Record<string, unknown>} - The data associated with the player.
+     */
+    getData(): Record<string, unknown>;
+    /**
+     * Retrieves the dynamic loop interval of the player.
+     * @returns {NodeJS.Timeout | null} - The dynamic loop interval of the player.
+     */
+    getDynamicLoopIntervalPublic(): NodeJS.Timeout | null;
+    /**
+     * Retrieves the data associated with the player.
+     * @returns {Record<string, unknown>} - The data associated with the player.
+     */
+    getSerializableData(): Record<string, unknown>;
+    /**
+     * Retrieves the current lyrics for the playing track.
+     * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.
+     * @returns {Promise<Lyrics>} - The lyrics of the current track.
+     */
+    getCurrentLyrics(skipTrackSource?: boolean): Promise<Lyrics>;
+    /**
+     * Sets up the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is set up.
+     * @throws {Error} - If the node is not a NodeLink.
+     */
+    setupVoiceReceiver(): Promise<void>;
+    /**
+     * Removes the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is removed.
+     * @throws {Error} - If the node is not a NodeLink.
+     */
+    removeVoiceReceiver(): Promise<void>;
+    /**
+     * Closes the voice receiver for the player.
+     * @param {number} code - The code to close the voice receiver with.
+     * @param {string} reason - The reason to close the voice receiver with.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is closed.
+     */
+    private closeVoiceReceiver;
+    /**
+     * Reconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is reconnected.
+     */
+    private reconnectVoiceReceiver;
+    /**
+     * Disconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is disconnected.
+     */
+    private disconnectVoiceReceiver;
+    /**
+     * Opens the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is opened.
+     */
+    private openVoiceReceiver;
+    /**
+     * Handles a voice receiver message.
+     * @param {string} payload - The payload to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
+     */
+    private onVoiceReceiverMessage;
+    /**
+     * Handles a voice receiver error.
+     * @param {Error} error - The error to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver error is handled.
+     */
+    private onVoiceReceiverError;
+    /**
+     * Updates the voice state for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice state is updated.
+     */
+    updateVoice(): Promise<void>;
+}