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

package/dist/structures/Filters.d.ts

@@ -0,0 +1,352 @@
+import { Band } from "../utils/filtersEqualizers";
+import { AvailableFilters } from "./Enums";
+import { Manager } from "./Manager";
+import { Player } from "./Player";
+import { DistortionOptions, KaraokeOptions, ReverbOptions, RotationOptions, TimescaleOptions, VibratoOptions } from "./Types";
+export declare class Filters {
+    distortion: DistortionOptions | null;
+    equalizer: Band[];
+    karaoke: KaraokeOptions | null;
+    rotation: RotationOptions | null;
+    timescale: TimescaleOptions | null;
+    vibrato: VibratoOptions | null;
+    reverb: ReverbOptions | null;
+    volume: number;
+    bassBoostlevel: number;
+    filtersStatus: Record<AvailableFilters, boolean>;
+    manager: Manager;
+    player: Player;
+    constructor(player: Player, manager: Manager);
+    /**
+     * Updates the player's audio filters.
+     *
+     * This method sends a request to the player's node to update the filter settings
+     * based on the current properties of the `Filters` instance. The filters include
+     * distortion, equalizer, karaoke, rotation, timescale, vibrato, and volume. Once
+     * the request is sent, it ensures that the player's audio output reflects the
+     * changes in filter settings.
+     *
+     * @returns {Promise<this>} - Returns a promise that resolves to the current instance
+     * of the Filters class for method chaining.
+     */
+    updateFilters(): Promise<this>;
+    /**
+     * Applies a specific filter to the player.
+     *
+     * This method allows you to set the value of a specific filter property.
+     * The filter property must be a valid key of the Filters object.
+     *
+     * @param {{ property: T; value: Filters[T] }} filter - An object containing the filter property and value.
+     * @param {boolean} [updateFilters=true] - Whether to update the filters after applying the filter.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    private applyFilter;
+    private emitPlayersTasteUpdate;
+    /**
+     * Sets the status of a specific filter.
+     *
+     * This method updates the filter status to either true or false, indicating whether
+     * the filter is applied or not. This helps track which filters are active.
+     *
+     * @param {AvailableFilters} filter - The filter to update.
+     * @param {boolean} status - The status to set (true for active, false for inactive).
+     * @returns {this} - Returns the current instance of the Filters class for method chaining.
+     */
+    private setFilterStatus;
+    /**
+     * Retrieves the status of a specific filter.
+     *
+     * This method returns whether a specific filter is currently applied or not.
+     *
+     * @param {AvailableFilters} filter - The filter to check.
+     * @returns {boolean} - Returns true if the filter is active, false otherwise.
+     */
+    getFilterStatus(filter: AvailableFilters): boolean;
+    /**
+     * Clears all filters applied to the audio.
+     *
+     * This method resets all filter settings to their default values and removes any
+     * active filters from the player.
+     *
+     * @returns {this} - Returns the current instance of the Filters class for method chaining.
+     */
+    clearFilters(): Promise<this>;
+    /**
+     * Sets the own equalizer bands on the audio.
+     *
+     * This method adjusts the equalization curve of the player's audio output,
+     * allowing you to control the frequency response.
+     *
+     * @param {Band[]} [bands] - The equalizer bands to apply (band, gain).
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    setEqualizer(bands?: Band[]): Promise<this>;
+    /**
+     * Sets the own karaoke options to the audio.
+     *
+     * This method adjusts the audio so that it sounds like a karaoke song, with the
+     * original vocals removed. Note that not all songs can be successfully made into
+     * karaoke tracks, and some tracks may not sound as good.
+     *
+     * @param {KaraokeOptions} [karaoke] - The karaoke settings to apply (level, monoLevel, filterBand, filterWidth).
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    setKaraoke(karaoke?: KaraokeOptions): Promise<this>;
+    /**
+     * Sets the own timescale options to the audio.
+     *
+     * This method adjusts the speed and pitch of the audio, allowing you to control the playback speed.
+     *
+     * @param {TimescaleOptions} [timescale] - The timescale settings to apply (speed and pitch).
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    setTimescale(timescale?: TimescaleOptions): Promise<this>;
+    /**
+     * Sets the own vibrato options to the audio.
+     *
+     * This method applies a vibrato effect to the audio, which adds a wavering,
+     * pulsing quality to the sound. The effect is created by rapidly varying the
+     * pitch of the audio.
+     *
+     * @param {VibratoOptions} [vibrato] - The vibrato settings to apply (frequency, depth).
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    setVibrato(vibrato?: VibratoOptions): Promise<this>;
+    /**
+     * Sets the own rotation options effect to the audio.
+     *
+     * This method applies a rotation effect to the audio, which simulates the sound
+     * moving around the listener's head. This effect can create a dynamic and immersive
+     * audio experience by altering the directionality of the sound.
+     *
+     * @param {RotationOptions} [rotation] - The rotation settings to apply (rotationHz).
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    setRotation(rotation?: RotationOptions): Promise<this>;
+    /**
+     * Sets the own distortion options effect to the audio.
+     *
+     * This method applies a distortion effect to the audio, which adds a rougher,
+     * more intense quality to the sound. The effect is created by altering the
+     * audio signal to create a more jagged, irregular waveform.
+     *
+     * @param {DistortionOptions} [distortion] - The distortion settings to apply (sinOffset, sinScale, cosOffset, cosScale, tanOffset, tanScale, offset, scale).
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    setDistortion(distortion?: DistortionOptions): Promise<this>;
+    /**
+     * Sets the bass boost level on the audio.
+     *
+     * This method scales the gain of a predefined equalizer curve to the specified level.
+     * The curve is designed to emphasize or reduce low frequencies, creating a bass-heavy
+     * or bass-reduced effect.
+     *
+     * @param {number} level - The level of bass boost to apply. The value ranges from -3 to 3,
+     *                         where negative values reduce bass, 0 disables the effect,
+     *                         and positive values increase bass.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     *
+     * @example
+     * // Apply different levels of bass boost or reduction:
+     * await player.bassBoost(3);  // Maximum Bass Boost
+     * await player.bassBoost(2);  // Medium Bass Boost
+     * await player.bassBoost(1);  // Mild Bass Boost
+     * await player.bassBoost(0);  // No Effect (Disabled)
+     * await player.bassBoost(-1); // Mild Bass Reduction
+     * await player.bassBoost(-2); // Medium Bass Reduction
+     * await player.bassBoost(-3); // Maximum Bass Removal
+     */
+    bassBoost(stage: number): Promise<this>;
+    /**
+     * Toggles the chipmunk effect on the audio.
+     *
+     * This method applies or removes a chipmunk effect by adjusting the timescale settings.
+     * When enabled, it increases the speed, pitch, and rate of the audio, resulting in a high-pitched, fast playback
+     * similar to the sound of a chipmunk.
+     *
+     * @param {boolean} status - Whether to enable or disable the chipmunk effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    chipmunk(status: boolean): Promise<this>;
+    /**
+     * Toggles the "China" effect on the audio.
+     *
+     * This method applies or removes a filter that reduces the pitch of the audio by half,
+     * without changing the speed or rate. This creates a "hollow" or "echoey" sound.
+     *
+     * @param {boolean} status - Whether to enable or disable the "China" effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    china(status: boolean): Promise<this>;
+    /**
+     * Toggles the 8D audio effect on the audio.
+     *
+     * This method applies or removes an 8D audio effect by adjusting the rotation settings.
+     * When enabled, it creates a sensation of the audio moving around the listener's head,
+     * providing an immersive audio experience.
+     *
+     * @param {boolean} status - Whether to enable or disable the 8D effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    eightD(status: boolean): Promise<this>;
+    /**
+     * Toggles the nightcore effect on the audio.
+     *
+     * This method applies or removes a nightcore effect by adjusting the timescale settings.
+     * When enabled, it increases the speed and pitch of the audio, giving it a more
+     * upbeat and energetic feel.
+     *
+     * @param {boolean} status - Whether to enable or disable the nightcore effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    nightcore(status: boolean): Promise<this>;
+    /**
+     * Toggles the slowmo effect on the audio.
+     *
+     * This method applies or removes a slowmo effect by adjusting the timescale settings.
+     * When enabled, it slows down the audio while keeping the pitch the same, giving it
+     * a more relaxed and calming feel.
+     *
+     * @param {boolean} status - Whether to enable or disable the slowmo effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    slowmo(status: boolean): Promise<this>;
+    /**
+     * Toggles a soft equalizer effect to the audio.
+     *
+     * This method applies or removes a soft equalizer effect by adjusting the equalizer settings.
+     * When enabled, it reduces the bass and treble frequencies, giving the audio a softer and more
+     * mellow sound.
+     *
+     * @param {boolean} status - Whether to enable or disable the soft equalizer effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    soft(status: boolean): Promise<this>;
+    /**
+     * Toggles the TV equalizer effect on the audio.
+     *
+     * This method applies or removes a TV equalizer effect by adjusting the equalizer settings.
+     * When enabled, it enhances specific frequency bands to mimic the audio characteristics
+     * typically found in television audio outputs.
+     *
+     * @param {boolean} status - Whether to enable or disable the TV equalizer effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    tv(status: boolean): Promise<this>;
+    /**
+     * Toggles the treble/bass equalizer effect on the audio.
+     *
+     * This method applies or removes a treble/bass equalizer effect by adjusting the equalizer settings.
+     * When enabled, it enhances the treble and bass frequencies, giving the audio a more balanced sound.
+     *
+     * @param {boolean} status - Whether to enable or disable the treble/bass equalizer effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    trebleBass(status: boolean): Promise<this>;
+    /**
+     * Toggles the vaporwave effect on the audio.
+     *
+     * This method applies or removes a vaporwave effect by adjusting the equalizer settings.
+     * When enabled, it gives the audio a dreamy and nostalgic feel, characteristic of the vaporwave genre.
+     *
+     * @param {boolean} status - Whether to enable or disable the vaporwave effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    vaporwave(status: boolean): Promise<this>;
+    /**
+     * Toggles the distortion effect on the audio.
+     *
+     * This method applies or removes a distortion effect by adjusting the distortion settings.
+     * When enabled, it adds a rougher, more intense quality to the sound by altering the
+     * audio signal to create a more jagged, irregular waveform.
+     *
+     * @param {boolean} status - Whether to enable or disable the distortion effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    distort(status: boolean): Promise<this>;
+    /**
+     * Toggles the party effect on the audio.
+     *
+     * This method applies or removes a party effect by adjusting the equalizer settings.
+     * When enabled, it enhances the bass and treble frequencies, providing a more energetic and lively sound.
+     *
+     * @param {boolean} status - Whether to enable or disable the party effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    pop(status: boolean): Promise<this>;
+    /**
+     * Toggles a party effect on the audio.
+     *
+     * This method applies a party effect to audio.
+     * @param {boolean} status - Whether to enable or disable the party effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    party(status: boolean): Promise<this>;
+    /**
+     * Toggles earrape effect on the audio.
+     *
+     * This method applies earrape effect to audio.
+     * @param {boolean} status - Whether to enable or disable the earrape effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    earrape(status: boolean): Promise<this>;
+    /**
+     * Toggles electronic effect on the audio.
+     *
+     * This method applies electronic effect to audio.
+     * @param {boolean} status - Whether to enable or disable the electronic effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    electronic(status: boolean): Promise<this>;
+    /**
+     * Toggles radio effect on the audio.
+     *
+     * This method applies radio effect to audio.
+     * @param {boolean} status - Whether to enable or disable the radio effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    radio(status: boolean): Promise<this>;
+    /**
+     * Toggles a tremolo effect on the audio.
+     *
+     * This method applies a tremolo effect to audio.
+     * @param {boolean} status - Whether to enable or disable the tremolo effect.
+     * @returns {this} - Returns the current instance of the Filters class for method chaining.
+     */
+    tremolo(status: boolean): Promise<this>;
+    /**
+     * Toggless a darthvader effect on the audio.
+     *
+     * This method applies a darthvader effect to audio.
+     * @param {boolean} status - Whether to enable or disable the darthvader effect.
+     * @returns {this} - Returns the current instance of the Filters class for method chaining.
+     */
+    darthvader(status: boolean): Promise<this>;
+    /**
+     * Toggles a daycore effect on the audio.
+     *
+     * This method applies a daycore effect to audio.
+     * @param {boolean} status - Whether to enable or disable the daycore effect.
+     * @returns {this} - Returns the current instance of the Filters class for method chaining.
+     */
+    daycore(status: boolean): Promise<this>;
+    /**
+     * Toggles a doubletime effect on the audio.
+     *
+     * This method applies a doubletime effect to audio.
+     * @param {boolean} status - Whether to enable or disable the doubletime effect.
+     * @returns {this} - Returns the current instance of the Filters class for method chaining
+     */
+    doubletime(status: boolean): Promise<this>;
+    /**
+     * Toggles the demon effect on the audio.
+     *
+     * This method applies or removes a demon effect by adjusting the equalizer,
+     * timescale, and reverb settings. When enabled, it creates a deeper and more
+     * intense sound by lowering the pitch and adding reverb to the audio.
+     *
+     * @param {boolean} status - Whether to enable or disable the demon effect.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    demon(status: boolean): Promise<this>;
+}

package/dist/structures/Filters.js

@@ -8,8 +8,6 @@ class Filters {
     distortion;
     equalizer;
     karaoke;
-    manager;
-    player;
     rotation;
     timescale;
     vibrato;
@@ -17,15 +15,16 @@ class Filters {
     volume;
     bassBoostlevel;
     filtersStatus;
+    manager;
+    player;
     constructor(player, manager) {
         this.distortion = null;
         this.equalizer = [];
         this.karaoke = null;
-        this.manager = manager;
-        this.player = player;
         this.rotation = null;
         this.timescale = null;
         this.vibrato = null;
+        this.reverb = null;
         this.volume = 1.0;
         this.bassBoostlevel = 0;
         // Initialize filter status
@@ -33,6 +32,8 @@ class Filters {
             acc[filter] = false;
             return acc;
         }, {});
+        this.manager = manager;
+        this.player = player;
     }
     /**
      * Updates the player's audio filters.

package/dist/structures/MagmastreamError.d.ts

@@ -0,0 +1,14 @@
+import { MagmaStreamErrorCode } from "./Enums";
+interface MagmaStreamErrorOptions<T = unknown> {
+    code: MagmaStreamErrorCode;
+    message?: string;
+    cause?: Error;
+    context?: T;
+}
+export declare class MagmaStreamError<T = unknown> extends Error {
+    readonly code: MagmaStreamErrorCode;
+    readonly number: number;
+    readonly context?: T;
+    constructor({ code, message, cause, context }: MagmaStreamErrorOptions<T>);
+}
+export {};

package/dist/structures/Manager.d.ts

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