magmastream 2.9.0-dev.9 → 2.9.1-dev.0

package/dist/structures/Player.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = void 0;
 const tslib_1 = require("tslib");
 const Filters_1 = require("./Filters");
-const Manager_1 = require("./Manager");
-const Node_1 = require("./Node");
-const Queue_1 = require("./Queue");
+const MemoryQueue_1 = require("../statestorage/MemoryQueue");
 const Utils_1 = require("./Utils");
 const _ = tslib_1.__importStar(require("lodash"));
 const playerCheck_1 = tslib_1.__importDefault(require("../utils/playerCheck"));
-const RedisQueue_1 = require("./RedisQueue");
+const RedisQueue_1 = require("../statestorage/RedisQueue");
+const Enums_1 = require("./Enums");
+const ws_1 = require("ws");
+const JsonQueue_1 = require("../statestorage/JsonQueue");
 class Player {
     options;
     /** The Queue for the Player. */
@@ -41,7 +42,7 @@ class Player {
     /**The now playing message. */
     nowPlayingMessage;
     /** The current state of the player. */
-    state = Utils_1.StateTypes.Disconnected;
+    state = Enums_1.StateTypes.Disconnected;
     /** The equalizer bands array. */
     bands = new Array(15).fill(0.0);
     /** The voice state object from Discord. */
@@ -52,10 +53,18 @@ class Player {
     isAutoplay = false;
     /** The number of times to try autoplay before emitting queueEnd. */
     autoplayTries = 3;
-    static _manager;
+    /** The cluster ID for the player. */
+    clusterId = 0;
     data = {};
     dynamicLoopInterval = null;
     dynamicRepeatIntervalMs = null;
+    static _manager;
+    /** Should only be used when the node is a NodeLink */
+    voiceReceiverWsClient;
+    isConnectToVoiceReceiver;
+    voiceReceiverReconnectTimeout;
+    voiceReceiverAttempt;
+    voiceReceiverReconnectTries;
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
@@ -68,6 +77,7 @@ class Player {
             this.manager = Utils_1.Structure.get("Player")._manager;
         if (!this.manager)
             throw new RangeError("Manager has not been initiated.");
+        this.clusterId = this.manager.options.clusterId || 0;
         // Check the player options for errors.
         (0, playerCheck_1.default)(options);
         // Set the guild ID and voice state.
@@ -82,29 +92,40 @@ class Player {
         if (options.textChannelId)
             this.textChannelId = options.textChannelId;
         // Set the node to use, either the specified node or the first available node.
-        const node = this.manager.nodes.get(options.node);
+        const node = this.manager.nodes.get(options.nodeIdentifier);
         this.node = node || this.manager.useableNode;
         // If no node is available, throw an error.
         if (!this.node)
             throw new RangeError("No available nodes.");
         // Initialize the queue with the guild ID and manager.
-        if (this.manager.options.stateStorage.type === Manager_1.StateStorageType.Redis) {
-            this.queue = new RedisQueue_1.RedisQueue(this.guildId, this.manager);
-        }
-        else {
-            this.queue = new Queue_1.Queue(this.guildId, this.manager);
-        }
-        if (this.queue instanceof Queue_1.Queue) {
-            this.queue.previous = [];
+        switch (this.manager.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Redis:
+                this.queue = new RedisQueue_1.RedisQueue(this.guildId, this.manager);
+                break;
+            case Enums_1.StateStorageType.Memory:
+                this.queue = new MemoryQueue_1.MemoryQueue(this.guildId, this.manager);
+                break;
+            case Enums_1.StateStorageType.JSON:
+                this.queue = new JsonQueue_1.JsonQueue(this.guildId, this.manager);
+                break;
         }
         // Add the player to the manager's player collection.
         this.manager.players.set(options.guildId, this);
         // Set the initial volume.
         this.setVolume(options.volume ?? 100);
         // Initialize the filters.
-        this.filters = new Filters_1.Filters(this);
+        this.filters = new Filters_1.Filters(this, this.manager);
         // Emit the playerCreate event.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerCreate, this);
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerCreate, this);
+    }
+    /**
+     * Initializes the static properties of the Player class.
+     * @hidden
+     * @param manager The Manager to use.
+     */
+    static init(manager) {
+        // Set the Manager to use.
+        this._manager = manager;
     }
     /**
      * Set custom data.
@@ -125,15 +146,6 @@ class Player {
         // Access the data object using the key and cast it to the specified type T.
         return this.data[key];
     }
-    /**
-     * Initializes the static properties of the Player class.
-     * @hidden
-     * @param manager The Manager to use.
-     */
-    static init(manager) {
-        // Set the Manager to use.
-        this._manager = manager;
-    }
     /**
      * Same as Manager#search() but a shortcut on the player itself.
      * @param query
@@ -153,11 +165,10 @@ class Player {
             throw new RangeError("No voice channel has been set. You must use the `setVoiceChannelId()` method to set the voice channel before connecting.");
         }
         // Set the player state to connecting.
-        this.state = Utils_1.StateTypes.Connecting;
+        this.state = Enums_1.StateTypes.Connecting;
         // Clone the current player state for comparison.
         const oldPlayer = this ? { ...this } : null;
-        // Send the voice state update to the gateway.
-        this.manager.options.send(this.guildId, {
+        this.manager.sendPacket({
             op: 4,
             d: {
                 guild_id: this.guildId,
@@ -167,49 +178,50 @@ class Player {
             },
         });
         // Set the player state to connected.
-        this.state = Utils_1.StateTypes.Connected;
+        this.state = Enums_1.StateTypes.Connected;
         // Emit the player state update event.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.ConnectionChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.ConnectionChange,
             details: {
-                changeType: "connect",
-                previousConnection: oldPlayer?.state === Utils_1.StateTypes.Connected,
+                type: "connection",
+                action: "connect",
+                previousConnection: oldPlayer?.state === Enums_1.StateTypes.Connected,
                 currentConnection: true,
             },
         });
     }
     /**
      * Disconnects the player from the voice channel.
-     * @throws {TypeError} If the player is not connected.
-     * @returns {this} - The current instance of the Player class for method chaining.
+     * @returns {this} The player instance.
      */
     async disconnect() {
         // Set the player state to disconnecting.
-        this.state = Utils_1.StateTypes.Disconnecting;
+        this.state = Enums_1.StateTypes.Disconnecting;
         // Clone the current player state for comparison.
         const oldPlayer = this ? { ...this } : null;
         // Pause the player.
         await this.pause(true);
         // Send the voice state update to the gateway.
-        this.manager.options.send(this.guildId, {
+        this.manager.sendPacket({
             op: 4,
             d: {
                 guild_id: this.guildId,
                 channel_id: null,
-                self_mute: false,
-                self_deaf: false,
+                self_mute: null,
+                self_deaf: null,
             },
         });
         // Set the player voice channel to null.
         this.voiceChannelId = null;
         // Set the player state to disconnected.
-        this.state = Utils_1.StateTypes.Disconnected;
+        this.state = Enums_1.StateTypes.Disconnected;
         // Emit the player state update event.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.ConnectionChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.ConnectionChange,
             details: {
-                changeType: "disconnect",
-                previousConnection: oldPlayer.state === Utils_1.StateTypes.Connected,
+                type: "connection",
+                action: "disconnect",
+                previousConnection: oldPlayer.state === Enums_1.StateTypes.Connected,
                 currentConnection: false,
             },
         });
@@ -223,21 +235,22 @@ class Player {
      * @emits {PlayerStateUpdate} - Emitted when the player state is updated.
      */
     async destroy(disconnect = true) {
-        const oldPlayer = this ? { ...this } : null;
-        this.state = Utils_1.StateTypes.Destroying;
+        this.state = Enums_1.StateTypes.Destroying;
         if (disconnect) {
-            await this.disconnect();
+            await this.disconnect().catch((err) => {
+                console.warn(`[Player#destroy] Failed to disconnect player ${this.guildId}:`, err);
+            });
         }
-        await this.node.rest.destroyPlayer(this.guildId);
-        await this.queue.clear();
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, null, {
-            changeType: Manager_1.PlayerStateEventTypes.PlayerDestroy,
+        await this.node.rest.destroyPlayer(this.guildId).catch((err) => {
+            console.warn(`[Player#destroy] REST failed to destroy player ${this.guildId}:`, err);
         });
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerDestroy, this);
+        await this.queue.clear();
+        await this.queue.clearPrevious();
+        await this.queue.setCurrent(null);
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerDestroy, this);
         const deleted = this.manager.players.delete(this.guildId);
-        if (!deleted) {
-            console.warn(`Failed to delete player with guildId: ${this.guildId}`);
-        }
+        if (this.manager.options.stateStorage.deleteInactivePlayers)
+            await this.manager.cleanupInactivePlayer(this.guildId);
         return deleted;
     }
     /**
@@ -254,12 +267,14 @@ class Player {
         const oldPlayer = this ? { ...this } : null;
         // Update the player voice channel
         this.voiceChannelId = channel;
+        this.options.voiceChannelId = channel;
         this.connect();
         // Emit a player state update event
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.ChannelChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.ChannelChange,
             details: {
-                changeType: "voice",
+                type: "channel",
+                action: "voice",
                 previousChannel: oldPlayer.voiceChannelId || null,
                 currentChannel: this.voiceChannelId,
             },
@@ -284,11 +299,13 @@ class Player {
         const oldPlayer = this ? { ...this } : null;
         // Update the text channel property
         this.textChannelId = channel;
+        this.options.textChannelId = channel;
         // Emit a player state update event with channel change details
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.ChannelChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.ChannelChange,
             details: {
-                changeType: "text",
+                type: "channel",
+                action: "text",
                 previousChannel: oldPlayer.textChannelId || null,
                 currentChannel: this.textChannelId,
             },
@@ -364,9 +381,11 @@ class Player {
             this.set("Internal_BotUser", null);
         }
         const oldPlayer = { ...this };
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.AutoPlayChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.AutoPlayChange,
             details: {
+                type: "autoplay",
+                action: "toggle",
                 previousAutoplay: oldPlayer.isAutoplay,
                 currentAutoplay: this.isAutoplay,
             },
@@ -391,23 +410,28 @@ class Player {
      * @emits {PlayerStateUpdate} - Emitted when the volume is changed.
      * @example
      * player.setVolume(50);
+     * player.setVolume(50, { gradual: true, interval: 50, step: 5 });
      */
     async setVolume(volume) {
         if (isNaN(volume))
             throw new TypeError("Volume must be a number.");
         if (volume < 0 || volume > 1000)
             throw new RangeError("Volume must be between 0 and 1000.");
-        const oldPlayer = this ? { ...this } : null;
+        const oldVolume = this.volume;
+        const oldPlayer = { ...this };
         await this.node.rest.updatePlayer({
             guildId: this.options.guildId,
-            data: {
-                volume,
-            },
+            data: { volume },
         });
         this.volume = volume;
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.VolumeChange,
-            details: { previousVolume: oldPlayer.volume || null, currentVolume: this.volume },
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.VolumeChange,
+            details: {
+                type: "volume",
+                action: "adjust",
+                previousVolume: oldVolume,
+                currentVolume: this.volume,
+            },
         });
         return this;
     }
@@ -416,7 +440,7 @@ class Player {
      * @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.
      */
-    async setSponsorBlock(segments = [Node_1.SponsorBlockSegment.Sponsor, Node_1.SponsorBlockSegment.SelfPromo]) {
+    async setSponsorBlock(segments = [Enums_1.SponsorBlockSegment.Sponsor, Enums_1.SponsorBlockSegment.SelfPromo]) {
         return this.node.setSponsorBlock(this, segments);
     }
     /**
@@ -461,10 +485,11 @@ class Player {
             this.dynamicRepeat = false;
         }
         // Emit an event indicating the repeat mode has changed
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.RepeatChange,
-            detail: {
-                changeType: "track",
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.RepeatChange,
+            details: {
+                type: "repeat",
+                action: "track",
                 previousRepeat: this.getRepeatState(oldPlayer),
                 currentRepeat: this.getRepeatState(this),
             },
@@ -495,10 +520,11 @@ class Player {
             this.dynamicRepeat = false;
         }
         // Emit the player state update event
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.RepeatChange,
-            detail: {
-                changeType: "queue",
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.RepeatChange,
+            details: {
+                type: "repeat",
+                action: "queue",
                 previousRepeat: this.getRepeatState(oldPlayer),
                 currentRepeat: this.getRepeatState(this),
             },
@@ -551,10 +577,11 @@ class Player {
             this.dynamicRepeat = false;
         }
         // Emit a player state update event
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.RepeatChange,
-            detail: {
-                changeType: "dynamic",
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.RepeatChange,
+            details: {
+                type: "repeat",
+                action: "dynamic",
                 previousRepeat: this.getRepeatState(oldPlayer),
                 currentRepeat: this.getRepeatState(this),
             },
@@ -605,10 +632,11 @@ class Player {
                 encodedTrack: null,
             },
         });
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
             details: {
-                changeType: "remove",
+                type: "queue",
+                action: "remove",
                 tracks: removedTracks,
             },
         });
@@ -640,9 +668,11 @@ class Player {
             },
         });
         // Emit an event indicating the pause state has changed.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.PauseChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.PauseChange,
             details: {
+                type: "pause",
+                action: "pause",
                 previousPause: oldPlayer.paused,
                 currentPause: this.paused,
             },
@@ -656,31 +686,26 @@ class Player {
      * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
      */
     async previous() {
-        // Check if there are previous tracks in the queue.
-        if (!(await this.queue.getPrevious()).length) {
+        // Get and remove the most recent previous track
+        const lastTrack = await this.queue.popPrevious();
+        if (!lastTrack) {
+            await this.queue.clearPrevious();
             throw new Error("No previous track available.");
         }
         // Capture the current state of the player before making changes.
         const oldPlayer = { ...this };
-        // Store the current track before changing it.
-        // let currentTrackBeforeChange: Track | null = this.queue.current ? (this.queue.current as Track) : null;
-        // Get the last played track and remove it from the history
-        const lastTrack = (await this.queue.getPrevious()).pop();
-        // Set the skip flag to true to prevent the onTrackEnd event from playing the next track.
+        // Set skip flag so trackEnd doesn't add current to previous
         this.set("skipFlag", true);
         await this.play(lastTrack);
-        // Add the current track back to the end of the previous queue
-        // if (currentTrackBeforeChange) this.queue.push(currentTrackBeforeChange);
-        // Emit a player state update event indicating the track change to previous.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.TrackChange,
+        // Emit state update
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
-                changeType: "previous",
+                type: "track",
+                action: "previous",
                 track: lastTrack,
             },
         });
-        // Reset the skip flag.
-        this.set("skipFlag", false);
         return this;
     }
     /**
@@ -714,10 +739,11 @@ class Player {
             },
         });
         // Emit an event to notify the manager of the track change.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.TrackChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
+            changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
-                changeType: "timeUpdate",
+                type: "track",
+                action: "timeUpdate",
                 previousTime: oldPlayer.position,
                 currentTime: this.position,
             },
@@ -761,13 +787,22 @@ class Player {
         const node = this.manager.nodes.get(identifier);
         if (!node)
             throw new Error(`Node with identifier ${identifier} not found`);
+        if (this.state !== Enums_1.StateTypes.Connected) {
+            return this;
+        }
         if (node.options.identifier === this.node.options.identifier) {
             return this;
         }
         try {
             const playerPosition = this.position;
-            const { sessionId, event: { token, endpoint }, } = this.voiceState;
             const currentTrack = (await this.queue.getCurrent()) ? await this.queue.getCurrent() : null;
+            // Safely get voice state properties with null checks
+            const sessionId = this.voiceState?.sessionId;
+            const token = this.voiceState?.event?.token;
+            const endpoint = this.voiceState?.event?.endpoint;
+            if (!sessionId || !token || !endpoint) {
+                throw new Error(`Voice state is not properly initialized for player ${this.guildId}. The bot might not be connected to a voice channel.`);
+            }
             await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
             this.manager.players.delete(this.guildId);
             this.node = node;
@@ -798,7 +833,7 @@ class Player {
         if (!newOptions.textChannelId)
             throw new Error("Text channel ID is required");
         // Check if a player already exists for the new guild
-        let newPlayer = await this.manager.getPlayer(newOptions.guildId);
+        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;
@@ -826,12 +861,12 @@ class Player {
         if (force && newPlayer) {
             await newPlayer.destroy();
         }
-        newOptions.node = newOptions.node ?? this.options.node;
+        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;
         // Deep clone the current player
-        const clonedPlayer = await this.manager.create(newOptions);
+        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
@@ -871,7 +906,7 @@ class Player {
                 queueSize: clonedPlayer.queue.size,
             },
         };
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[PLAYER] Transferred player to a new server: ${JSON.stringify(debugInfo)}.`);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Transferred player to a new server: ${JSON.stringify(debugInfo)}.`);
         // Return the cloned player
         return clonedPlayer;
     }
@@ -901,5 +936,133 @@ class Player {
         }
         return result;
     }
+    /**
+     * 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.
+     */
+    async setupVoiceReceiver() {
+        if (!this.node.isNodeLink)
+            throw new Error("This function is only available for NodeLinks");
+        if (this.voiceReceiverWsClient)
+            await this.removeVoiceReceiver();
+        const headers = {
+            Authorization: this.node.options.password,
+            "User-Id": this.manager.options.clientId,
+            "Guild-Id": this.guildId,
+            "Client-Name": this.manager.options.clientName,
+        };
+        const { host, useSSL, port } = this.node.options;
+        this.voiceReceiverWsClient = new ws_1.WebSocket(`${useSSL ? "wss" : "ws"}://${host}:${port}/connection/data`, { headers });
+        this.voiceReceiverWsClient.on("open", () => this.openVoiceReceiver());
+        this.voiceReceiverWsClient.on("error", (err) => this.onVoiceReceiverError(err));
+        this.voiceReceiverWsClient.on("message", (data) => this.onVoiceReceiverMessage(data.toString()));
+        this.voiceReceiverWsClient.on("close", (code, reason) => this.closeVoiceReceiver(code, reason.toString()));
+    }
+    /**
+     * 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.
+     */
+    async removeVoiceReceiver() {
+        if (!this.node.isNodeLink)
+            throw new Error("This function is only available for NodeLinks");
+        if (this.voiceReceiverWsClient) {
+            this.voiceReceiverWsClient.close(1000, "destroy");
+            this.voiceReceiverWsClient.removeAllListeners();
+            this.voiceReceiverWsClient = null;
+        }
+        this.isConnectToVoiceReceiver = false;
+    }
+    /**
+     * 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.
+     */
+    async closeVoiceReceiver(code, reason) {
+        await this.disconnectVoiceReceiver();
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Closed voice receiver for player ${this.guildId} with code ${code} and reason ${reason}`);
+        if (code !== 1000)
+            await this.reconnectVoiceReceiver();
+    }
+    /**
+     * Reconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is reconnected.
+     */
+    async reconnectVoiceReceiver() {
+        this.voiceReceiverReconnectTimeout = setTimeout(async () => {
+            if (this.voiceReceiverAttempt > this.voiceReceiverReconnectTries)
+                throw new Error("Failed to reconnect to voice receiver");
+            this.voiceReceiverWsClient?.removeAllListeners();
+            this.voiceReceiverWsClient = null;
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Reconnecting to voice receiver for player ${this.guildId}`);
+            await this.setupVoiceReceiver();
+            this.voiceReceiverAttempt++;
+        }, this.node.options.retryDelayMs);
+    }
+    /**
+     * Disconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is disconnected.
+     */
+    async disconnectVoiceReceiver() {
+        if (!this.isConnectToVoiceReceiver)
+            return;
+        this.voiceReceiverWsClient?.close(1000, "destroy");
+        this.voiceReceiverWsClient?.removeAllListeners();
+        this.voiceReceiverWsClient = null;
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Disconnected from voice receiver for player ${this.guildId}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverDisconnect, this);
+    }
+    /**
+     * Opens the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is opened.
+     */
+    async openVoiceReceiver() {
+        if (this.voiceReceiverReconnectTimeout)
+            clearTimeout(this.voiceReceiverReconnectTimeout);
+        this.voiceReceiverReconnectTimeout = null;
+        this.isConnectToVoiceReceiver = true;
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Opened voice receiver for player ${this.guildId}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverConnect, this);
+    }
+    /**
+     * 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.
+     */
+    async onVoiceReceiverMessage(payload) {
+        const packet = JSON.parse(payload);
+        if (!packet?.op)
+            return;
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved a payload: ${JSON.stringify(payload)}`);
+        switch (packet.type) {
+            case "startSpeakingEvent": {
+                this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverStartSpeaking, this, packet.data);
+                break;
+            }
+            case "endSpeakingEvent": {
+                const data = {
+                    ...packet.data,
+                    data: Buffer.from(packet.data.data, "base64"),
+                };
+                this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverEndSpeaking, this, data);
+                break;
+            }
+            default: {
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved an unknown payload: ${JSON.stringify(payload)}`);
+                break;
+            }
+        }
+    }
+    /**
+     * 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.
+     */
+    async onVoiceReceiverError(error) {
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver error for player ${this.guildId}: ${error.message}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverError, this, error);
+    }
 }
 exports.Player = Player;

package/dist/structures/Plugin.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
+/**
+ * Base abstract class for all plugins.
+ * Users must extend this and implement load and unload methods.
+ */
 class Plugin {
     name;
     /**
@@ -9,6 +13,5 @@ class Plugin {
     constructor(name) {
         this.name = name;
     }
-    load(manager) { }
 }
 exports.Plugin = Plugin;