magmastream 2.9.3-dev.3 → 2.9.3-dev.31

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>;
+}

package/dist/structures/Player.js

@@ -82,7 +82,7 @@ class Player {
                 message: "Manager instance is required.",
             });
         }
-        this.clusterId = this.manager.options.clusterId || 0;
+        this.clusterId = this.manager.options.clusterId ?? 0;
         // Check the player options for errors.
         (0, playerCheck_1.default)(options);
         this.options = {
@@ -260,21 +260,30 @@ class Player {
      */
     async destroy(disconnect = true) {
         this.state = Enums_1.StateTypes.Destroying;
+        if (this.dynamicLoopInterval) {
+            clearInterval(this.dynamicLoopInterval);
+            this.dynamicLoopInterval = null;
+        }
+        if (this.voiceReceiverReconnectTimeout) {
+            clearTimeout(this.voiceReceiverReconnectTimeout);
+            this.voiceReceiverReconnectTimeout = null;
+        }
+        if (this.voiceReceiverWsClient) {
+            this.voiceReceiverWsClient.removeAllListeners();
+            this.voiceReceiverWsClient.close();
+            this.voiceReceiverWsClient = null;
+        }
         if (disconnect) {
-            await this.disconnect().catch((err) => {
-                console.warn(`[Player#destroy] Failed to disconnect player ${this.guildId}:`, err);
-            });
+            await this.disconnect().catch(() => { });
         }
-        await this.node.rest.destroyPlayer(this.guildId).catch((err) => {
-            console.warn(`[Player#destroy] REST failed to destroy player ${this.guildId}:`, err);
-        });
-        await this.queue.clear();
-        await this.queue.clearPrevious();
-        await this.queue.setCurrent(null);
+        await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
+        await this.queue.destroy();
+        this.nowPlayingMessage = undefined;
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerDestroy, this);
         const deleted = this.manager.players.delete(this.guildId);
-        if (this.manager.options.stateStorage.deleteInactivePlayers)
+        if (this.manager.options.stateStorage.deleteDestroyedPlayers) {
             await this.manager.cleanupInactivePlayer(this.guildId);
+        }
         return deleted;
     }
     /**
@@ -374,11 +383,8 @@ class Player {
             console.error(error);
             return this;
         }
-        const finalOptions = playOptions
-            ? playOptions
-            : ["startTime", "endTime", "noReplace"].every((v) => Object.keys(optionsOrTrack || {}).includes(v))
-                ? optionsOrTrack
-                : {};
+        const isPlayOptions = (v) => typeof v === "object" && v !== null && ("startTime" in v || "endTime" in v || "noReplace" in v);
+        const finalOptions = playOptions ? playOptions : isPlayOptions(optionsOrTrack) ? optionsOrTrack : {};
         await this.node.rest.updatePlayer({
             guildId: this.guildId,
             data: {
@@ -387,7 +393,7 @@ class Player {
             },
         });
         this.playing = true;
-        this.position = 0;
+        this.position = finalOptions.startTime || 0;
         return this;
     }
     /**
@@ -806,11 +812,8 @@ class Player {
             if (currentPlayingTrack) {
                 await this.queue.add(currentPlayingTrack, 0);
             }
-            await this.play(lastTrack);
-        }
-        else {
-            await this.play(lastTrack);
         }
+        await this.play(lastTrack);
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
             changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
@@ -922,7 +925,8 @@ class Player {
             const sessionId = this.voiceState?.sessionId;
             const token = this.voiceState?.event?.token;
             const endpoint = this.voiceState?.event?.endpoint;
-            if (!sessionId || !token || !endpoint) {
+            const channelId = this.voiceState?.channelId;
+            if (!sessionId || !token || !endpoint || !channelId) {
                 this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Voice state is not properly initialized for player ${this.guildId}. The bot might not be connected to a voice channel.`);
                 throw new MagmastreamError_1.MagmaStreamError({
                     code: Enums_1.MagmaStreamErrorCode.PLAYER_STATE_INVALID,
@@ -936,7 +940,7 @@ class Player {
             this.manager.players.set(this.guildId, this);
             await this.node.rest.updatePlayer({
                 guildId: this.guildId,
-                data: { paused: this.paused, volume: this.volume, position: playerPosition, encodedTrack: currentTrack?.track, voice: { token, endpoint, sessionId } },
+                data: { paused: this.paused, volume: this.volume, position: playerPosition, encodedTrack: currentTrack?.track, voice: { token, endpoint, sessionId, channelId } },
             });
             await this.filters.updateFilters();
         }
@@ -953,115 +957,6 @@ class Player {
             console.error(error);
         }
     }
-    /**
-     * Transfers the player to a new server. If the player already exists on the new server
-     * and force is false, this method will return the existing player. Otherwise, a new player
-     * will be created and the current player will be destroyed.
-     * @param {PlayerOptions} newOptions - The new options for the player.
-     * @param {boolean} force - Whether to force the creation of a new player.
-     * @returns {Promise<Player>} - The new player instance.
-     */
-    async switchGuild(newOptions, force = false) {
-        if (!newOptions.guildId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "guildId is required for switchGuild",
-            });
-        }
-        if (!newOptions.voiceChannelId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "voiceChannelId is required for switchGuild",
-            });
-        }
-        if (!newOptions.textChannelId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "textChannelId is required for switchGuild",
-            });
-        }
-        // Check if a player already exists for the new guild
-        let newPlayer = this.manager.getPlayer(newOptions.guildId);
-        // If the player already exists and force is false, return the existing player
-        if (newPlayer && !force)
-            return newPlayer;
-        const oldPlayerProperties = {
-            paused: this.paused,
-            selfMute: this.options.selfMute,
-            selfDeafen: this.options.selfDeafen,
-            volume: this.volume,
-            position: this.position,
-            queue: {
-                current: await this.queue.getCurrent(),
-                tracks: [...(await this.queue.getTracks())],
-                previous: [...(await this.queue.getPrevious())],
-            },
-            trackRepeat: this.trackRepeat,
-            queueRepeat: this.queueRepeat,
-            dynamicRepeat: this.dynamicRepeat,
-            dynamicRepeatIntervalMs: this.dynamicRepeatIntervalMs,
-            ClientUser: this.get("Internal_AutoplayUser"),
-            filters: this.filters,
-            nowPlayingMessage: this.nowPlayingMessage,
-            isAutoplay: this.isAutoplay,
-            applyVolumeAsFilter: this.options.applyVolumeAsFilter,
-            pauseOnDisconnect: this.options.pauseOnDisconnect,
-        };
-        // If force is true, destroy the existing player for the new guild
-        if (force && newPlayer) {
-            await newPlayer.destroy();
-        }
-        newOptions.nodeIdentifier = newOptions.nodeIdentifier ?? this.options.nodeIdentifier;
-        newOptions.selfDeafen = newOptions.selfDeafen ?? oldPlayerProperties.selfDeafen;
-        newOptions.selfMute = newOptions.selfMute ?? oldPlayerProperties.selfMute;
-        newOptions.volume = newOptions.volume ?? oldPlayerProperties.volume;
-        newOptions.applyVolumeAsFilter = newOptions.applyVolumeAsFilter ?? oldPlayerProperties.applyVolumeAsFilter;
-        newOptions.pauseOnDisconnect = newOptions.pauseOnDisconnect ?? oldPlayerProperties.pauseOnDisconnect;
-        // Deep clone the current player
-        const clonedPlayer = this.manager.create(newOptions);
-        // Connect the cloned player to the new voice channel
-        clonedPlayer.connect();
-        // Update the player's state on the Lavalink node
-        await clonedPlayer.node.rest.updatePlayer({
-            guildId: clonedPlayer.guildId,
-            data: {
-                paused: oldPlayerProperties.paused,
-                volume: oldPlayerProperties.volume,
-                position: oldPlayerProperties.position,
-                encodedTrack: oldPlayerProperties.queue.current?.track,
-            },
-        });
-        await clonedPlayer.queue.setCurrent(oldPlayerProperties.queue.current);
-        await clonedPlayer.queue.addPrevious(oldPlayerProperties.queue.previous);
-        await clonedPlayer.queue.add(oldPlayerProperties.queue.tracks);
-        clonedPlayer.filters = oldPlayerProperties.filters;
-        clonedPlayer.isAutoplay = oldPlayerProperties.isAutoplay;
-        clonedPlayer.nowPlayingMessage = oldPlayerProperties.nowPlayingMessage;
-        clonedPlayer.trackRepeat = oldPlayerProperties.trackRepeat;
-        clonedPlayer.queueRepeat = oldPlayerProperties.queueRepeat;
-        clonedPlayer.dynamicRepeat = oldPlayerProperties.dynamicRepeat;
-        clonedPlayer.dynamicRepeatIntervalMs = oldPlayerProperties.dynamicRepeatIntervalMs;
-        clonedPlayer.set("Internal_AutoplayUser", oldPlayerProperties.ClientUser);
-        clonedPlayer.paused = oldPlayerProperties.paused;
-        // Update filters for the cloned player
-        await clonedPlayer.filters.updateFilters();
-        // Debug information
-        const debugInfo = {
-            success: true,
-            message: `Transferred ${await clonedPlayer.queue.size()} tracks successfully to <#${newOptions.voiceChannelId}> bound to <#${newOptions.textChannelId}>.`,
-            player: {
-                guildId: clonedPlayer.guildId,
-                voiceChannelId: clonedPlayer.voiceChannelId,
-                textChannelId: clonedPlayer.textChannelId,
-                volume: clonedPlayer.volume,
-                playing: clonedPlayer.playing,
-                queueSize: clonedPlayer.queue.size,
-            },
-        };
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Transferred player to a new server: ${Utils_1.JSONUtils.safe(debugInfo, 2)}.`);
-        // Return the cloned player
-        return clonedPlayer;
-    }
     /**
      * Retrieves the data associated with the player.
      * @returns {Record<string, unknown>} - The data associated with the player.
@@ -1076,6 +971,13 @@ class Player {
     getDynamicLoopIntervalPublic() {
         return this.dynamicLoopInterval;
     }
+    /**
+     * Retrieves the data associated with the player.
+     * @returns {Record<string, unknown>} - The data associated with the player.
+     */
+    getSerializableData() {
+        return { ...this.data };
+    }
     /**
      * Retrieves the current lyrics for the playing track.
      * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.
@@ -1239,5 +1141,26 @@ class Player {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver error for player ${this.guildId}: ${error.message}`);
         this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverError, this, error);
     }
+    /**
+     * Updates the voice state for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice state is updated.
+     */
+    async updateVoice() {
+        const vs = this.voiceState;
+        const ev = vs?.event;
+        if (!vs?.channelId || !vs?.sessionId || !ev?.token || !ev?.endpoint)
+            return;
+        await this.node.rest.updatePlayer({
+            guildId: this.options.guildId,
+            data: {
+                voice: {
+                    token: ev.token,
+                    endpoint: ev.endpoint,
+                    sessionId: vs.sessionId,
+                    channelId: vs.channelId,
+                },
+            },
+        });
+    }
 }
 exports.Player = Player;

package/dist/structures/Plugin.d.ts

@@ -0,0 +1,23 @@
+import { Manager } from "./Manager";
+/**
+ * Base abstract class for all plugins.
+ * Users must extend this and implement load and unload methods.
+ */
+export declare abstract class Plugin {
+    readonly name: string;
+    /**
+     * @param name The name of the plugin
+     */
+    constructor(name: string);
+    /**
+     * Load the plugin.
+     * @param manager The MagmaStream Manager instance
+     */
+    abstract load(manager: Manager): void;
+    /**
+     * Unload the plugin.
+     * Called on shutdown to gracefully cleanup resources or detach listeners.
+     * @param manager The MagmaStream Manager instance
+     */
+    abstract unload(manager: Manager): void;
+}