lavalink-client 2.7.0 → 2.7.2

package/dist/index.d.mts

@@ -1,1122 +1,416 @@
 import { EventEmitter } from 'events';
 
-/** The Audio Outputs type */
-type AudioOutputs = "mono" | "stereo" | "left" | "right";
-/** The "active" / "disabled" Player Filters */
-interface PlayerFilters {
-    /** Sets nightcore to false, and vaporwave to false */
-    custom: boolean;
-    /** Sets custom to false, and vaporwave to false */
-    nightcore: boolean;
-    /** Sets custom to false, and nightcore to false */
-    vaporwave: boolean;
-    /** If rotation filter is enabled / not */
-    rotation: boolean;
-    /** if karaoke filter is enabled / not */
-    karaoke: boolean;
-    /** if tremolo filter is enabled / not */
-    tremolo: boolean;
-    /** if vibrato filter is enabled / not */
-    vibrato: boolean;
-    lowPass: boolean;
-    /** audio Output (default stereo, mono sounds the fullest and best for not-stereo tracks) */
-    audioOutput: AudioOutputs;
-    /** Lavalink Volume FILTER (not player Volume, think of it as a gain booster) */
-    volume: boolean;
-    /** Filters for the Lavalink Filter Plugin */
-    lavalinkFilterPlugin: {
-        /** if echo filter is enabled / not */
-        echo: boolean;
-        /** if reverb filter is enabled / not */
-        reverb: boolean;
-    };
-    lavalinkLavaDspxPlugin: {
-        /** if lowPass filter is enabled / not */
-        lowPass: boolean;
-        /** if highPass filter is enabled / not */
-        highPass: boolean;
-        /** if normalization filter is enabled / not */
-        normalization: boolean;
-        /** if echo filter is enabled / not */
-        echo: boolean;
-    };
-}
-/**
- * There are 15 bands (0-14) that can be changed.
- * "gain" is the multiplier for the given band.
- * The default value is 0.
- *  Valid values range from -0.25 to 1.0, where -0.25 means the given band is completely muted, and 0.25 means it is doubled.
- * Modifying the gain could also change the volume of the output.
- */
-interface EQBand {
-    /** On what band position (0-14) it should work */
-    band: IntegerNumber | number;
-    /** The gain (-0.25 to 1.0) */
-    gain: FloatNumber | number;
-}
-/**
- * Uses equalization to eliminate part of a band, usually targeting vocals.
- */
-interface KaraokeFilter {
-    /** The level (0 to 1.0 where 0.0 is no effect and 1.0 is full effect) */
-    level?: number;
-    /** The mono level (0 to 1.0 where 0.0 is no effect and 1.0 is full effect) */
-    monoLevel?: number;
-    /** The filter band (in Hz) */
-    filterBand?: number;
-    /**	The filter width */
-    filterWidth?: number;
-}
-/**
- * Changes the speed, pitch, and rate
- */
-interface TimescaleFilter {
-    /** The playback speed 0.0 ≤ x */
-    speed?: number;
-    /** The pitch 0.0 ≤ x */
-    pitch?: number;
-    /** The rate 0.0 ≤ x */
-    rate?: number;
-}
-/**
- * Uses amplification to create a shuddering effect, where the volume quickly oscillates.
- * Demo: https://en.wikipedia.org/wiki/File:Fuse_Electronics_Tremolo_MK-III_Quick_Demo.ogv
- */
-interface TremoloFilter {
-    /** The frequency 0.0 < x */
-    frequency?: number;
-    /** The tremolo depth 0.0 < x ≤ 1.0 */
-    depth?: number;
-}
-/**
- * Similar to tremolo. While tremolo oscillates the volume, vibrato oscillates the pitch.
- */
-interface VibratoFilter {
-    /** The frequency 0.0 < x ≤ 14.0 */
-    frequency?: number;
-    /** The vibrato depth 0.0 < x ≤ 1.0 */
-    depth?: number;
-}
-/**
- * Rotates the sound around the stereo channels/user headphones (aka Audio Panning).
- * It can produce an effect similar to https://youtu.be/QB9EB8mTKcc (without the reverb).
- */
-interface RotationFilter {
-    /** The frequency of the audio rotating around the listener in Hz. 0.2 is similar to the example video above */
-    rotationHz?: number;
-}
-/**
- * Distortion effect. It can generate some pretty unique audio effects.
- */
-interface DistortionFilter {
-    sinOffset?: number;
-    sinScale?: number;
-    cosOffset?: number;
-    cosScale?: number;
-    tanOffset?: number;
-    tanScale?: number;
-    offset?: number;
-    scale?: number;
-}
-/**
- * Mixes both channels (left and right), with a configurable factor on how much each channel affects the other.
- * With the defaults, both channels are kept independent of each other.
- * Setting all factors to 0.5 means both channels get the same audio.
- */
-interface ChannelMixFilter {
-    /** The left to left channel mix factor (0.0 ≤ x ≤ 1.0) */
-    leftToLeft?: number;
-    /** The left to right channel mix factor (0.0 ≤ x ≤ 1.0) */
-    leftToRight?: number;
-    /** The right to left channel mix factor (0.0 ≤ x ≤ 1.0) */
-    rightToLeft?: number;
-    /** The right to right channel mix factor (0.0 ≤ x ≤ 1.0) */
-    rightToRight?: number;
-}
-/**
- * Higher frequencies get suppressed, while lower frequencies pass through this filter, thus the name low pass.
- * Any smoothing values equal to or less than 1.0 will disable the filter.
- */
-interface LowPassFilter {
-    /** The smoothing factor (1.0 < x) */
-    smoothing?: number;
-}
-/**
- * Filter Data stored in the Client and partially sent to Lavalink
- */
-interface FilterData {
-    volume?: number;
-    karaoke?: KaraokeFilter;
-    timescale?: TimescaleFilter;
-    tremolo?: TremoloFilter;
-    vibrato?: VibratoFilter;
-    rotation?: RotationFilter;
-    distortion?: DistortionFilter;
-    channelMix?: ChannelMixFilter;
-    lowPass?: LowPassFilter;
-    pluginFilters?: {
-        "lavalink-filter-plugin"?: {
-            "echo"?: {
-                delay?: number;
-                decay?: number;
-            };
-            "reverb"?: {
-                delays?: number[];
-                gains?: number[];
-            };
-        };
-        "high-pass"?: {
-            cutoffFrequency?: number;
-            boostFactor?: number;
-        };
-        "low-pass"?: {
-            cutoffFrequency?: number;
-            boostFactor?: number;
-        };
-        normalization?: {
-            maxAmplitude?: number;
-            adaptive?: boolean;
-        };
-        echo?: {
-            echoLength?: number;
-            decay?: number;
-        };
-    };
-}
-/**
- * Actual Filter Data sent to Lavalink
- */
-interface LavalinkFilterData extends FilterData {
-    equalizer?: EQBand[];
-}
-
-/**
- * Debug events for more detailed logging
- */
-declare enum DebugEvents {
-    SetSponsorBlock = "SetSponsorBlock",
-    DeleteSponsorBlock = "DeleteSponsorBlock",
-    TrackEndReplaced = "TrackEndReplaced",
-    AutoplayExecution = "AutoplayExecution",
-    AutoplayNoSongsAdded = "AutoplayNoSongsAdded",
-    AutoplayThresholdSpamLimiter = "AutoplayThresholdSpamLimiter",
-    TriggerQueueEmptyInterval = "TriggerQueueEmptyInterval",
-    QueueEnded = "QueueEnded",
-    TrackStartNewSongsOnly = "TrackStartNewSongsOnly",
-    TrackStartNoTrack = "TrackStartNoTrack",
-    ResumingFetchingError = "ResumingFetchingError",
-    PlayerUpdateNoPlayer = "PlayerUpdateNoPlayer",
-    PlayerUpdateFilterFixApply = "PlayerUpdateFilterFixApply",
-    PlayerUpdateSuccess = "PlayerUpdateSuccess",
-    HeartBeatTriggered = "HeartBeatTriggered",
-    NoSocketOnDestroy = "NoSocketOnDestroy",
-    SocketCleanupError = "SocketCleanupError",
-    SocketTerminateHeartBeatTimeout = "SocketTerminateHeartBeatTimeout",
-    TryingConnectWhileConnected = "TryingConnectWhileConnected",
-    LavaSearchNothingFound = "LavaSearchNothingFound",
-    SearchNothingFound = "SearchNothingFound",
-    ValidatingBlacklistLinks = "ValidatingBlacklistLinks",
-    ValidatingWhitelistLinks = "ValidatingWhitelistLinks",
-    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
-    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime",
-    PlayerDestroyingSomewhereElse = "PlayerDestroyingSomewhereElse",
-    PlayerCreateNodeNotFound = "PlayerCreateNodeNotFound",
-    PlayerPlayQueueEmptyTimeoutClear = "PlayerPlayQueueEmptyTimeoutClear",
-    PlayerPlayWithTrackReplace = "PlayerPlayWithTrackReplace",
-    PlayerPlayUnresolvedTrack = "PlayerPlayUnresolvedTrack",
-    PlayerPlayUnresolvedTrackFailed = "PlayerPlayUnresolvedTrackFailed",
-    PlayerVolumeAsFilter = "PlayerVolumeAsFilter",
-    BandcampSearchLokalEngine = "BandcampSearchLokalEngine",
-    PlayerChangeNode = "PlayerChangeNode",
-    BuildTrackError = "BuildTrackError",
-    TransformRequesterFunctionFailed = "TransformRequesterFunctionFailed",
-    GetClosestTrackFailed = "GetClosestTrackFailed",
-    PlayerDeleteInsteadOfDestroy = "PlayerDeleteInsteadOfDestroy",
-    FailedToConnectToNodes = "FailedToConnectToNodes",
-    NoAudioDebug = "NoAudioDebug",
-    PlayerAutoReconnect = "PlayerAutoReconnect"
-}
-/**
- * Reasons why a player got destroyed
- */
-declare enum DestroyReasons {
-    QueueEmpty = "QueueEmpty",
-    NodeDestroy = "NodeDestroy",
-    NodeDeleted = "NodeDeleted",
-    LavalinkNoVoice = "LavalinkNoVoice",
-    NodeReconnectFail = "NodeReconnectFail",
-    Disconnected = "Disconnected",
-    PlayerReconnectFail = "PlayerReconnectFail",
-    PlayerChangeNodeFail = "PlayerChangeNodeFail",
-    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
-    ChannelDeleted = "ChannelDeleted",
-    DisconnectAllNodes = "DisconnectAllNodes",
-    ReconnectAllNodes = "ReconnectAllNodes",
-    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
-    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime"
-}
-/**
- *  Reasons why a player got disconnected
- */
-declare enum DisconnectReasons {
-    Disconnected = "Disconnected",
-    DisconnectAllNodes = "DisconnectAllNodes"
-}
-/** The valid SponsorBlock categories */
-declare const validSponsorBlocks: string[];
-/**  The audio Outputs Data map declaration */
-declare const audioOutputsData: Record<AudioOutputs, ChannelMixFilter>;
-/**  Equalizer Presets */
-declare const EQList: {
-    /** A Bassboost Equalizer, so high it distorts the audio */
-    BassboostEarrape: EQBand[];
-    /** A High and decent Bassboost Equalizer */
-    BassboostHigh: EQBand[];
-    /** A decent Bassboost Equalizer */
-    BassboostMedium: EQBand[];
-    /** A slight Bassboost Equalizer */
-    BassboostLow: EQBand[];
-    /** Makes the Music slightly "better" */
-    BetterMusic: EQBand[];
-    /** Makes the Music sound like rock music / sound rock music better */
-    Rock: EQBand[];
-    /** Makes the Music sound like Classic music / sound Classic music better */
-    Classic: EQBand[];
-    /** Makes the Music sound like Pop music / sound Pop music better */
-    Pop: EQBand[];
-    /** Makes the Music sound like Electronic music / sound Electronic music better */
-    Electronic: EQBand[];
-    /** Boosts all Bands slightly for louder and fuller sound */
-    FullSound: EQBand[];
-    /** Boosts basses + lower highs for a pro gaming sound */
-    Gaming: EQBand[];
-};
-
-declare class FilterManager {
-    static EQList: {
-        BassboostEarrape: EQBand[];
-        BassboostHigh: EQBand[];
-        BassboostMedium: EQBand[];
-        BassboostLow: EQBand[];
-        BetterMusic: EQBand[];
-        Rock: EQBand[];
-        Classic: EQBand[];
-        Pop: EQBand[];
-        Electronic: EQBand[];
-        FullSound: EQBand[];
-        Gaming: EQBand[];
-    };
-    /** The Equalizer bands currently applied to the Lavalink Server */
-    equalizerBands: EQBand[];
-    /** Private Util for the instaFix Filters option */
-    filterUpdatedState: boolean;
-    /** All "Active" / "disabled" Player Filters */
-    filters: PlayerFilters;
-    /** The Filter Data sent to Lavalink, only if the filter is enabled (ofc.) */
-    data: FilterData;
-    /** The Player assigned to this Filter Manager */
-    player: Player;
-    /** The Constructor for the FilterManager */
-    constructor(player: Player);
-    /**
-     * Apply Player filters for lavalink filter sending data, if the filter is enabled / not
-     *
-     * @returns {Promise<void>}
-     *
-     * @example
-     * ```ts
-     * // Apply the filters after changing them manually:
-     * player.filterManager.data.volume = 0.5;
-     * // maybe you wanna manually set a distorition filter? then do it like this...
-     * player.filterManager.data.distortion = { sinOffset: 0.5, sinScale: 2, cosOffset: 0.5, cosScale: 2, tanOffset: 0.5, tanScale: 2, offset: 0.5, scale: 2 };
-     * await player.filterManager.applyPlayerFilters();
-     * ```
-     */
-    applyPlayerFilters(): Promise<void>;
-    privateNot0(value: number | undefined): boolean;
-    /**
-     * Checks if the filters are correctly stated (active / not-active) - mostly used internally.
-     * @param oldFilterTimescale
-     * @returns {boolean} True, if the check was successfull
-     *
-     * @example
-     * ```ts
-     * // Check the filter states
-     * player.filterManager.checkFiltersState();
-     * // Apply the filters after checking
-     * await player.filterManager.applyPlayerFilters();
-     * ```
-     */
-    checkFiltersState(oldFilterTimescale?: Partial<TimescaleFilter>): boolean;
-    /**
-     * Reset all Filters
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Reset all filters
-     * await player.filterManager.resetFilters();
-     * ```
-     */
-    resetFilters(): Promise<FilterManager>;
-    /**
-     * Set the Filter Volume
-     * @param volume the volume (0.0 - 5.0)
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Set Volume to 50%
-     * await player.filterManager.setVolume(0.5);
-     * // note this is a filter, so it will "jump" to the volume, i think it's like a "volume boost effect" so i marketed it as a filter
-     * ```
-     */
-    setVolume(volume: number): Promise<this>;
-    /**
-     * Set the AudioOutput Filter
-     * @param {AudioOutputs} type the audio output type
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Set Audio Output to Mono
-     * await player.filterManager.setAudioOutput("mono");
-     *
-     * // Set Audio Output to Stereo
-     * await player.filterManager.setAudioOutput("stereo");
-     *
-     * // Set Audio Output to Left
-     * await player.filterManager.setAudioOutput("left");
-     *
-     * // Set Audio Output to Right
-     * await player.filterManager.setAudioOutput("right");
-     * ```
-     */
-    setAudioOutput(type: AudioOutputs): Promise<FilterManager>;
-    /**
-     * Set custom filter.timescale#speed . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
-     * @param {number} speed set the speed of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Set Speed to 1.25 (disableds nightcore and vaporwave effect which are pre-made timescale settings of rate,pitch and speed)
-     * await player.filterManager.setSpeed(1.25);
-     * ```
-     */
-    setSpeed(speed?: number): Promise<FilterManager>;
-    /**
-     * Set custom filter.timescale#pitch . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
-     * @param  {number} pitch set the pitch of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Set Pitch to 1.25 (disableds nightcore and vaporwave effect which are pre-made timescale settings of rate,pitch and speed)
-     * await player.filterManager.setPitch(1.25);
-     * ```
-     */
-    setPitch(pitch?: number): Promise<FilterManager>;
-    /**
-     * Set custom filter.timescale#rate . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
-     * @param {number} rate set the rate of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Set Rate to 1.25 (disableds nightcore and vaporwave effect which are pre-made timescale settings of rate,pitch and speed)
-     * await player.filterManager.setRate(1.25);
-     * ```
-     */
-    setRate(rate?: number): Promise<FilterManager>;
-    /**
-     * Enables / Disables the rotation effect, (Optional: provide your Own Data)
-     * @param {number} rotationHz set the rotationHz of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Toggle Rotation filter with custom settings
-     * await player.filterManager.toggleRotation(0.4);
-     * // or use the defaults
-     * await player.filterManager.toggleRotation();
-     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-     * ```
-     */
-    toggleRotation(rotationHz?: number): Promise<FilterManager>;
-    /**
-     * Enables / Disables the Vibrato effect, (Optional: provide your Own Data)
-     * @param {number} frequency set the frequency of the filter
-     * @param {number} depth set the depth of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Toggle Vibrato filter with custom settings
-     * await player.filterManager.toggleVibrato(8, 0.5);
-     * // or use the defaults
-     * await player.filterManager.toggleVibrato();
-     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-     * ```
-     */
-    toggleVibrato(frequency?: number, depth?: number): Promise<FilterManager>;
-    /**
-     * Enables / Disables the Tremolo effect, (Optional: provide your Own Data)
-     * @param {number} frequency set the frequency of the filter
-     * @param {number} depth set the depth of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Toggle Tremolo filter with custom settings
-     * await player.filterManager.toggleTremolo(5, 0.7);
-     * // or use the defaults
-     * await player.filterManager.toggleTremolo();
-     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-     * ```
-     */
-    toggleTremolo(frequency?: number, depth?: number): Promise<FilterManager>;
-    /**
-     * Enables / Disables the LowPass effect, (Optional: provide your Own Data)
-     * @param {number} smoothing set the smoothing of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Toggle LowPass filter with custom settings
-     * await player.filterManager.toggleLowPass(30);
-     * // or use the defaults
-     * await player.filterManager.toggleLowPass();
-     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-     * ```
-     */
-    toggleLowPass(smoothing?: number): Promise<FilterManager>;
-    /**
-     * Lavalink LavaDspx Plugin Filters
-     */
-    lavalinkLavaDspxPlugin: {
-        /**
-         * Enables / Disables the LowPass effect, (Optional: provide your Own Data)
-         * @param {number} boostFactor set the boost factor of the filter
-         * @param {number} cutoffFrequency set the cutoff frequency of the filter
-         * @returns  {Promise<boolean>} the state of the filter after execution.
-         *
-         * @example
-         * ```ts
-         * // Toggle LowPass filter with custom settings
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleLowPass(1.2, 300);
-         * // or use the defaults
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleLowPass();
-         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-         * ```
-         */
-        toggleLowPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<FilterManager>;
-        /**
-         * Enables / Disables the HighPass effect, (Optional: provide your Own Data)
-         * @param {number} boostFactor [] set the boost factor of the filter
-         * @param {number} cutoffFrequency set the cutoff frequency of the filter
-         * @returns  {Promise<boolean>} the state of the filter after execution.
-         *
-         * @example
-         * ```ts
-         * // Toggle HighPass filter with custom settings
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleHighPass(1.2, 150); // custom values
-         * // or use the defaults
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleHighPass();
-         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-         * ```
-         */
-        toggleHighPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<FilterManager>;
-        /**
-         * Enables / Disables the Normalization effect.
-         * @param {number} [maxAmplitude=0.75] - The maximum amplitude of the audio.
-         * @param {boolean} [adaptive=true] Whether to use adaptive normalization or not.
-         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-         *
-         * @example
-         * ```ts
-         * // Toggle Normalization filter with custom settings
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleNormalization(0.9, false); // custom values
-         * // or use the defaults
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleNormalization();
-         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-         * ```
-         */
-        toggleNormalization: (maxAmplitude?: number, adaptive?: boolean) => Promise<FilterManager>;
-        /**
-         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
-         * @param {number} [decay=0.5] The decay of the echo effect.
-         * @param {number} [echoLength=0.5] The length of the echo effect.
-         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-         *
-         * @example
-         * ```ts
-         * // Toggle Echo filter with custom settings
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleEcho(0.7, 0.6); // custom values
-         * // or use the defaults
-         * await player.filterManager.lavalinkLavaDspxPlugin.toggleEcho();
-         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-         * ```
-         */
-        toggleEcho: (decay?: number, echoLength?: number) => Promise<FilterManager>;
-    };
-    /**
-     * LavalinkFilter Plugin specific Filters
-     */
-    lavalinkFilterPlugin: {
-        /**
-         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
-         * @param {number} delay set the delay of the echo
-         * @param {number} decay set the decay of the echo
-         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-         *
-         * @example
-         * ```ts
-         * // Toggle Echo filter with custom settings
-         * await player.filterManager.lavalinkFilterPlugin.toggleEcho(3, 0.7); // custom values
-         * // or use the defaults
-         * await player.filterManager.lavalinkFilterPlugin.toggleEcho();
-         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-         * ```
-         */
-        toggleEcho: (delay?: number, decay?: number) => Promise<FilterManager>;
-        /**
-         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
-         * @param {number} delays set the delays of the reverb
-         * @param {number} gains set the gains of the reverb
-         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-         *
-         * @example
-         * ```ts
-         * // Toggle Reverb filter with custom settings
-         * await player.filterManager.lavalinkFilterPlugin.toggleReverb([0.04, 0.045, 0.05, 0.055], [0.85, 0.84, 0.83, 0.82]);
-         * // or use the defaults
-         * await player.filterManager.lavalinkFilterPlugin.toggleReverb();
-         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-         * ```
-         */
-        toggleReverb: (delays?: number[], gains?: number[]) => Promise<FilterManager>;
+declare class FilterManager {
+    static EQList: {
+        BassboostEarrape: EQBand[];
+        BassboostHigh: EQBand[];
+        BassboostMedium: EQBand[];
+        BassboostLow: EQBand[];
+        BetterMusic: EQBand[];
+        Rock: EQBand[];
+        Classic: EQBand[];
+        Pop: EQBand[];
+        Electronic: EQBand[];
+        FullSound: EQBand[];
+        Gaming: EQBand[];
     };
+    /** The Equalizer bands currently applied to the Lavalink Server */
+    equalizerBands: EQBand[];
+    /** Private Util for the instaFix Filters option */
+    filterUpdatedState: boolean;
+    /** All "Active" / "disabled" Player Filters */
+    filters: PlayerFilters;
+    /** The Filter Data sent to Lavalink, only if the filter is enabled (ofc.) */
+    data: FilterData;
+    /** The Player assigned to this Filter Manager */
+    player: Player;
+    /** The Constructor for the FilterManager */
+    constructor(player: Player);
     /**
-     * Enables / Disables a Nightcore-like filter Effect. Disables/Overrides both: custom and Vaporwave Filter
-     * @param {number} speed set the speed of the filter
-     * @param {number} pitch set the pitch of the filter
-     * @param {number} rate set the rate of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Toggle Nightcore filter with custom settings
-     * await player.filterManager.toggleNightcore(1.3, 1.3, 0.9);
-     * // or use the defaults
-     * await player.filterManager.toggleNightcore();
-     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-     * ```
-     */
-    toggleNightcore(speed?: number, pitch?: number, rate?: number): Promise<FilterManager>;
-    /**
-     * Enables / Disables a Vaporwave-like filter Effect. Disables/Overrides both: custom and nightcore Filter
-     * @param {number} speed set the speed of the filterq
-     * @param {number} pitch set the pitch of the filter
-     * @param {number} rate set the rate of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Toggle Vaporwave filter with custom settings
-     * await player.filterManager.toggleVaporwave(0.9, 0.7, 1);
-     * // or use the defaults
-     * await player.filterManager.toggleVaporwave();
-     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-     * ```
-     */
-    toggleVaporwave(speed?: number, pitch?: number, rate?: number): Promise<FilterManager>;
-    /**
-     * Enable / Disables a Karaoke like Filter Effect
-     * @param {number} level set the level of the filter
-     * @param {number} monoLevel set the mono level of the filter
-     * @param {number} filterBand set the filter band of the filter
-     * @param {number} filterWidth set the filter width of the filter
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Toggle Karaoke filter with custom settings
-     * await player.filterManager.toggleKaraoke(1.5, 1.0, 220, 100);
-     * // or use the defaults
-     * await player.filterManager.toggleKaraoke();
-     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
-     * ```
-     */
-    toggleKaraoke(level?: number, monoLevel?: number, filterBand?: number, filterWidth?: number): Promise<FilterManager>;
-    /**
-     * Function to find out if currently there is a custom timescamle etc. filter applied
-     * @returns {boolean} whether a custom filter is active
-     *
-     * @example
-     * ```ts
-     * // Check if a custom filter is active
-     * const isCustom = player.filterManager.isCustomFilterActive();
-     * console.log(`Is custom filter active? ${isCustom}`);
-     * ```
-     */
-    isCustomFilterActive(): boolean;
-    /**
-     * Sets the players equalizer bands using one of the predefined presets.
-     * @param {keyof typeof EQList} preset The preset to use.
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Set EQ preset
-     * await player.filterManager.setEQPreset('BassboostMedium');
-     * ```
-     */
-    setEQPreset(preset: keyof typeof EQList): Promise<this>;
-    /**
-     * Sets the players equalizer band on-top of the existing ones.
-     * @param {number} bands
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
-     *
-     * @example
-     * ```ts
-     * // Set EQ bands
-     * await player.filterManager.setEQ([
-     *   { band: 0, gain: 0.3 },
-     *   { band: 1, gain: -0.2 },
-     *   { band: 2, gain: 0.1 }
-     * ]);
+     * Apply Player filters for lavalink filter sending data, if the filter is enabled / not
      *
-     * // or use one of the templates:
-     * await player.filterManager.setEQ(player.filterManager.EQList.BassboostMedium); // you can also import EQList from somewhere package if wanted.
-     * ```
-     */
-    setEQ(bands: EQBand | EQBand[]): Promise<this>;
-    /**
-     * Clears the equalizer bands.
-     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     * @returns {Promise<void>}
      *
      * @example
      * ```ts
-     * // Clear all EQ bands
-     * await player.filterManager.clearEQ();
-     * ```
-     */
-    clearEQ(): Promise<this>;
-}
-
-declare class QueueSaver {
-    /**
-     * The queue store manager
-     */
-    private _;
-    /**
-     * The options for the queue saver
-     */
-    options: {
-        maxPreviousTracks: number;
-    };
-    constructor(options: ManagerQueueOptions);
-    /**
-     * Get the queue for a guild
-     * @param guildId The guild ID
-     * @returns The queue for the guild
-     */
-    get(guildId: string): Promise<Partial<StoredQueue>>;
-    /**
-     * Delete the queue for a guild
-     * @param guildId The guild ID
-     * @returns The queue for the guild
-     */
-    delete(guildId: string): Promise<boolean | void>;
-    /**
-     * Set the queue for a guild
-     * @param guildId The guild ID
-     * @param valueToStringify The queue to set
-     * @returns The queue for the guild
-     */
-    set(guildId: string, valueToStringify: StoredQueue): Promise<boolean | void>;
-    /**
-     * Sync the queue for a guild
-     * @param guildId The guild ID
-     * @returns The queue for the guild
-     */
-    sync(guildId: string): Promise<Partial<StoredQueue>>;
-}
-declare class DefaultQueueStore implements QueueStoreManager {
-    private data;
-    constructor();
-    /**
-     * Get the queue for a guild
-     * @param guildId The guild ID
-     * @returns The queue for the guild
-     */
-    get(guildId: string): StoredQueue | undefined;
-    /**
-     * Set the queue for a guild
-     * @param guildId The guild ID
-     * @param valueToStringify The queue to set
-     * @returns The queue for the guild
-     */
-    set(guildId: string, valueToStringify: any): boolean;
-    /**
-     * Delete the queue for a guild
-     * @param guildId The guild ID
-     * @returns The queue for the guild
-     */
-    delete(guildId: string): boolean;
-    /**
-     * Stringify the queue for a guild
-     * @param value The queue to stringify
-     * @returns The stringified queue
-     */
-    stringify(value: StoredQueue | string): StoredQueue | string;
-    /**
-     * Parse the queue for a guild
-     * @param value The queue to parse
-     * @returns The parsed queue
-     */
-    parse(value: StoredQueue | string): Partial<StoredQueue>;
-}
-declare class Queue {
-    readonly tracks: (Track | UnresolvedTrack)[];
-    readonly previous: Track[];
-    current: Track | null;
-    options: {
-        maxPreviousTracks: number;
-    };
-    private readonly guildId;
-    private readonly QueueSaver;
-    private managerUtils;
-    private queueChanges;
-    /**
-     * Create a new Queue
-     * @param guildId The guild ID
-     * @param data The data to initialize the queue with
-     * @param QueueSaver The queue saver to use
-     * @param queueOptions
-     */
-    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: ManagerQueueOptions);
-    /**
-     * Utils for a Queue
-     */
-    utils: {
-        /**
-         * Save the current cached Queue on the database/server (overides the server)
-         */
-        save: () => Promise<boolean | void>;
-        /**
-         * Sync the current queue database/server with the cached one
-         * @returns {void}
-         */
-        sync: (override?: boolean, dontSyncCurrent?: boolean) => Promise<void>;
-        destroy: () => Promise<boolean | void>;
-        /**
-         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
-         */
-        toJSON: () => StoredQueue;
-        /**
-         * Get the Total Duration of the Queue-Songs summed up
-         * @returns {number}
-         */
-        totalDuration: () => number;
-    };
-    /**
-     * Shuffles the current Queue, then saves it
-     * @returns Amount of Tracks in the Queue
+     * // Apply the filters after changing them manually:
+     * player.filterManager.data.volume = 0.5;
+     * // maybe you wanna manually set a distorition filter? then do it like this...
+     * player.filterManager.data.distortion = { sinOffset: 0.5, sinScale: 2, cosOffset: 0.5, cosScale: 2, tanOffset: 0.5, tanScale: 2, offset: 0.5, scale: 2 };
+     * await player.filterManager.applyPlayerFilters();
+     * ```
      */
-    shuffle(): Promise<number>;
+    applyPlayerFilters(): Promise<void>;
+    privateNot0(value: number | undefined): boolean;
     /**
-     * Add a Track to the Queue, and after saved in the "db" it returns the amount of the Tracks
-     * @param {Track | Track[]} TrackOrTracks
-     * @param {number} index At what position to add the Track
-     * @returns {number} Queue-Size (for the next Tracks)
+     * Checks if the filters are correctly stated (active / not-active) - mostly used internally.
+     * @param oldFilterTimescale
+     * @returns {boolean} True, if the check was successfull
+     *
+     * @example
+     * ```ts
+     * // Check the filter states
+     * player.filterManager.checkFiltersState();
+     * // Apply the filters after checking
+     * await player.filterManager.applyPlayerFilters();
+     * ```
      */
-    add(TrackOrTracks: Track | UnresolvedTrack | (Track | UnresolvedTrack)[], index?: number): any;
+    checkFiltersState(oldFilterTimescale?: Partial<TimescaleFilter>): boolean;
     /**
-     * Splice the tracks in the Queue
-     * @param {number} index Where to remove the Track
-     * @param {number} amount How many Tracks to remove?
-     * @param {Track | Track[]} TrackOrTracks Want to Add more Tracks?
-     * @returns {Track} Spliced Track
+     * Reset all Filters
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Reset all filters
+     * await player.filterManager.resetFilters();
+     * ```
      */
-    splice(index: number, amount: number, TrackOrTracks?: Track | UnresolvedTrack | (Track | UnresolvedTrack)[]): any;
+    resetFilters(): Promise<FilterManager>;
     /**
-     * Remove stuff from the queue.tracks array
-     *  - single Track | UnresolvedTrack
-     *  - multiple Track | UnresovedTrack
-     *  - at the index or multiple indexes
-     *  - Since v2.7 the removed tracks get unshifted into the previous queue state instead of pushed (indexed at the start instead of end - as it should)
-     * @param removeQueryTrack
-     * @returns null (if nothing was removed) / { removed } where removed is an array with all removed elements
+     * Set the Filter Volume
+     * @param volume the volume (0.0 - 5.0)
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
      *
      * @example
-     * ```js
-     * // remove single track
-     *
-     * const track = player.queue.tracks[4];
-     * await player.queue.remove(track);
-     *
-     * // if you already have the index you can straight up pass it too
-     * await player.queue.remove(4);
-     *
-     *
-     * // if you want to remove multiple tracks, e.g. from position 4 to position 10 you can do smt like this
-     * await player.queue.remove(player.queue.tracks.slice(4, 10)) // get's the tracks from 4 - 10, which then get's found in the remove function to be removed
+     * ```ts
+     * // Set Volume to 50%
+     * await player.filterManager.setVolume(0.5);
+     * // note this is a filter, so it will "jump" to the volume, i think it's like a "volume boost effect" so i marketed it as a filter
+     * ```
+     */
+    setVolume(volume: number): Promise<this>;
+    /**
+     * Set the AudioOutput Filter
+     * @param {AudioOutputs} type the audio output type
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
      *
-     * // I still highly suggest to use .splice!
+     * @example
+     * ```ts
+     * // Set Audio Output to Mono
+     * await player.filterManager.setAudioOutput("mono");
      *
-     * await player.queue.splice(4, 10); // removes at index 4, 10 tracks
+     * // Set Audio Output to Stereo
+     * await player.filterManager.setAudioOutput("stereo");
      *
-     * await player.queue.splice(1, 1); // removes at index 1, 1 track
+     * // Set Audio Output to Left
+     * await player.filterManager.setAudioOutput("left");
      *
-     * await player.queue.splice(4, 0, ...tracks) // removes 0 tracks at position 4, and then inserts all tracks after position 4.
+     * // Set Audio Output to Right
+     * await player.filterManager.setAudioOutput("right");
      * ```
      */
-    remove<T extends Track | UnresolvedTrack | number | Track[] | UnresolvedTrack[] | number[] | (number | Track | UnresolvedTrack)[]>(removeQueryTrack: T): Promise<{
-        removed: (Track | UnresolvedTrack)[];
-    } | null>;
+    setAudioOutput(type: AudioOutputs): Promise<FilterManager>;
     /**
-     * Shifts the previous array, to return the last previous track & thus remove it from the previous queue
-     * @returns
+     * Set custom filter.timescale#speed . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
+     * @param {number} speed set the speed of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
      *
      * @example
-     * ```js
-     * // example on how to play the previous track again
-     * const previous = await player.queue.shiftPrevious(); // get the previous track and remove it from the previous queue array!!
-     * if(!previous) return console.error("No previous track found");
-     * await player.play({ clientTrack: previous }); // play it again
+     * ```ts
+     * // Set Speed to 1.25 (disableds nightcore and vaporwave effect which are pre-made timescale settings of rate,pitch and speed)
+     * await player.filterManager.setSpeed(1.25);
      * ```
      */
-    shiftPrevious(): Promise<Track>;
-}
-
-declare class Player {
-    /** Filter Manager per player */
-    filterManager: FilterManager;
-    /** circular reference to the lavalink Manager from the Player for easier use */
-    LavalinkManager: LavalinkManager;
-    /** Player options currently used, mutation doesn't affect player's state */
-    options: PlayerOptions;
-    /** The lavalink node assigned the the player, don't change it manually */
-    node: LavalinkNode;
-    /** The queue from the player */
-    queue: Queue;
-    /** The Guild Id of the Player */
-    guildId: string;
-    /** The Voice Channel Id of the Player */
-    voiceChannelId: string | null;
-    /** The Text Channel Id of the Player */
-    textChannelId: string | null;
-    /** States if the Bot is supposed to be outputting audio */
-    playing: boolean;
-    /** States if the Bot is paused or not */
-    paused: boolean;
-    /** Repeat Mode of the Player */
-    repeatMode: RepeatMode;
-    /** Player's ping */
-    ping: {
-        lavalink: number;
-        ws: number;
-    };
-    /** The Display Volume */
-    volume: number;
-    /** The Volume Lavalink actually is outputting */
-    lavalinkVolume: number;
-    /** The current Positin of the player (Calculated) */
-    get position(): number;
-    /** The timestamp when the last position change update happened */
-    lastPositionChange: number | null;
-    /** The current Positin of the player (from Lavalink) */
-    lastPosition: number;
-    lastSavedPosition: number;
-    /** When the player was created [Timestamp in Ms] (from lavalink) */
-    createdTimeStamp: number;
-    /** The Player Connection's State (from Lavalink) */
-    connected: boolean | undefined;
-    /** Voice Server Data (from Lavalink) */
-    voice: LavalinkPlayerVoiceOptions;
-    voiceState: {
-        selfDeaf: boolean;
-        selfMute: boolean;
-        serverDeaf: boolean;
-        serverMute: boolean;
-        suppress: boolean;
-    };
-    /** Custom data for the player */
-    private readonly data;
-    /**
-     * Create a new Player
-     * @param options
-     * @param LavalinkManager
-     */
-    constructor(options: PlayerOptions, LavalinkManager: LavalinkManager, dontEmitPlayerCreateEvent?: boolean);
-    /**
-     * Set custom data.
-     * @param key
-     * @param value
-     */
-    set(key: string, value: unknown): this;
-    /**
-     * Get custom data.
-     * @param key
-     */
-    get<T>(key: string): T;
-    /**
-     * CLears all the custom data.
-     */
-    clearData(): this;
-    /**
-     * Get all custom Data
-     */
-    getAllData(): Record<string, unknown>;
-    /**
-     * Play the next track from the queue / a specific track, with playoptions for Lavalink
-     * @param options
-     */
-    play(options?: Partial<PlayOptions>): any;
-    /**
-     * Set the Volume for the Player
-     * @param volume The Volume in percent
-     * @param ignoreVolumeDecrementer If it should ignore the volumedecrementer option
-     */
-    setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
-    /**
-     * Search for a track
-     * @param query The query to search for
-     * @param requestUser The user that requested the track
-     * @param throwOnEmpty If an error should be thrown if no track is found
-     * @returns The search result
-     */
-    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<LavaSearchResponse | SearchResult>;
-    /**
-     * Set the SponsorBlock
-     * @param segments The segments to set
-     */
-    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
-    /**
-     * Get the SponsorBlock
-     */
-    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
-    /**
-     * Delete the SponsorBlock
-     */
-    deleteSponsorBlock(): Promise<void>;
+    setSpeed(speed?: number): Promise<FilterManager>;
     /**
+     * Set custom filter.timescale#pitch . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
+     * @param  {number} pitch set the pitch of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
      *
-     * @param query Query for your data
-     * @param requestUser
+     * @example
+     * ```ts
+     * // Set Pitch to 1.25 (disableds nightcore and vaporwave effect which are pre-made timescale settings of rate,pitch and speed)
+     * await player.filterManager.setPitch(1.25);
+     * ```
      */
-    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<UnresolvedSearchResult | SearchResult>;
+    setPitch(pitch?: number): Promise<FilterManager>;
     /**
-     * Pause the player
+     * Set custom filter.timescale#rate . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
+     * @param {number} rate set the rate of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Set Rate to 1.25 (disableds nightcore and vaporwave effect which are pre-made timescale settings of rate,pitch and speed)
+     * await player.filterManager.setRate(1.25);
+     * ```
      */
-    pause(): Promise<this>;
+    setRate(rate?: number): Promise<FilterManager>;
     /**
-     * Resume the Player
+     * Enables / Disables the rotation effect, (Optional: provide your Own Data)
+     * @param {number} rotationHz set the rotationHz of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Toggle Rotation filter with custom settings
+     * await player.filterManager.toggleRotation(0.4);
+     * // or use the defaults
+     * await player.filterManager.toggleRotation();
+     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+     * ```
      */
-    resume(): Promise<this>;
+    toggleRotation(rotationHz?: number): Promise<FilterManager>;
     /**
-     * Seek to a specific Position
-     * @param position
+     * Enables / Disables the Vibrato effect, (Optional: provide your Own Data)
+     * @param {number} frequency set the frequency of the filter
+     * @param {number} depth set the depth of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Toggle Vibrato filter with custom settings
+     * await player.filterManager.toggleVibrato(8, 0.5);
+     * // or use the defaults
+     * await player.filterManager.toggleVibrato();
+     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+     * ```
      */
-    seek(position: number): Promise<this>;
+    toggleVibrato(frequency?: number, depth?: number): Promise<FilterManager>;
     /**
-     * Set the Repeatmode of the Player
-     * @param repeatMode
+     * Enables / Disables the Tremolo effect, (Optional: provide your Own Data)
+     * @param {number} frequency set the frequency of the filter
+     * @param {number} depth set the depth of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Toggle Tremolo filter with custom settings
+     * await player.filterManager.toggleTremolo(5, 0.7);
+     * // or use the defaults
+     * await player.filterManager.toggleTremolo();
+     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+     * ```
      */
-    setRepeatMode(repeatMode: RepeatMode): Promise<this>;
+    toggleTremolo(frequency?: number, depth?: number): Promise<FilterManager>;
     /**
-     * Skip the current song, or a specific amount of songs
-     * @param amount provide the index of the next track to skip to
+     * Enables / Disables the LowPass effect, (Optional: provide your Own Data)
+     * @param {number} smoothing set the smoothing of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Toggle LowPass filter with custom settings
+     * await player.filterManager.toggleLowPass(30);
+     * // or use the defaults
+     * await player.filterManager.toggleLowPass();
+     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+     * ```
      */
-    skip(skipTo?: number, throwError?: boolean): Promise<this>;
+    toggleLowPass(smoothing?: number): Promise<FilterManager>;
     /**
-     * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
-     * @returns
+     * Lavalink LavaDspx Plugin Filters
      */
-    stopPlaying(clearQueue?: boolean, executeAutoplay?: boolean): Promise<this>;
+    lavalinkLavaDspxPlugin: {
+        /**
+         * Enables / Disables the LowPass effect, (Optional: provide your Own Data)
+         * @param {number} boostFactor set the boost factor of the filter
+         * @param {number} cutoffFrequency set the cutoff frequency of the filter
+         * @returns  {Promise<boolean>} the state of the filter after execution.
+         *
+         * @example
+         * ```ts
+         * // Toggle LowPass filter with custom settings
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleLowPass(1.2, 300);
+         * // or use the defaults
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleLowPass();
+         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+         * ```
+         */
+        toggleLowPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<FilterManager>;
+        /**
+         * Enables / Disables the HighPass effect, (Optional: provide your Own Data)
+         * @param {number} boostFactor [] set the boost factor of the filter
+         * @param {number} cutoffFrequency set the cutoff frequency of the filter
+         * @returns  {Promise<boolean>} the state of the filter after execution.
+         *
+         * @example
+         * ```ts
+         * // Toggle HighPass filter with custom settings
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleHighPass(1.2, 150); // custom values
+         * // or use the defaults
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleHighPass();
+         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+         * ```
+         */
+        toggleHighPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<FilterManager>;
+        /**
+         * Enables / Disables the Normalization effect.
+         * @param {number} [maxAmplitude=0.75] - The maximum amplitude of the audio.
+         * @param {boolean} [adaptive=true] Whether to use adaptive normalization or not.
+         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+         *
+         * @example
+         * ```ts
+         * // Toggle Normalization filter with custom settings
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleNormalization(0.9, false); // custom values
+         * // or use the defaults
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleNormalization();
+         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+         * ```
+         */
+        toggleNormalization: (maxAmplitude?: number, adaptive?: boolean) => Promise<FilterManager>;
+        /**
+         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
+         * @param {number} [decay=0.5] The decay of the echo effect.
+         * @param {number} [echoLength=0.5] The length of the echo effect.
+         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+         *
+         * @example
+         * ```ts
+         * // Toggle Echo filter with custom settings
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleEcho(0.7, 0.6); // custom values
+         * // or use the defaults
+         * await player.filterManager.lavalinkLavaDspxPlugin.toggleEcho();
+         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+         * ```
+         */
+        toggleEcho: (decay?: number, echoLength?: number) => Promise<FilterManager>;
+    };
     /**
-     * Connects the Player to the Voice Channel
-     * @returns
+     * LavalinkFilter Plugin specific Filters
      */
-    connect(): Promise<this>;
-    changeVoiceState(data: {
-        voiceChannelId?: string;
-        selfDeaf?: boolean;
-        selfMute?: boolean;
-    }): Promise<this>;
+    lavalinkFilterPlugin: {
+        /**
+         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
+         * @param {number} delay set the delay of the echo
+         * @param {number} decay set the decay of the echo
+         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+         *
+         * @example
+         * ```ts
+         * // Toggle Echo filter with custom settings
+         * await player.filterManager.lavalinkFilterPlugin.toggleEcho(3, 0.7); // custom values
+         * // or use the defaults
+         * await player.filterManager.lavalinkFilterPlugin.toggleEcho();
+         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+         * ```
+         */
+        toggleEcho: (delay?: number, decay?: number) => Promise<FilterManager>;
+        /**
+         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
+         * @param {number} delays set the delays of the reverb
+         * @param {number} gains set the gains of the reverb
+         * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+         *
+         * @example
+         * ```ts
+         * // Toggle Reverb filter with custom settings
+         * await player.filterManager.lavalinkFilterPlugin.toggleReverb([0.04, 0.045, 0.05, 0.055], [0.85, 0.84, 0.83, 0.82]);
+         * // or use the defaults
+         * await player.filterManager.lavalinkFilterPlugin.toggleReverb();
+         * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+         * ```
+         */
+        toggleReverb: (delays?: number[], gains?: number[]) => Promise<FilterManager>;
+    };
     /**
-     * Disconnects the Player from the Voice Channel, but keeps the player in the cache
-     * @param force If false it throws an error, if player thinks it's already disconnected
-     * @returns
+     * Enables / Disables a Nightcore-like filter Effect. Disables/Overrides both: custom and Vaporwave Filter
+     * @param {number} speed set the speed of the filter
+     * @param {number} pitch set the pitch of the filter
+     * @param {number} rate set the rate of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Toggle Nightcore filter with custom settings
+     * await player.filterManager.toggleNightcore(1.3, 1.3, 0.9);
+     * // or use the defaults
+     * await player.filterManager.toggleNightcore();
+     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+     * ```
      */
-    disconnect(force?: boolean): Promise<this>;
+    toggleNightcore(speed?: number, pitch?: number, rate?: number): Promise<FilterManager>;
     /**
-     * Destroy the player and disconnect from the voice channel
+     * Enables / Disables a Vaporwave-like filter Effect. Disables/Overrides both: custom and nightcore Filter
+     * @param {number} speed set the speed of the filterq
+     * @param {number} pitch set the pitch of the filter
+     * @param {number} rate set the rate of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
+     * @example
+     * ```ts
+     * // Toggle Vaporwave filter with custom settings
+     * await player.filterManager.toggleVaporwave(0.9, 0.7, 1);
+     * // or use the defaults
+     * await player.filterManager.toggleVaporwave();
+     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
+     * ```
      */
-    destroy(reason?: DestroyReasons | string, disconnect?: boolean): Promise<this>;
+    toggleVaporwave(speed?: number, pitch?: number, rate?: number): Promise<FilterManager>;
     /**
-     * Get the current lyrics of the track currently playing on the guild
-     * @param guildId The guild id to get the current lyrics for
-     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
-     * @returns The current lyrics
+     * Enable / Disables a Karaoke like Filter Effect
+     * @param {number} level set the level of the filter
+     * @param {number} monoLevel set the mono level of the filter
+     * @param {number} filterBand set the filter band of the filter
+     * @param {number} filterWidth set the filter width of the filter
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
      * @example
      * ```ts
-     * const lyrics = await player.getCurrentLyrics();
+     * // Toggle Karaoke filter with custom settings
+     * await player.filterManager.toggleKaraoke(1.5, 1.0, 220, 100);
+     * // or use the defaults
+     * await player.filterManager.toggleKaraoke();
+     * // when it's enabled before calling the toggle function, it disables it, so you might need to do some if/else logic.
      * ```
      */
-    getCurrentLyrics(skipTrackSource?: boolean): Promise<LyricsResult>;
+    toggleKaraoke(level?: number, monoLevel?: number, filterBand?: number, filterWidth?: number): Promise<FilterManager>;
     /**
-     * Get the lyrics of a specific track
-     * @param track The track to get the lyrics for
-     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
-     * @returns The lyrics of the track
+     * Function to find out if currently there is a custom timescamle etc. filter applied
+     * @returns {boolean} whether a custom filter is active
+     *
      * @example
      * ```ts
-     * const lyrics = await player.getLyrics(player.queue.tracks[0], true);
+     * // Check if a custom filter is active
+     * const isCustom = player.filterManager.isCustomFilterActive();
+     * console.log(`Is custom filter active? ${isCustom}`);
      * ```
      */
-    getLyrics(track: Track, skipTrackSource?: boolean): Promise<LyricsResult>;
+    isCustomFilterActive(): boolean;
     /**
-     * Subscribe to the lyrics event on a specific guild to active live lyrics events
-     * @returns The unsubscribe function
+     * Sets the players equalizer bands using one of the predefined presets.
+     * @param {keyof typeof EQList} preset The preset to use.
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
      * @example
      * ```ts
-     * const lyrics = await player.subscribeLyrics();
+     * // Set EQ preset
+     * await player.filterManager.setEQPreset('BassboostMedium');
      * ```
      */
-    subscribeLyrics(): Promise<unknown>;
+    setEQPreset(preset: keyof typeof EQList): Promise<this>;
     /**
-     * Unsubscribe from the lyrics event on a specific guild to disable live lyrics events
-     * @returns The unsubscribe function
+     * Sets the players equalizer band on-top of the existing ones.
+     * @param {number} bands
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
      * @example
      * ```ts
-     * const lyrics = await player.unsubscribeLyrics();
+     * // Set EQ bands
+     * await player.filterManager.setEQ([
+     *   { band: 0, gain: 0.3 },
+     *   { band: 1, gain: -0.2 },
+     *   { band: 2, gain: 0.1 }
+     * ]);
+     *
+     * // or use one of the templates:
+     * await player.filterManager.setEQ(player.filterManager.EQList.BassboostMedium); // you can also import EQList from somewhere package if wanted.
      * ```
      */
-    unsubscribeLyrics(): Promise<void>;
+    setEQ(bands: EQBand | EQBand[]): Promise<this>;
     /**
-     * Move the player on a different Audio-Node
-     * @param newNode New Node / New Node Id
-     * @param checkSources If it should check if the sources are supported by the new node @default true
-     * @return The new Node Id
+     * Clears the equalizer bands.
+     * @returns {Promise<FilterManager>} The Filter Manager, for chaining.
+     *
      * @example
      * ```ts
-     * const changeNode = await player.changeNode(newNode, true);
+     * // Clear all EQ bands
+     * await player.filterManager.clearEQ();
      * ```
      */
-    changeNode(newNode: LavalinkNode | string, checkSources?: boolean): Promise<string>;
-    /**
-     * Move the player to a different node. If no node is provided, it will find the least used node that is not the same as the current node.
-     * @param node the id of the node to move to
-     * @returns the player
-     * @throws RangeError if there is no available nodes.
-     * @throws Error if the node to move to is the same as the current node.
-     */
-    moveNode(node?: string): Promise<string | this>;
-    /** Converts the Player including Queue to a Json state */
-    toJSON(): PlayerJson;
+    clearEQ(): Promise<this>;
 }
 
 /** Sourcenames provided by lavalink server */
@@ -1234,398 +528,469 @@ interface UnresolvedTrackInfo extends Partial<TrackInfo> {
 }
 interface UnresolvedQuery extends UnresolvedTrackInfo {
     /** The base64 of the unresolved track to "encode" */
-    encoded?: Base64;
-}
-interface UnresolvedTrack {
-    /** Required */
-    resolve: (player: Player) => Promise<void>;
-    /** The Base 64 encoded String */
-    encoded?: Base64;
-    /** Track Information */
-    info: UnresolvedTrackInfo;
-    /** Plugin Information from Lavalink */
-    pluginInfo: Partial<PluginInfo>;
-    /** The userData Object from when you provide to the lavalink request */
-    userData?: anyObject;
-    /** The Track's Requester */
-    requester?: unknown;
-}
-
-interface StoredQueue {
-    current: Track | null;
-    previous: Track[];
-    tracks: (Track | UnresolvedTrack)[];
-}
-interface QueueStoreManager {
-    /** @async get a Value (MUST RETURN UNPARSED!) */
-    get: (guildId: string) => Awaitable<StoredQueue | string | undefined>;
-    /** @async Set a value inside a guildId (MUST BE UNPARSED) */
-    set: (guildId: string, value: StoredQueue | string) => Awaitable<void | boolean>;
-    /** @async Delete a Database Value based of it's guildId */
-    delete: (guildId: string) => Awaitable<void | boolean>;
-    /** @async Transform the value(s) inside of the QueueStoreManager (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
-    stringify: (value: StoredQueue | string) => Awaitable<StoredQueue | string>;
-    /** @async Parse the saved value back to the Queue (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
-    parse: (value: StoredQueue | string) => Awaitable<Partial<StoredQueue>>;
-}
-interface ManagerQueueOptions {
-    /** Maximum Amount of tracks for the queue.previous array. Set to 0 to not save previous songs. Defaults to 25 Tracks */
-    maxPreviousTracks?: number;
-    /** Custom Queue Store option */
-    queueStore?: QueueStoreManager;
-    /** Custom Queue Watcher class */
-    queueChangesWatcher?: QueueChangesWatcher;
-}
-interface QueueChangesWatcher {
-    /** get a Value (MUST RETURN UNPARSED!) */
-    tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
-    /** Set a value inside a guildId (MUST BE UNPARSED) */
-    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number | number[], oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
-    /** Set a value inside a guildId (MUST BE UNPARSED) */
-    shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
-}
-
-type DestroyReasonsType = keyof typeof DestroyReasons | string;
-type DisconnectReasonsType = keyof typeof DisconnectReasons | string;
-interface PlayerJson {
-    /** Guild Id where the player was playing in */
-    guildId: string;
-    /** Options provided to the player */
-    options: PlayerOptions;
-    /** Voice Channel Id the player was playing in */
-    voiceChannelId: string;
-    /** Text Channel Id the player was synced to */
-    textChannelId?: string;
-    /** Position the player was at */
-    position: number;
-    /** Lavalink's position the player was at */
-    lastPosition: number;
-    /** Last time the position was sent from lavalink */
-    lastPositionChange: number | null;
-    /** Volume in % from the player (without volumeDecrementer) */
-    volume: number;
-    /** Real Volume used in lavalink (with the volumeDecrementer) */
-    lavalinkVolume: number;
-    /** The repeatmode from the player */
-    repeatMode: RepeatMode;
-    /** Pause state */
-    paused: boolean;
-    /** Wether the player was playing or not */
-    playing: boolean;
-    /** When the player was created */
-    createdTimeStamp?: number;
-    /** All current used fitlers Data */
-    filters: FilterData;
-    /** The player's ping object */
-    ping: {
-        /** Ping to the voice websocket server */
-        ws: number;
-        /** Avg. calc. Ping to the lavalink server */
-        lavalink: number;
-    };
-    /** Equalizer Bands used in lavalink */
-    equalizer: EQBand[];
-    /** The Id of the last used node */
-    nodeId?: string;
-    /** The SessionId of the node */
-    nodeSessionId?: string;
-    /** The stored queue */
-    queue?: StoredQueue;
-}
-type RepeatMode = "queue" | "track" | "off";
-interface PlayerOptions {
-    /** Guild id of the player */
-    guildId: string;
-    /** The Voice Channel Id */
-    voiceChannelId: string;
-    /** The Text Channel Id of the Player */
-    textChannelId?: string;
-    /** instantly change volume with the one play request */
-    volume?: number;
-    /** VC Region for node selections */
-    vcRegion?: string;
-    /** if it should join deafened */
-    selfDeaf?: boolean;
-    /** If it should join muted */
-    selfMute?: boolean;
-    /** If it should use a specific lavalink node */
-    node?: LavalinkNode | string;
-    /** If when applying filters, it should use the insta apply filters fix  */
-    instaUpdateFiltersFix?: boolean;
-    /** If a volume should be applied via filters instead of lavalink-volume */
-    applyVolumeAsFilter?: boolean;
-    /** Custom Data for the player get/set datastorage */
-    customData?: anyObject;
-}
-type anyObject = {
-    [key: string | number]: string | number | null | anyObject;
-};
-interface BasePlayOptions {
-    /** The position to start the track. */
-    position?: number;
-    /** The position to end the track. */
-    endTime?: number;
-    /** If to start "paused" */
-    paused?: boolean;
-    /** The Volume to start with */
-    volume?: number;
-    /** The Lavalink Filters to use | only with the new REST API */
-    filters?: Partial<LavalinkFilterData>;
-    /** Voice Update for Lavalink */
-    voice?: LavalinkPlayerVoiceOptions;
-}
-interface LavalinkPlayOptions extends BasePlayOptions {
-    /** Which Track to play | don't provide, if it should pick from the Queue */
-    track?: {
-        /** The track encoded base64 string to use instead of the one from the queue system */
-        encoded?: Base64 | null;
-        /** The identifier of the track to use */
-        identifier?: string;
-        /** Custom User Data for the track to provide, will then be on the userData object from the track */
-        userData?: anyObject;
-        /** The Track requester for when u provide encodedTrack / identifer */
-        requester?: unknown;
-    };
-}
-interface PlayOptions extends LavalinkPlayOptions {
-    /** Whether to not replace the track if a play payload is sent. */
-    noReplace?: boolean;
-    /** Adds track on queue and skips to it */
-    clientTrack?: Track | UnresolvedTrack;
-}
-
-/** Ability to manipulate fetch requests */
-type ModifyRequest = (options: RequestInit & {
-    path: string;
-    extraQueryUrlParams?: URLSearchParams;
-}) => void;
-type SponsorBlockSegment = "sponsor" | "selfpromo" | "interaction" | "intro" | "outro" | "preview" | "music_offtopic" | "filler";
-/**
- * Node Options for creating a lavalink node
- */
-interface LavalinkNodeOptions {
-    /** The Lavalink Server-Ip / Domain-URL */
-    host: string;
-    /** The Lavalink Connection Port */
-    port: number;
-    /** The Lavalink Password / Authorization-Key */
-    authorization: string;
-    /** Does the Server use ssl (https) */
-    secure?: boolean;
-    /** RESUME THE PLAYER? by providing a sessionid on the node-creation */
-    sessionId?: string;
-    /** Add a Custom ID to the node, for later use */
-    id?: string;
-    /** Voice Regions of this Node */
-    regions?: string[];
-    /** The retryAmount for the node. */
-    retryAmount?: number;
-    /** The retryDelay for the node. */
-    retryDelay?: number;
-    /** signal for cancelling requests - default: AbortSignal.timeout(options.requestSignalTimeoutMS || 10000) - put <= 0 to disable */
-    requestSignalTimeoutMS?: number;
-    /** Close on error */
-    closeOnError?: boolean;
-    /** Heartbeat interval , set to <= 0 to disable heartbeat system */
-    heartBeatInterval?: number;
-    /** Recommended, to check wether the client is still connected or not on the stats endpoint */
-    enablePingOnStatsCheck?: boolean;
-}
-/**
- * Memory Stats object from lavalink
- */
-interface MemoryStats {
-    /** The free memory of the allocated amount. */
-    free: number;
-    /** The used memory of the allocated amount. */
-    used: number;
-    /** The total allocated memory. */
-    allocated: number;
-    /** The reservable memory. */
-    reservable: number;
-}
-/**
- * CPU Stats object from lavalink
- */
-interface CPUStats {
-    /** The core amount the host machine has. */
-    cores: number;
-    /** The system load. */
-    systemLoad: number;
-    /** The lavalink load. */
-    lavalinkLoad: number;
-}
-/**
- * FrameStats Object from lavalink
- */
-interface FrameStats {
-    /** The amount of sent frames. */
-    sent?: number;
-    /** The amount of nulled frames. */
-    nulled?: number;
-    /** The amount of deficit frames. */
-    deficit?: number;
+    encoded?: Base64;
 }
-/**
- * BaseNodeStats object from Lavalink
- */
-interface BaseNodeStats {
-    /** The amount of players on the node. */
-    players: number;
-    /** The amount of playing players on the node. */
-    playingPlayers: number;
-    /** The uptime for the node. */
-    uptime: number;
-    /** The memory stats for the node. */
-    memory: MemoryStats;
-    /** The cpu stats for the node. */
-    cpu: CPUStats;
-    /** The frame stats for the node. */
-    frameStats: FrameStats;
+interface UnresolvedTrack {
+    /** Required */
+    resolve: (player: Player) => Promise<void>;
+    /** The Base 64 encoded String */
+    encoded?: Base64;
+    /** Track Information */
+    info: UnresolvedTrackInfo;
+    /** Plugin Information from Lavalink */
+    pluginInfo: Partial<PluginInfo>;
+    /** The userData Object from when you provide to the lavalink request */
+    userData?: anyObject;
+    /** The Track's Requester */
+    requester?: unknown;
 }
-/**
- * Interface for nodeStats from lavalink
- */
-interface NodeStats extends BaseNodeStats {
-    /** The frame stats for the node. */
-    frameStats: FrameStats;
+
+interface StoredQueue {
+    current: Track | null;
+    previous: Track[];
+    tracks: (Track | UnresolvedTrack)[];
 }
-/**
- * Entire lavalink information object from lavalink
- */
-interface LavalinkInfo {
-    /** The version of this Lavalink server */
-    version: VersionObject;
-    /** The millisecond unix timestamp when this Lavalink jar was built */
-    buildTime: number;
-    /** The git information of this Lavalink server */
-    git: GitObject;
-    /** The JVM version this Lavalink server runs on */
-    jvm: string;
-    /** The Lavaplayer version being used by this server */
-    lavaplayer: string;
-    /** The enabled source managers for this server */
-    sourceManagers: string[];
-    /** The enabled filters for this server */
-    filters: string[];
-    /** The enabled plugins for this server */
-    plugins: PluginObject[];
+interface QueueStoreManager {
+    /** @async get a Value (MUST RETURN UNPARSED!) */
+    get: (guildId: string) => Awaitable<StoredQueue | string | undefined>;
+    /** @async Set a value inside a guildId (MUST BE UNPARSED) */
+    set: (guildId: string, value: StoredQueue | string) => Awaitable<void | boolean>;
+    /** @async Delete a Database Value based of it's guildId */
+    delete: (guildId: string) => Awaitable<void | boolean>;
+    /** @async Transform the value(s) inside of the QueueStoreManager (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
+    stringify: (value: StoredQueue | string) => Awaitable<StoredQueue | string>;
+    /** @async Parse the saved value back to the Queue (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
+    parse: (value: StoredQueue | string) => Awaitable<Partial<StoredQueue>>;
 }
-/**
- * Lavalink's version object from lavalink
- */
-interface VersionObject {
-    /** The full version string of this Lavalink server */
-    semver: string;
-    /** The major version of this Lavalink server */
-    major: number;
-    /** The minor version of this Lavalink server */
-    minor: number;
-    /** The patch version of this Lavalink server */
-    patch: number;
-    /** The pre-release version according to semver as a . separated list of identifiers */
-    preRelease?: string;
-    /** The build metadata according to semver as a . separated list of identifiers */
-    build?: string;
+interface ManagerQueueOptions {
+    /** Maximum Amount of tracks for the queue.previous array. Set to 0 to not save previous songs. Defaults to 25 Tracks */
+    maxPreviousTracks?: number;
+    /** Custom Queue Store option */
+    queueStore?: QueueStoreManager;
+    /** Custom Queue Watcher class */
+    queueChangesWatcher?: QueueChangesWatcher;
 }
-/**
- * Git information object from lavalink
- */
-interface GitObject {
-    /** The branch this Lavalink server was built on */
-    branch: string;
-    /** The commit this Lavalink server was built on */
-    commit: string;
-    /** The millisecond unix timestamp for when the commit was created */
-    commitTime: string;
+interface QueueChangesWatcher {
+    /** get a Value (MUST RETURN UNPARSED!) */
+    tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number | number[], oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
 }
-/**
- * Lavalink's plugins object from lavalink's plugin
- */
-interface PluginObject {
-    /** The name of the plugin */
-    name: string;
-    /** The version of the plugin */
-    version: string;
+
+declare class QueueSaver {
+    /**
+     * The queue store manager
+     */
+    private _;
+    /**
+     * The options for the queue saver
+     */
+    options: {
+        maxPreviousTracks: number;
+    };
+    constructor(options: ManagerQueueOptions);
+    /**
+     * Get the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
+    get(guildId: string): Promise<Partial<StoredQueue>>;
+    /**
+     * Delete the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
+    delete(guildId: string): Promise<boolean | void>;
+    /**
+     * Set the queue for a guild
+     * @param guildId The guild ID
+     * @param valueToStringify The queue to set
+     * @returns The queue for the guild
+     */
+    set(guildId: string, valueToStringify: StoredQueue): Promise<boolean | void>;
+    /**
+     * Sync the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
+    sync(guildId: string): Promise<Partial<StoredQueue>>;
 }
-interface LyricsResult {
-    /**The name of the source */
-    sourceName: string;
-    /**The name of the provider */
-    provider: string;
-    /**The result text */
-    text: string | null;
-    /**The lyrics lines */
-    lines: LyricsLine[];
-    /**Information about the plugin */
-    plugin: PluginInfo;
+declare class DefaultQueueStore implements QueueStoreManager {
+    private data;
+    constructor();
+    /**
+     * Get the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
+    get(guildId: string): StoredQueue | undefined;
+    /**
+     * Set the queue for a guild
+     * @param guildId The guild ID
+     * @param valueToStringify The queue to set
+     * @returns The queue for the guild
+     */
+    set(guildId: string, valueToStringify: any): boolean;
+    /**
+     * Delete the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
+    delete(guildId: string): boolean;
+    /**
+     * Stringify the queue for a guild
+     * @param value The queue to stringify
+     * @returns The stringified queue
+     */
+    stringify(value: StoredQueue | string): StoredQueue | string;
+    /**
+     * Parse the queue for a guild
+     * @param value The queue to parse
+     * @returns The parsed queue
+     */
+    parse(value: StoredQueue | string): Partial<StoredQueue>;
 }
-interface LyricsLine {
-    /**The millisecond timestamp */
-    timestamp: number;
-    /**The line duration in milliseconds */
-    duration: number | null;
-    /**The line text */
-    line: string;
-    /**Information about the plugin */
-    plugin: PluginInfo;
+declare class Queue {
+    readonly tracks: (Track | UnresolvedTrack)[];
+    readonly previous: Track[];
+    current: Track | null;
+    options: {
+        maxPreviousTracks: number;
+    };
+    private readonly guildId;
+    private readonly QueueSaver;
+    private managerUtils;
+    private queueChanges;
+    /**
+     * Create a new Queue
+     * @param guildId The guild ID
+     * @param data The data to initialize the queue with
+     * @param QueueSaver The queue saver to use
+     * @param queueOptions
+     */
+    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: ManagerQueueOptions);
+    /**
+     * Utils for a Queue
+     */
+    utils: {
+        /**
+         * Save the current cached Queue on the database/server (overides the server)
+         */
+        save: () => Promise<boolean | void>;
+        /**
+         * Sync the current queue database/server with the cached one
+         * @returns {void}
+         */
+        sync: (override?: boolean, dontSyncCurrent?: boolean) => Promise<void>;
+        destroy: () => Promise<boolean | void>;
+        /**
+         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
+         */
+        toJSON: () => StoredQueue;
+        /**
+         * Get the Total Duration of the Queue-Songs summed up
+         * @returns {number}
+         */
+        totalDuration: () => number;
+    };
+    /**
+     * Shuffles the current Queue, then saves it
+     * @returns Amount of Tracks in the Queue
+     */
+    shuffle(): Promise<number>;
+    /**
+     * Add a Track to the Queue, and after saved in the "db" it returns the amount of the Tracks
+     * @param {Track | Track[]} TrackOrTracks
+     * @param {number} index At what position to add the Track
+     * @returns {number} Queue-Size (for the next Tracks)
+     */
+    add(TrackOrTracks: Track | UnresolvedTrack | (Track | UnresolvedTrack)[], index?: number): any;
+    /**
+     * Splice the tracks in the Queue
+     * @param {number} index Where to remove the Track
+     * @param {number} amount How many Tracks to remove?
+     * @param {Track | Track[]} TrackOrTracks Want to Add more Tracks?
+     * @returns {Track} Spliced Track
+     */
+    splice(index: number, amount: number, TrackOrTracks?: Track | UnresolvedTrack | (Track | UnresolvedTrack)[]): any;
+    /**
+     * Remove stuff from the queue.tracks array
+     *  - single Track | UnresolvedTrack
+     *  - multiple Track | UnresovedTrack
+     *  - at the index or multiple indexes
+     *  - Since v2.7 the removed tracks get unshifted into the previous queue state instead of pushed (indexed at the start instead of end - as it should)
+     * @param removeQueryTrack
+     * @returns null (if nothing was removed) / { removed } where removed is an array with all removed elements
+     *
+     * @example
+     * ```js
+     * // remove single track
+     *
+     * const track = player.queue.tracks[4];
+     * await player.queue.remove(track);
+     *
+     * // if you already have the index you can straight up pass it too
+     * await player.queue.remove(4);
+     *
+     *
+     * // if you want to remove multiple tracks, e.g. from position 4 to position 10 you can do smt like this
+     * await player.queue.remove(player.queue.tracks.slice(4, 10)) // get's the tracks from 4 - 10, which then get's found in the remove function to be removed
+     *
+     * // I still highly suggest to use .splice!
+     *
+     * await player.queue.splice(4, 10); // removes at index 4, 10 tracks
+     *
+     * await player.queue.splice(1, 1); // removes at index 1, 1 track
+     *
+     * await player.queue.splice(4, 0, ...tracks) // removes 0 tracks at position 4, and then inserts all tracks after position 4.
+     * ```
+     */
+    remove<T extends Track | UnresolvedTrack | number | Track[] | UnresolvedTrack[] | number[] | (number | Track | UnresolvedTrack)[]>(removeQueryTrack: T): Promise<{
+        removed: (Track | UnresolvedTrack)[];
+    } | null>;
+    /**
+     * Shifts the previous array, to return the last previous track & thus remove it from the previous queue
+     * @returns
+     *
+     * @example
+     * ```js
+     * // example on how to play the previous track again
+     * const previous = await player.queue.shiftPrevious(); // get the previous track and remove it from the previous queue array!!
+     * if(!previous) return console.error("No previous track found");
+     * await player.play({ clientTrack: previous }); // play it again
+     * ```
+     */
+    shiftPrevious(): Promise<Track>;
 }
-type LavalinkNodeIdentifier = string;
-interface NodeManagerEvents {
+
+declare class Player {
+    /** Filter Manager per player */
+    filterManager: FilterManager;
+    /** circular reference to the lavalink Manager from the Player for easier use */
+    LavalinkManager: LavalinkManager;
+    /** Player options currently used, mutation doesn't affect player's state */
+    options: PlayerOptions;
+    /** The lavalink node assigned the the player, don't change it manually */
+    node: LavalinkNode;
+    /** The queue from the player */
+    queue: Queue;
+    /** The Guild Id of the Player */
+    guildId: string;
+    /** The Voice Channel Id of the Player */
+    voiceChannelId: string | null;
+    /** The Text Channel Id of the Player */
+    textChannelId: string | null;
+    /** States if the Bot is supposed to be outputting audio */
+    playing: boolean;
+    /** States if the Bot is paused or not */
+    paused: boolean;
+    /** Repeat Mode of the Player */
+    repeatMode: RepeatMode;
+    /** Player's ping */
+    ping: {
+        lavalink: number;
+        ws: number;
+    };
+    /** The Display Volume */
+    volume: number;
+    /** The Volume Lavalink actually is outputting */
+    lavalinkVolume: number;
+    /** The current Positin of the player (Calculated) */
+    get position(): number;
+    /** The timestamp when the last position change update happened */
+    lastPositionChange: number | null;
+    /** The current Positin of the player (from Lavalink) */
+    lastPosition: number;
+    lastSavedPosition: number;
+    /** When the player was created [Timestamp in Ms] (from lavalink) */
+    createdTimeStamp: number;
+    /** The Player Connection's State (from Lavalink) */
+    connected: boolean | undefined;
+    /** Voice Server Data (from Lavalink) */
+    voice: LavalinkPlayerVoiceOptions;
+    voiceState: {
+        selfDeaf: boolean;
+        selfMute: boolean;
+        serverDeaf: boolean;
+        serverMute: boolean;
+        suppress: boolean;
+    };
+    /** Custom data for the player */
+    private readonly data;
     /**
-     * Emitted when a Node is created.
-     * @event Manager.nodeManager#create
+     * Create a new Player
+     * @param options
+     * @param LavalinkManager
+     */
+    constructor(options: PlayerOptions, LavalinkManager: LavalinkManager, dontEmitPlayerCreateEvent?: boolean);
+    /**
+     * Set custom data.
+     * @param key
+     * @param value
+     */
+    set(key: string, value: unknown): this;
+    /**
+     * Get custom data.
+     * @param key
+     */
+    get<T>(key: string): T;
+    /**
+     * CLears all the custom data.
+     */
+    clearData(): this;
+    /**
+     * Get all custom Data
+     */
+    getAllData(): Record<string, unknown>;
+    /**
+     * Play the next track from the queue / a specific track, with playoptions for Lavalink
+     * @param options
+     */
+    play(options?: Partial<PlayOptions>): any;
+    /**
+     * Set the Volume for the Player
+     * @param volume The Volume in percent
+     * @param ignoreVolumeDecrementer If it should ignore the volumedecrementer option
+     */
+    setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
+    /**
+     * Search for a track
+     * @param query The query to search for
+     * @param requestUser The user that requested the track
+     * @param throwOnEmpty If an error should be thrown if no track is found
+     * @returns The search result
+     */
+    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<LavaSearchResponse | SearchResult>;
+    /**
+     * Set the SponsorBlock
+     * @param segments The segments to set
+     */
+    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    /**
+     * Get the SponsorBlock
+     */
+    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    /**
+     * Delete the SponsorBlock
+     */
+    deleteSponsorBlock(): Promise<void>;
+    /**
+     *
+     * @param query Query for your data
+     * @param requestUser
+     */
+    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<UnresolvedSearchResult | SearchResult>;
+    /**
+     * Pause the player
+     */
+    pause(): Promise<this>;
+    /**
+     * Resume the Player
+     */
+    resume(): Promise<this>;
+    /**
+     * Seek to a specific Position
+     * @param position
+     */
+    seek(position: number): Promise<this>;
+    /**
+     * Set the Repeatmode of the Player
+     * @param repeatMode
+     */
+    setRepeatMode(repeatMode: RepeatMode): Promise<this>;
+    /**
+     * Skip the current song, or a specific amount of songs
+     * @param amount provide the index of the next track to skip to
+     */
+    skip(skipTo?: number, throwError?: boolean): Promise<this>;
+    /**
+     * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
+     * @returns
+     */
+    stopPlaying(clearQueue?: boolean, executeAutoplay?: boolean): Promise<this>;
+    /**
+     * Connects the Player to the Voice Channel
+     * @returns
+     */
+    connect(): Promise<this>;
+    changeVoiceState(data: {
+        voiceChannelId?: string;
+        selfDeaf?: boolean;
+        selfMute?: boolean;
+    }): Promise<this>;
+    /**
+     * Disconnects the Player from the Voice Channel, but keeps the player in the cache
+     * @param force If false it throws an error, if player thinks it's already disconnected
+     * @returns
+     */
+    disconnect(force?: boolean): Promise<this>;
+    /**
+     * Destroy the player and disconnect from the voice channel
+     */
+    destroy(reason?: DestroyReasons | string, disconnect?: boolean): Promise<this>;
+    /**
+     * Get the current lyrics of the track currently playing on the guild
+     * @param guildId The guild id to get the current lyrics for
+     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
+     * @returns The current lyrics
+     * @example
+     * ```ts
+     * const lyrics = await player.getCurrentLyrics();
+     * ```
+     */
+    getCurrentLyrics(skipTrackSource?: boolean): Promise<LyricsResult>;
+    /**
+     * Get the lyrics of a specific track
+     * @param track The track to get the lyrics for
+     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
+     * @returns The lyrics of the track
+     * @example
+     * ```ts
+     * const lyrics = await player.getLyrics(player.queue.tracks[0], true);
+     * ```
      */
-    "create": (node: LavalinkNode) => void;
+    getLyrics(track: Track, skipTrackSource?: boolean): Promise<LyricsResult>;
     /**
-     * Emitted when a Node is destroyed.
-     * @event Manager.nodeManager#destroy
+     * Subscribe to the lyrics event on a specific guild to active live lyrics events
+     * @returns The unsubscribe function
+     * @example
+     * ```ts
+     * const lyrics = await player.subscribeLyrics();
+     * ```
      */
-    "destroy": (node: LavalinkNode, destroyReason?: DestroyReasonsType) => void;
+    subscribeLyrics(): Promise<unknown>;
     /**
-     * Emitted when a Node is connected.
-     * @event Manager.nodeManager#connect
+     * Unsubscribe from the lyrics event on a specific guild to disable live lyrics events
+     * @returns The unsubscribe function
+     * @example
+     * ```ts
+     * const lyrics = await player.unsubscribeLyrics();
+     * ```
      */
-    "connect": (node: LavalinkNode) => void;
-    /**
-     * Emitted when a Node is reconnecting.
-     * @event Manager.nodeManager#reconnecting
-    */
-    "reconnecting": (node: LavalinkNode) => void;
+    unsubscribeLyrics(): Promise<void>;
     /**
-     * Emitted When a node starts to reconnect (if you have a reconnection delay, the reconnecting event will be emitted after the retryDelay.)
-     * Useful to check wether the internal node reconnect system works or not
-     * @event Manager.nodeManager#reconnectinprogress
+     * Move the player on a different Audio-Node
+     * @param newNode New Node / New Node Id
+     * @param checkSources If it should check if the sources are supported by the new node @default true
+     * @return The new Node Id
+     * @example
+     * ```ts
+     * const changeNode = await player.changeNode(newNode, true);
+     * ```
      */
-    "reconnectinprogress": (node: LavalinkNode) => void;
-    /**
-     * Emitted when a Node is disconnects.
-     * @event Manager.nodeManager#disconnect
-    */
-    "disconnect": (node: LavalinkNode, reason: {
-        code?: number;
-        reason?: string;
-    }) => void;
-    /**
-     * Emitted when a Node is error.
-     * @event Manager.nodeManager#error
-    */
-    "error": (node: LavalinkNode, error: Error, payload?: unknown) => void;
-    /**
-     * Emits every single Node event.
-     * @event Manager.nodeManager#raw
-    */
-    "raw": (node: LavalinkNode, payload: unknown) => void;
+    changeNode(newNode: LavalinkNode | string, checkSources?: boolean): Promise<string>;
     /**
-     * Emits when the node connects resumed. You then need to create all players within this event for your usecase.
-     * Aka for that you need to be able to save player data like vc channel + text channel in a db and then sync it again
-     * @event Manager.nodeManager#nodeResumed
+     * Move the player to a different node. If no node is provided, it will find the least used node that is not the same as the current node.
+     * @param node the id of the node to move to
+     * @returns the player
+     * @throws RangeError if there is no available nodes.
+     * @throws Error if the node to move to is the same as the current node.
      */
-    "resumed": (node: LavalinkNode, payload: {
-        resumed: true;
-        sessionId: string;
-        op: "ready";
-    }, players: LavalinkPlayer[] | InvalidLavalinkRestRequest) => void;
+    moveNode(node?: string): Promise<string | this>;
+    /** Converts the Player including Queue to a Json state */
+    toJSON(): PlayerJson;
 }
 
 declare const TrackSymbol: unique symbol;
@@ -1711,464 +1076,1107 @@ declare class ManagerUtils {
         types: string[];
         source: any;
     };
-    validateSourceString(node: LavalinkNode, sourceString: SearchPlatform): void;
+    validateSourceString(node: LavalinkNode, sourceString: SearchPlatform): void;
+}
+/**
+ * Separate interface for the constructor so that emitted js does not have a constructor that overwrites itself
+ *
+ * @internal
+ */
+interface MiniMap<K, V> extends Map<K, V> {
+    constructor: MiniMapConstructor;
+}
+declare class MiniMap<K, V> extends Map<K, V> {
+    constructor(data?: [K, V][]);
+    /**
+     * Identical to
+     * [Array.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),
+     * but returns a MiniMap instead of an Array.
+     *
+     * @param fn The function to test with (should return boolean)
+     * @param thisArg Value to use as `this` when executing function
+     *
+     * @example
+     * miniMap.filter(user => user.username === 'Bob');
+     */
+    filter<K2 extends K>(fn: (value: V, key: K, miniMap: this) => key is K2): MiniMap<K2, V>;
+    filter<V2 extends V>(fn: (value: V, key: K, miniMap: this) => value is V2): MiniMap<K, V2>;
+    filter(fn: (value: V, key: K, miniMap: this) => boolean): MiniMap<K, V>;
+    filter<This, K2 extends K>(fn: (this: This, value: V, key: K, miniMap: this) => key is K2, thisArg: This): MiniMap<K2, V>;
+    filter<This, V2 extends V>(fn: (this: This, value: V, key: K, miniMap: this) => value is V2, thisArg: This): MiniMap<K, V2>;
+    filter<This>(fn: (this: This, value: V, key: K, miniMap: this) => boolean, thisArg: This): MiniMap<K, V>;
+    toJSON(): [K, V][];
+    /**
+     * Maps each item to another value into an array. Identical in behavior to
+     * [Array.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).
+     *
+     * @param fn Function that produces an element of the new array, taking three arguments
+     * @param thisArg Value to use as `this` when executing function
+     *
+     * @example
+     * miniMap.map(user => user.tag);
+     */
+    map<T>(fn: (value: V, key: K, miniMap: this) => T): T[];
+    map<This, T>(fn: (this: This, value: V, key: K, miniMap: this) => T, thisArg: This): T[];
+}
+declare function queueTrackEnd(player: Player, dontShiftQueue?: boolean): Promise<Track>;
+declare function safeStringify(obj: any, padding?: number): string;
+
+/** Helper for generating Opaque types. */
+type Opaque<T, K> = T & {
+    __opaque__: K;
+};
+/** Opqaue tyep for integernumber */
+type IntegerNumber = Opaque<number, 'Int'>;
+/** Opqaue tyep for floatnumber */
+type FloatNumber = Opaque<number, 'Float'>;
+type LavaSrcSearchPlatformBase = "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "dzrec" | "ymsearch" | "ymrec" | "vksearch" | "vkrec" | "tdsearch" | "tdrec" | "qbsearch" | "qbisrc" | "qbrec" | "pdsearch" | "pdisrc" | "pdrec";
+type LavaSrcSearchPlatform = LavaSrcSearchPlatformBase | "ftts";
+type JioSaavnSearchPlatform = "jssearch" | "jsrec";
+type DuncteSearchPlatform = "speak" | "phsearch" | "pornhub" | "porn" | "tts";
+type LavalinkClientSearchPlatform = "bcsearch";
+type LavalinkClientSearchPlatformResolve = "bandcamp" | "bc";
+type LavalinkSearchPlatform = "ytsearch" | "ytmsearch" | "scsearch" | "bcsearch" | LavaSrcSearchPlatform | DuncteSearchPlatform | JioSaavnSearchPlatform | LavalinkClientSearchPlatform;
+type ClientCustomSearchPlatformUtils = "local" | "http" | "https" | "link" | "uri";
+type ClientSearchPlatform = ClientCustomSearchPlatformUtils | // for file/link requests
+"youtube" | "yt" | "youtube music" | "youtubemusic" | "ytm" | "musicyoutube" | "music youtube" | "soundcloud" | "sc" | "am" | "apple music" | "applemusic" | "apple" | "musicapple" | "music apple" | "sp" | "spsuggestion" | "spotify" | "spotify.com" | "spotifycom" | "dz" | "deezer" | "yandex" | "yandex music" | "yandexmusic" | "vk" | "vk music" | "vkmusic" | "tidal" | "tidal music" | "qobuz" | "pandora" | "pd" | "pandora music" | "pandoramusic" | "flowerytts" | "flowery" | "flowery.tts" | LavalinkClientSearchPlatformResolve | LavalinkClientSearchPlatform | "js" | "jiosaavn" | "td" | "tidal" | "tdrec";
+type SearchPlatform = LavalinkSearchPlatform | ClientSearchPlatform;
+type SourcesRegex = "YoutubeRegex" | "YoutubeMusicRegex" | "SoundCloudRegex" | "SoundCloudMobileRegex" | "DeezerTrackRegex" | "DeezerArtistRegex" | "DeezerEpisodeRegex" | "DeezerMixesRegex" | "DeezerPageLinkRegex" | "DeezerPlaylistRegex" | "DeezerAlbumRegex" | "AllDeezerRegex" | "AllDeezerRegexWithoutPageLink" | "SpotifySongRegex" | "SpotifyPlaylistRegex" | "SpotifyArtistRegex" | "SpotifyEpisodeRegex" | "SpotifyShowRegex" | "SpotifyAlbumRegex" | "AllSpotifyRegex" | "mp3Url" | "m3uUrl" | "m3u8Url" | "mp4Url" | "m4aUrl" | "wavUrl" | "aacpUrl" | "tiktok" | "mixcloud" | "musicYandex" | "radiohost" | "bandcamp" | "jiosaavn" | "appleMusic" | "tidal" | "PandoraTrackRegex" | "PandoraAlbumRegex" | "PandoraArtistRegex" | "PandoraPlaylistRegex" | "AllPandoraRegex" | "TwitchTv" | "vimeo";
+interface PlaylistInfo {
+    /** The playlist name */
+    name: string;
+    /** The playlist title (same as name) */
+    title: string;
+    /** The playlist Author */
+    author?: string;
+    /** The playlist Thumbnail */
+    thumbnail?: string;
+    /** A Uri to the playlist */
+    uri?: string;
+    /** The playlist selected track. */
+    selectedTrack: Track | null;
+    /** The duration of the entire playlist. (calcualted) */
+    duration: number;
+}
+interface SearchResult {
+    loadType: LoadTypes;
+    exception: Exception | null;
+    pluginInfo: PluginInfo;
+    playlist: PlaylistInfo | null;
+    tracks: Track[];
+}
+interface UnresolvedSearchResult {
+    loadType: LoadTypes;
+    exception: Exception | null;
+    pluginInfo: PluginInfo;
+    playlist: PlaylistInfo | null;
+    tracks: UnresolvedTrack[];
+}
+/**
+ * @internal
+ */
+interface MiniMapConstructor {
+    new (): MiniMap<unknown, unknown>;
+    new <K, V>(entries?: ReadonlyArray<readonly [K, V]> | null): MiniMap<K, V>;
+    new <K, V>(iterable: Iterable<readonly [K, V]>): MiniMap<K, V>;
+    readonly prototype: MiniMap<unknown, unknown>;
+    readonly [Symbol.species]: MiniMapConstructor;
+}
+type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents | LyricsEvent;
+type Severity = "COMMON" | "SUSPICIOUS" | "FAULT";
+interface Exception {
+    /** Severity of the error */
+    severity: Severity;
+    /** Nodejs Error */
+    error?: Error;
+    /** Message by lavalink */
+    message: string;
+    /** Cause by lavalink */
+    cause: string;
+    /** causeStackTrace by lavalink */
+    causeStackTrace: string;
+}
+interface PlayerEvent {
+    op: "event";
+    type: PlayerEventType;
+    guildId: string;
+}
+interface TrackStartEvent extends PlayerEvent {
+    type: "TrackStartEvent";
+    track: LavalinkTrack;
+}
+interface TrackEndEvent extends PlayerEvent {
+    type: "TrackEndEvent";
+    track: LavalinkTrack;
+    reason: TrackEndReason;
+}
+interface TrackExceptionEvent extends PlayerEvent {
+    type: "TrackExceptionEvent";
+    exception?: Exception;
+    track: LavalinkTrack;
+    error: string;
+}
+interface TrackStuckEvent extends PlayerEvent {
+    type: "TrackStuckEvent";
+    thresholdMs: number;
+    track: LavalinkTrack;
+}
+interface WebSocketClosedEvent extends PlayerEvent {
+    type: "WebSocketClosedEvent";
+    code: number;
+    byRemote: boolean;
+    reason: string;
+}
+/**
+ * Types & Events for Sponsorblock-plugin from Lavalink: https://github.com/topi314/Sponsorblock-Plugin#segmentsloaded
+ */
+type SponsorBlockSegmentEvents = SponsorBlockSegmentSkipped | SponsorBlockSegmentsLoaded | SponsorBlockChapterStarted | SponsorBlockChaptersLoaded;
+type SponsorBlockSegmentEventType = "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted";
+interface SponsorBlockSegmentsLoaded extends PlayerEvent {
+    type: "SegmentsLoaded";
+    segments: {
+        category: string;
+        start: number;
+        end: number;
+    }[];
+}
+interface SponsorBlockSegmentSkipped extends PlayerEvent {
+    type: "SegmentSkipped";
+    segment: {
+        category: string;
+        start: number;
+        end: number;
+    };
+}
+interface SponsorBlockChapterStarted extends PlayerEvent {
+    type: "ChapterStarted";
+    /** The Chapter which started */
+    chapter: {
+        /** The Name of the Chapter */
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    };
+}
+interface SponsorBlockChaptersLoaded extends PlayerEvent {
+    type: "ChaptersLoaded";
+    /** All Chapters loaded */
+    chapters: {
+        /** The Name of the Chapter */
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    }[];
 }
 /**
- * Separate interface for the constructor so that emitted js does not have a constructor that overwrites itself
- *
- * @internal
+ * Types & Events for Lyrics plugin from Lavalink: https://github.com/topi314/LavaLyrics
  */
-interface MiniMap<K, V> extends Map<K, V> {
-    constructor: MiniMapConstructor;
+type LyricsEvent = LyricsFoundEvent | LyricsNotFoundEvent | LyricsLineEvent;
+type LyricsEventType = "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
+interface LyricsFoundEvent extends PlayerEvent {
+    /** The lyricsfound event */
+    type: "LyricsFoundEvent";
+    /** The guildId */
+    guildId: string;
+    /** The lyrics */
+    lyrics: LyricsResult;
 }
-declare class MiniMap<K, V> extends Map<K, V> {
-    constructor(data?: [K, V][]);
-    /**
-     * Identical to
-     * [Array.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),
-     * but returns a MiniMap instead of an Array.
-     *
-     * @param fn The function to test with (should return boolean)
-     * @param thisArg Value to use as `this` when executing function
-     *
-     * @example
-     * miniMap.filter(user => user.username === 'Bob');
-     */
-    filter<K2 extends K>(fn: (value: V, key: K, miniMap: this) => key is K2): MiniMap<K2, V>;
-    filter<V2 extends V>(fn: (value: V, key: K, miniMap: this) => value is V2): MiniMap<K, V2>;
-    filter(fn: (value: V, key: K, miniMap: this) => boolean): MiniMap<K, V>;
-    filter<This, K2 extends K>(fn: (this: This, value: V, key: K, miniMap: this) => key is K2, thisArg: This): MiniMap<K2, V>;
-    filter<This, V2 extends V>(fn: (this: This, value: V, key: K, miniMap: this) => value is V2, thisArg: This): MiniMap<K, V2>;
-    filter<This>(fn: (this: This, value: V, key: K, miniMap: this) => boolean, thisArg: This): MiniMap<K, V>;
-    toJSON(): [K, V][];
-    /**
-     * Maps each item to another value into an array. Identical in behavior to
-     * [Array.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).
-     *
-     * @param fn Function that produces an element of the new array, taking three arguments
-     * @param thisArg Value to use as `this` when executing function
-     *
-     * @example
-     * miniMap.map(user => user.tag);
-     */
-    map<T>(fn: (value: V, key: K, miniMap: this) => T): T[];
-    map<This, T>(fn: (this: This, value: V, key: K, miniMap: this) => T, thisArg: This): T[];
+interface LyricsNotFoundEvent extends PlayerEvent {
+    /**The lyricsnotfound event*/
+    type: "LyricsNotFoundEvent";
+    /**The guildId*/
+    guildId: string;
 }
-declare function queueTrackEnd(player: Player, dontShiftQueue?: boolean): Promise<Track>;
-declare function safeStringify(obj: any, padding?: number): string;
-
-/** Helper for generating Opaque types. */
-type Opaque<T, K> = T & {
-    __opaque__: K;
-};
-/** Opqaue tyep for integernumber */
-type IntegerNumber = Opaque<number, 'Int'>;
-/** Opqaue tyep for floatnumber */
-type FloatNumber = Opaque<number, 'Float'>;
-type LavaSrcSearchPlatformBase = "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "dzrec" | "ymsearch" | "ymrec" | "vksearch" | "vkrec" | "tdsearch" | "tdrec" | "qbsearch" | "qbisrc" | "qbrec" | "pdsearch" | "pdisrc" | "pdrec";
-type LavaSrcSearchPlatform = LavaSrcSearchPlatformBase | "ftts";
-type JioSaavnSearchPlatform = "jssearch" | "jsrec";
-type DuncteSearchPlatform = "speak" | "phsearch" | "pornhub" | "porn" | "tts";
-type LavalinkClientSearchPlatform = "bcsearch";
-type LavalinkClientSearchPlatformResolve = "bandcamp" | "bc";
-type LavalinkSearchPlatform = "ytsearch" | "ytmsearch" | "scsearch" | "bcsearch" | LavaSrcSearchPlatform | DuncteSearchPlatform | JioSaavnSearchPlatform | LavalinkClientSearchPlatform;
-type ClientCustomSearchPlatformUtils = "local" | "http" | "https" | "link" | "uri";
-type ClientSearchPlatform = ClientCustomSearchPlatformUtils | // for file/link requests
-"youtube" | "yt" | "youtube music" | "youtubemusic" | "ytm" | "musicyoutube" | "music youtube" | "soundcloud" | "sc" | "am" | "apple music" | "applemusic" | "apple" | "musicapple" | "music apple" | "sp" | "spsuggestion" | "spotify" | "spotify.com" | "spotifycom" | "dz" | "deezer" | "yandex" | "yandex music" | "yandexmusic" | "vk" | "vk music" | "vkmusic" | "tidal" | "tidal music" | "qobuz" | "pandora" | "pd" | "pandora music" | "pandoramusic" | "flowerytts" | "flowery" | "flowery.tts" | LavalinkClientSearchPlatformResolve | LavalinkClientSearchPlatform | "js" | "jiosaavn" | "td" | "tidal" | "tdrec";
-type SearchPlatform = LavalinkSearchPlatform | ClientSearchPlatform;
-type SourcesRegex = "YoutubeRegex" | "YoutubeMusicRegex" | "SoundCloudRegex" | "SoundCloudMobileRegex" | "DeezerTrackRegex" | "DeezerArtistRegex" | "DeezerEpisodeRegex" | "DeezerMixesRegex" | "DeezerPageLinkRegex" | "DeezerPlaylistRegex" | "DeezerAlbumRegex" | "AllDeezerRegex" | "AllDeezerRegexWithoutPageLink" | "SpotifySongRegex" | "SpotifyPlaylistRegex" | "SpotifyArtistRegex" | "SpotifyEpisodeRegex" | "SpotifyShowRegex" | "SpotifyAlbumRegex" | "AllSpotifyRegex" | "mp3Url" | "m3uUrl" | "m3u8Url" | "mp4Url" | "m4aUrl" | "wavUrl" | "aacpUrl" | "tiktok" | "mixcloud" | "musicYandex" | "radiohost" | "bandcamp" | "jiosaavn" | "appleMusic" | "tidal" | "PandoraTrackRegex" | "PandoraAlbumRegex" | "PandoraArtistRegex" | "PandoraPlaylistRegex" | "AllPandoraRegex" | "TwitchTv" | "vimeo";
-interface PlaylistInfo {
-    /** The playlist name */
-    name: string;
-    /** The playlist title (same as name) */
-    title: string;
-    /** The playlist Author */
-    author?: string;
-    /** The playlist Thumbnail */
-    thumbnail?: string;
-    /** A Uri to the playlist */
-    uri?: string;
-    /** The playlist selected track. */
-    selectedTrack: Track | null;
-    /** The duration of the entire playlist. (calcualted) */
-    duration: number;
+interface LyricsLineEvent extends PlayerEvent {
+    /**The lyricsline event*/
+    type: "LyricsLineEvent";
+    /** The guildId */
+    guildId: string;
+    /** The line number */
+    lineIndex: number;
+    /** The line */
+    line: LyricsLine;
+    /**skipped is true if the line was skipped */
+    skipped: boolean;
+}
+type LoadTypes = "track" | "playlist" | "search" | "error" | "empty";
+type State = "CONNECTED" | "CONNECTING" | "DISCONNECTED" | "DISCONNECTING" | "DESTROYING";
+type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | SponsorBlockSegmentEventType | LyricsEventType;
+type TrackEndReason = "finished" | "loadFailed" | "stopped" | "replaced" | "cleanup";
+interface InvalidLavalinkRestRequest {
+    /** Rest Request Data for when it was made */
+    timestamp: number;
+    /** Status of the request */
+    status: number;
+    /** Specific Errro which was sent */
+    error: string;
+    /** Specific Message which was created */
+    message?: string;
+    /** The specific error trace from the request */
+    trace?: unknown;
+    /** Path of where it's from */
+    path: string;
+}
+interface LavalinkPlayerVoice {
+    /** The Voice Token */
+    token: string;
+    /** The Voice Server Endpoint  */
+    endpoint: string;
+    /** The Voice SessionId */
+    sessionId: string;
+    /** Wether or not the player is connected */
+    connected?: boolean;
+    /** The Ping to the voice server */
+    ping?: number;
+}
+type LavalinkPlayerVoiceOptions = Omit<LavalinkPlayerVoice, 'connected' | 'ping'>;
+interface FailingAddress {
+    /** The failing address */
+    failingAddress: string;
+    /** The timestamp when the address failed */
+    failingTimestamp: number;
+    /** The timestamp when the address failed as a pretty string */
+    failingTime: string;
+}
+type RoutePlannerTypes = "RotatingIpRoutePlanner" | "NanoIpRoutePlanner" | "RotatingNanoIpRoutePlanner" | "BalancingIpRoutePlanner";
+interface RoutePlanner {
+    class?: RoutePlannerTypes;
+    details?: {
+        /** The ip block being used */
+        ipBlock: {
+            /** The type of the ip block */
+            type: "Inet4Address" | "Inet6Address";
+            /** 	The size of the ip block */
+            size: string;
+        };
+        /** The failing addresses */
+        failingAddresses: FailingAddress[];
+        /** The number of rotations */
+        rotateIndex?: string;
+        /** The current offset in the block	 */
+        ipIndex?: string;
+        /** The current address being used	 */
+        currentAddress?: string;
+        /** The current offset in the ip block */
+        currentAddressIndex?: string;
+        /** The information in which /64 block ips are chosen. This number increases on each ban. */
+        blockIndex?: string;
+    };
+}
+interface Session {
+    /** Wether or not session is resuming or not */
+    resuming: boolean;
+    /** For how long a session is lasting while not connected */
+    timeout: number;
+}
+interface GuildShardPayload {
+    /** The OP code */
+    op: number;
+    /** Data to send  */
+    d: {
+        /** Guild id to apply voice settings */
+        guild_id: string;
+        /** channel to move/connect to, or null to leave it */
+        channel_id: string | null;
+        /** wether or not mute yourself */
+        self_mute: boolean;
+        /** wether or not deafen yourself */
+        self_deaf: boolean;
+    };
+}
+interface PlayerUpdateInfo {
+    /** guild id of the player */
+    guildId: string;
+    /** Player options to provide to lavalink */
+    playerOptions: LavalinkPlayOptions;
+    /** Whether or not replace the current track with the new one (true is recommended) */
+    noReplace?: boolean;
+}
+interface LavalinkPlayer {
+    /** Guild Id of the player */
+    guildId: string;
+    /** IF playing a track, all of the track information */
+    track?: LavalinkTrack;
+    /** Lavalink volume (mind volumedecrementer) */
+    volume: number;
+    /** Wether it's paused or not */
+    paused: boolean;
+    /** Voice Endpoint data */
+    voice: LavalinkPlayerVoice;
+    /** All Audio Filters */
+    filters: Partial<LavalinkFilterData>;
+    /** Lavalink-Voice-State Variables */
+    state: {
+        /** Time since connection established */
+        time: number;
+        /** Position of the track */
+        position: number;
+        /** COnnected or not */
+        connected: boolean;
+        /** Ping to voice server */
+        ping: number;
+    };
+}
+interface ChannelDeletePacket {
+    /** Packet key for channel delete */
+    t: "CHANNEL_DELETE";
+    /** data which is sent and relevant */
+    d: {
+        /** guild id */
+        guild_id: string;
+        /** Channel id */
+        id: string;
+    };
+}
+interface VoiceState {
+    /** OP key from lavalink */
+    op: "voiceUpdate";
+    /** GuildId provided by lavalink */
+    guildId: string;
+    /** Event data */
+    event: VoiceServer;
+    /** Session Id of the voice connection */
+    sessionId?: string;
+    /** guild id of the voice channel */
+    guild_id: string;
+    /** user id from the voice connection */
+    user_id: string;
+    /** Session Id of the voice connection */
+    session_id: string;
+    /** Voice Channel Id */
+    channel_id: string;
+    /** Server Mute status */
+    mute: boolean;
+    /** Server Deaf status */
+    deaf: boolean;
+    /** Self Deaf status */
+    self_deaf: boolean;
+    /** Self Mute status */
+    self_mute: boolean;
+    /** Self Video (Camera) status */
+    self_video: boolean;
+    /** Self Stream status */
+    self_stream: boolean;
+    /** Wether the user requests to speak (stage channel) */
+    request_to_speak_timestamp: boolean;
+    /** Self suppressed status (stage channel) */
+    suppress: boolean;
 }
-interface SearchResult {
-    loadType: LoadTypes;
-    exception: Exception | null;
+/** The Base64 decodes tring by lavalink */
+type Base64 = string;
+interface VoiceServer {
+    /** Voice Token */
+    token: string;
+    /** Guild Id of the voice server connection */
+    guild_id: string;
+    /** Server Endpoint */
+    endpoint: string;
+}
+interface VoicePacket {
+    /** Voice Packet Keys to send */
+    t?: "VOICE_SERVER_UPDATE" | "VOICE_STATE_UPDATE";
+    /** Voice Packets to send */
+    d: VoiceState | VoiceServer;
+}
+interface NodeMessage extends NodeStats {
+    /** The type of the event */
+    type: PlayerEventType;
+    /** what ops are applying to that event */
+    op: "stats" | "playerUpdate" | "event";
+    /** The specific guild id for that message */
+    guildId: string;
+}
+/** Specific types to filter for lavasearch, will be filtered to correct types */
+type LavaSearchType = "track" | "album" | "artist" | "playlist" | "text" | "tracks" | "albums" | "artists" | "playlists" | "texts";
+interface LavaSearchFilteredResponse {
+    /** The Information of a playlist provided by lavasearch */
+    info: PlaylistInfo;
+    /** additional plugin information */
     pluginInfo: PluginInfo;
-    playlist: PlaylistInfo | null;
+    /** List of tracks  */
     tracks: Track[];
 }
-interface UnresolvedSearchResult {
-    loadType: LoadTypes;
-    exception: Exception | null;
+interface LavaSearchResponse {
+    /** An array of tracks, only present if track is in types */
+    tracks: Track[];
+    /** An array of albums, only present if album is in types */
+    albums: LavaSearchFilteredResponse[];
+    /** 	An array of artists, only present if artist is in types */
+    artists: LavaSearchFilteredResponse[];
+    /** 	An array of playlists, only present if playlist is in types */
+    playlists: LavaSearchFilteredResponse[];
+    /** An array of text results, only present if text is in types */
+    texts: {
+        text: string;
+        pluginInfo: PluginInfo;
+    }[];
+    /** Addition result data provided by plugins */
     pluginInfo: PluginInfo;
-    playlist: PlaylistInfo | null;
-    tracks: UnresolvedTrack[];
+}
+/** SearchQuery Object for raw lavalink requests */
+type SearchQuery = {
+    /** lavalink search Query / identifier string */
+    query: string;
+    /** Extra url query params to use, e.g. for flowertts */
+    extraQueryUrlParams?: URLSearchParams;
+    /** Source to append to the search query string */
+    source?: SearchPlatform;
+} | /** Our just the search query / identifier string */ string;
+/** SearchQuery Object for Lavalink LavaSearch Plugin requests */
+type LavaSearchQuery = {
+    /** lavalink search Query / identifier string */
+    query: string;
+    /** Source to append to the search query string */
+    source: LavaSrcSearchPlatformBase;
+    /** The Types to filter the search to */
+    types?: LavaSearchType[];
+};
+type Awaitable<T> = Promise<T> | T;
+
+/** The Audio Outputs type */
+type AudioOutputs = "mono" | "stereo" | "left" | "right";
+/** The "active" / "disabled" Player Filters */
+interface PlayerFilters {
+    /** Sets nightcore to false, and vaporwave to false */
+    custom: boolean;
+    /** Sets custom to false, and vaporwave to false */
+    nightcore: boolean;
+    /** Sets custom to false, and nightcore to false */
+    vaporwave: boolean;
+    /** If rotation filter is enabled / not */
+    rotation: boolean;
+    /** if karaoke filter is enabled / not */
+    karaoke: boolean;
+    /** if tremolo filter is enabled / not */
+    tremolo: boolean;
+    /** if vibrato filter is enabled / not */
+    vibrato: boolean;
+    lowPass: boolean;
+    /** audio Output (default stereo, mono sounds the fullest and best for not-stereo tracks) */
+    audioOutput: AudioOutputs;
+    /** Lavalink Volume FILTER (not player Volume, think of it as a gain booster) */
+    volume: boolean;
+    /** Filters for the Lavalink Filter Plugin */
+    lavalinkFilterPlugin: {
+        /** if echo filter is enabled / not */
+        echo: boolean;
+        /** if reverb filter is enabled / not */
+        reverb: boolean;
+    };
+    lavalinkLavaDspxPlugin: {
+        /** if lowPass filter is enabled / not */
+        lowPass: boolean;
+        /** if highPass filter is enabled / not */
+        highPass: boolean;
+        /** if normalization filter is enabled / not */
+        normalization: boolean;
+        /** if echo filter is enabled / not */
+        echo: boolean;
+    };
 }
 /**
- * @internal
+ * There are 15 bands (0-14) that can be changed.
+ * "gain" is the multiplier for the given band.
+ * The default value is 0.
+ *  Valid values range from -0.25 to 1.0, where -0.25 means the given band is completely muted, and 0.25 means it is doubled.
+ * Modifying the gain could also change the volume of the output.
  */
-interface MiniMapConstructor {
-    new (): MiniMap<unknown, unknown>;
-    new <K, V>(entries?: ReadonlyArray<readonly [K, V]> | null): MiniMap<K, V>;
-    new <K, V>(iterable: Iterable<readonly [K, V]>): MiniMap<K, V>;
-    readonly prototype: MiniMap<unknown, unknown>;
-    readonly [Symbol.species]: MiniMapConstructor;
+interface EQBand {
+    /** On what band position (0-14) it should work */
+    band: IntegerNumber | number;
+    /** The gain (-0.25 to 1.0) */
+    gain: FloatNumber | number;
 }
-type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents | LyricsEvent;
-type Severity = "COMMON" | "SUSPICIOUS" | "FAULT";
-interface Exception {
-    /** Severity of the error */
-    severity: Severity;
-    /** Nodejs Error */
-    error?: Error;
-    /** Message by lavalink */
-    message: string;
-    /** Cause by lavalink */
-    cause: string;
-    /** causeStackTrace by lavalink */
-    causeStackTrace: string;
+/**
+ * Uses equalization to eliminate part of a band, usually targeting vocals.
+ */
+interface KaraokeFilter {
+    /** The level (0 to 1.0 where 0.0 is no effect and 1.0 is full effect) */
+    level?: number;
+    /** The mono level (0 to 1.0 where 0.0 is no effect and 1.0 is full effect) */
+    monoLevel?: number;
+    /** The filter band (in Hz) */
+    filterBand?: number;
+    /**	The filter width */
+    filterWidth?: number;
 }
-interface PlayerEvent {
-    op: "event";
-    type: PlayerEventType;
-    guildId: string;
+/**
+ * Changes the speed, pitch, and rate
+ */
+interface TimescaleFilter {
+    /** The playback speed 0.0 ≤ x */
+    speed?: number;
+    /** The pitch 0.0 ≤ x */
+    pitch?: number;
+    /** The rate 0.0 ≤ x */
+    rate?: number;
 }
-interface TrackStartEvent extends PlayerEvent {
-    type: "TrackStartEvent";
-    track: LavalinkTrack;
+/**
+ * Uses amplification to create a shuddering effect, where the volume quickly oscillates.
+ * Demo: https://en.wikipedia.org/wiki/File:Fuse_Electronics_Tremolo_MK-III_Quick_Demo.ogv
+ */
+interface TremoloFilter {
+    /** The frequency 0.0 < x */
+    frequency?: number;
+    /** The tremolo depth 0.0 < x ≤ 1.0 */
+    depth?: number;
 }
-interface TrackEndEvent extends PlayerEvent {
-    type: "TrackEndEvent";
-    track: LavalinkTrack;
-    reason: TrackEndReason;
+/**
+ * Similar to tremolo. While tremolo oscillates the volume, vibrato oscillates the pitch.
+ */
+interface VibratoFilter {
+    /** The frequency 0.0 < x ≤ 14.0 */
+    frequency?: number;
+    /** The vibrato depth 0.0 < x ≤ 1.0 */
+    depth?: number;
 }
-interface TrackExceptionEvent extends PlayerEvent {
-    type: "TrackExceptionEvent";
-    exception?: Exception;
-    track: LavalinkTrack;
-    error: string;
+/**
+ * Rotates the sound around the stereo channels/user headphones (aka Audio Panning).
+ * It can produce an effect similar to https://youtu.be/QB9EB8mTKcc (without the reverb).
+ */
+interface RotationFilter {
+    /** The frequency of the audio rotating around the listener in Hz. 0.2 is similar to the example video above */
+    rotationHz?: number;
 }
-interface TrackStuckEvent extends PlayerEvent {
-    type: "TrackStuckEvent";
-    thresholdMs: number;
-    track: LavalinkTrack;
+/**
+ * Distortion effect. It can generate some pretty unique audio effects.
+ */
+interface DistortionFilter {
+    sinOffset?: number;
+    sinScale?: number;
+    cosOffset?: number;
+    cosScale?: number;
+    tanOffset?: number;
+    tanScale?: number;
+    offset?: number;
+    scale?: number;
 }
-interface WebSocketClosedEvent extends PlayerEvent {
-    type: "WebSocketClosedEvent";
-    code: number;
-    byRemote: boolean;
-    reason: string;
+/**
+ * Mixes both channels (left and right), with a configurable factor on how much each channel affects the other.
+ * With the defaults, both channels are kept independent of each other.
+ * Setting all factors to 0.5 means both channels get the same audio.
+ */
+interface ChannelMixFilter {
+    /** The left to left channel mix factor (0.0 ≤ x ≤ 1.0) */
+    leftToLeft?: number;
+    /** The left to right channel mix factor (0.0 ≤ x ≤ 1.0) */
+    leftToRight?: number;
+    /** The right to left channel mix factor (0.0 ≤ x ≤ 1.0) */
+    rightToLeft?: number;
+    /** The right to right channel mix factor (0.0 ≤ x ≤ 1.0) */
+    rightToRight?: number;
 }
 /**
- * Types & Events for Sponsorblock-plugin from Lavalink: https://github.com/topi314/Sponsorblock-Plugin#segmentsloaded
+ * Higher frequencies get suppressed, while lower frequencies pass through this filter, thus the name low pass.
+ * Any smoothing values equal to or less than 1.0 will disable the filter.
  */
-type SponsorBlockSegmentEvents = SponsorBlockSegmentSkipped | SponsorBlockSegmentsLoaded | SponsorBlockChapterStarted | SponsorBlockChaptersLoaded;
-type SponsorBlockSegmentEventType = "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted";
-interface SponsorBlockSegmentsLoaded extends PlayerEvent {
-    type: "SegmentsLoaded";
-    segments: {
-        category: string;
-        start: number;
-        end: number;
-    }[];
+interface LowPassFilter {
+    /** The smoothing factor (1.0 < x) */
+    smoothing?: number;
 }
-interface SponsorBlockSegmentSkipped extends PlayerEvent {
-    type: "SegmentSkipped";
-    segment: {
-        category: string;
-        start: number;
-        end: number;
+/**
+ * Filter Data stored in the Client and partially sent to Lavalink
+ */
+interface FilterData {
+    volume?: number;
+    karaoke?: KaraokeFilter;
+    timescale?: TimescaleFilter;
+    tremolo?: TremoloFilter;
+    vibrato?: VibratoFilter;
+    rotation?: RotationFilter;
+    distortion?: DistortionFilter;
+    channelMix?: ChannelMixFilter;
+    lowPass?: LowPassFilter;
+    pluginFilters?: {
+        "lavalink-filter-plugin"?: {
+            "echo"?: {
+                delay?: number;
+                decay?: number;
+            };
+            "reverb"?: {
+                delays?: number[];
+                gains?: number[];
+            };
+        };
+        "high-pass"?: {
+            cutoffFrequency?: number;
+            boostFactor?: number;
+        };
+        "low-pass"?: {
+            cutoffFrequency?: number;
+            boostFactor?: number;
+        };
+        normalization?: {
+            maxAmplitude?: number;
+            adaptive?: boolean;
+        };
+        echo?: {
+            echoLength?: number;
+            decay?: number;
+        };
     };
 }
-interface SponsorBlockChapterStarted extends PlayerEvent {
-    type: "ChapterStarted";
-    /** The Chapter which started */
-    chapter: {
-        /** The Name of the Chapter */
-        name: string;
-        start: number;
-        end: number;
-        duration: number;
-    };
+/**
+ * Actual Filter Data sent to Lavalink
+ */
+interface LavalinkFilterData extends FilterData {
+    equalizer?: EQBand[];
 }
-interface SponsorBlockChaptersLoaded extends PlayerEvent {
-    type: "ChaptersLoaded";
-    /** All Chapters loaded */
-    chapters: {
-        /** The Name of the Chapter */
-        name: string;
-        start: number;
-        end: number;
-        duration: number;
-    }[];
+
+/**
+ * Debug events for more detailed logging
+ */
+declare enum DebugEvents {
+    SetSponsorBlock = "SetSponsorBlock",
+    DeleteSponsorBlock = "DeleteSponsorBlock",
+    TrackEndReplaced = "TrackEndReplaced",
+    AutoplayExecution = "AutoplayExecution",
+    AutoplayNoSongsAdded = "AutoplayNoSongsAdded",
+    AutoplayThresholdSpamLimiter = "AutoplayThresholdSpamLimiter",
+    TriggerQueueEmptyInterval = "TriggerQueueEmptyInterval",
+    QueueEnded = "QueueEnded",
+    TrackStartNewSongsOnly = "TrackStartNewSongsOnly",
+    TrackStartNoTrack = "TrackStartNoTrack",
+    ResumingFetchingError = "ResumingFetchingError",
+    PlayerUpdateNoPlayer = "PlayerUpdateNoPlayer",
+    PlayerUpdateFilterFixApply = "PlayerUpdateFilterFixApply",
+    PlayerUpdateSuccess = "PlayerUpdateSuccess",
+    HeartBeatTriggered = "HeartBeatTriggered",
+    NoSocketOnDestroy = "NoSocketOnDestroy",
+    SocketCleanupError = "SocketCleanupError",
+    SocketTerminateHeartBeatTimeout = "SocketTerminateHeartBeatTimeout",
+    TryingConnectWhileConnected = "TryingConnectWhileConnected",
+    LavaSearchNothingFound = "LavaSearchNothingFound",
+    SearchNothingFound = "SearchNothingFound",
+    ValidatingBlacklistLinks = "ValidatingBlacklistLinks",
+    ValidatingWhitelistLinks = "ValidatingWhitelistLinks",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime",
+    PlayerDestroyingSomewhereElse = "PlayerDestroyingSomewhereElse",
+    PlayerCreateNodeNotFound = "PlayerCreateNodeNotFound",
+    PlayerPlayQueueEmptyTimeoutClear = "PlayerPlayQueueEmptyTimeoutClear",
+    PlayerPlayWithTrackReplace = "PlayerPlayWithTrackReplace",
+    PlayerPlayUnresolvedTrack = "PlayerPlayUnresolvedTrack",
+    PlayerPlayUnresolvedTrackFailed = "PlayerPlayUnresolvedTrackFailed",
+    PlayerVolumeAsFilter = "PlayerVolumeAsFilter",
+    BandcampSearchLokalEngine = "BandcampSearchLokalEngine",
+    PlayerChangeNode = "PlayerChangeNode",
+    BuildTrackError = "BuildTrackError",
+    TransformRequesterFunctionFailed = "TransformRequesterFunctionFailed",
+    GetClosestTrackFailed = "GetClosestTrackFailed",
+    PlayerDeleteInsteadOfDestroy = "PlayerDeleteInsteadOfDestroy",
+    FailedToConnectToNodes = "FailedToConnectToNodes",
+    NoAudioDebug = "NoAudioDebug",
+    PlayerAutoReconnect = "PlayerAutoReconnect"
 }
 /**
- * Types & Events for Lyrics plugin from Lavalink: https://github.com/topi314/LavaLyrics
+ * Reasons why a player got destroyed
  */
-type LyricsEvent = LyricsFoundEvent | LyricsNotFoundEvent | LyricsLineEvent;
-type LyricsEventType = "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
-interface LyricsFoundEvent extends PlayerEvent {
-    /** The lyricsfound event */
-    type: "LyricsFoundEvent";
-    /** The guildId */
-    guildId: string;
-    /** The lyrics */
-    lyrics: LyricsResult;
+declare enum DestroyReasons {
+    QueueEmpty = "QueueEmpty",
+    NodeDestroy = "NodeDestroy",
+    NodeDeleted = "NodeDeleted",
+    LavalinkNoVoice = "LavalinkNoVoice",
+    NodeReconnectFail = "NodeReconnectFail",
+    Disconnected = "Disconnected",
+    PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
+    ChannelDeleted = "ChannelDeleted",
+    DisconnectAllNodes = "DisconnectAllNodes",
+    ReconnectAllNodes = "ReconnectAllNodes",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime"
 }
-interface LyricsNotFoundEvent extends PlayerEvent {
-    /**The lyricsnotfound event*/
-    type: "LyricsNotFoundEvent";
-    /**The guildId*/
-    guildId: string;
+/**
+ *  Reasons why a player got disconnected
+ */
+declare enum DisconnectReasons {
+    Disconnected = "Disconnected",
+    DisconnectAllNodes = "DisconnectAllNodes"
 }
-interface LyricsLineEvent extends PlayerEvent {
-    /**The lyricsline event*/
-    type: "LyricsLineEvent";
-    /** The guildId */
+/** The valid SponsorBlock categories */
+declare const validSponsorBlocks: string[];
+/**  The audio Outputs Data map declaration */
+declare const audioOutputsData: Record<AudioOutputs, ChannelMixFilter>;
+/**  Equalizer Presets */
+declare const EQList: {
+    /** A Bassboost Equalizer, so high it distorts the audio */
+    BassboostEarrape: EQBand[];
+    /** A High and decent Bassboost Equalizer */
+    BassboostHigh: EQBand[];
+    /** A decent Bassboost Equalizer */
+    BassboostMedium: EQBand[];
+    /** A slight Bassboost Equalizer */
+    BassboostLow: EQBand[];
+    /** Makes the Music slightly "better" */
+    BetterMusic: EQBand[];
+    /** Makes the Music sound like rock music / sound rock music better */
+    Rock: EQBand[];
+    /** Makes the Music sound like Classic music / sound Classic music better */
+    Classic: EQBand[];
+    /** Makes the Music sound like Pop music / sound Pop music better */
+    Pop: EQBand[];
+    /** Makes the Music sound like Electronic music / sound Electronic music better */
+    Electronic: EQBand[];
+    /** Boosts all Bands slightly for louder and fuller sound */
+    FullSound: EQBand[];
+    /** Boosts basses + lower highs for a pro gaming sound */
+    Gaming: EQBand[];
+};
+
+type DestroyReasonsType = keyof typeof DestroyReasons | string;
+type DisconnectReasonsType = keyof typeof DisconnectReasons | string;
+interface PlayerJson {
+    /** Guild Id where the player was playing in */
+    guildId: string;
+    /** Options provided to the player */
+    options: PlayerOptions;
+    /** Voice Channel Id the player was playing in */
+    voiceChannelId: string;
+    /** Text Channel Id the player was synced to */
+    textChannelId?: string;
+    /** Position the player was at */
+    position: number;
+    /** Lavalink's position the player was at */
+    lastPosition: number;
+    /** Last time the position was sent from lavalink */
+    lastPositionChange: number | null;
+    /** Volume in % from the player (without volumeDecrementer) */
+    volume: number;
+    /** Real Volume used in lavalink (with the volumeDecrementer) */
+    lavalinkVolume: number;
+    /** The repeatmode from the player */
+    repeatMode: RepeatMode;
+    /** Pause state */
+    paused: boolean;
+    /** Wether the player was playing or not */
+    playing: boolean;
+    /** When the player was created */
+    createdTimeStamp?: number;
+    /** All current used fitlers Data */
+    filters: FilterData;
+    /** The player's ping object */
+    ping: {
+        /** Ping to the voice websocket server */
+        ws: number;
+        /** Avg. calc. Ping to the lavalink server */
+        lavalink: number;
+    };
+    /** Equalizer Bands used in lavalink */
+    equalizer: EQBand[];
+    /** The Id of the last used node */
+    nodeId?: string;
+    /** The SessionId of the node */
+    nodeSessionId?: string;
+    /** The stored queue */
+    queue?: StoredQueue;
+}
+type RepeatMode = "queue" | "track" | "off";
+interface PlayerOptions {
+    /** Guild id of the player */
     guildId: string;
-    /** The line number */
-    lineIndex: number;
-    /** The line */
-    line: LyricsLine;
-    /**skipped is true if the line was skipped */
-    skipped: boolean;
+    /** The Voice Channel Id */
+    voiceChannelId: string;
+    /** The Text Channel Id of the Player */
+    textChannelId?: string;
+    /** instantly change volume with the one play request */
+    volume?: number;
+    /** VC Region for node selections */
+    vcRegion?: string;
+    /** if it should join deafened */
+    selfDeaf?: boolean;
+    /** If it should join muted */
+    selfMute?: boolean;
+    /** If it should use a specific lavalink node */
+    node?: LavalinkNode | string;
+    /** If when applying filters, it should use the insta apply filters fix  */
+    instaUpdateFiltersFix?: boolean;
+    /** If a volume should be applied via filters instead of lavalink-volume */
+    applyVolumeAsFilter?: boolean;
+    /** Custom Data for the player get/set datastorage */
+    customData?: anyObject;
 }
-type LoadTypes = "track" | "playlist" | "search" | "error" | "empty";
-type State = "CONNECTED" | "CONNECTING" | "DISCONNECTED" | "DISCONNECTING" | "DESTROYING";
-type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | SponsorBlockSegmentEventType | LyricsEventType;
-type TrackEndReason = "finished" | "loadFailed" | "stopped" | "replaced" | "cleanup";
-interface InvalidLavalinkRestRequest {
-    /** Rest Request Data for when it was made */
-    timestamp: number;
-    /** Status of the request */
-    status: number;
-    /** Specific Errro which was sent */
-    error: string;
-    /** Specific Message which was created */
-    message?: string;
-    /** The specific error trace from the request */
-    trace?: unknown;
-    /** Path of where it's from */
-    path: string;
+type anyObject = {
+    [key: string | number]: string | number | null | anyObject;
+};
+interface BasePlayOptions {
+    /** The position to start the track. */
+    position?: number;
+    /** The position to end the track. */
+    endTime?: number;
+    /** If to start "paused" */
+    paused?: boolean;
+    /** The Volume to start with */
+    volume?: number;
+    /** The Lavalink Filters to use | only with the new REST API */
+    filters?: Partial<LavalinkFilterData>;
+    /** Voice Update for Lavalink */
+    voice?: LavalinkPlayerVoiceOptions;
 }
-interface LavalinkPlayerVoice {
-    /** The Voice Token */
-    token: string;
-    /** The Voice Server Endpoint  */
-    endpoint: string;
-    /** The Voice SessionId */
-    sessionId: string;
-    /** Wether or not the player is connected */
-    connected?: boolean;
-    /** The Ping to the voice server */
-    ping?: number;
+interface LavalinkPlayOptions extends BasePlayOptions {
+    /** Which Track to play | don't provide, if it should pick from the Queue */
+    track?: {
+        /** The track encoded base64 string to use instead of the one from the queue system */
+        encoded?: Base64 | null;
+        /** The identifier of the track to use */
+        identifier?: string;
+        /** Custom User Data for the track to provide, will then be on the userData object from the track */
+        userData?: anyObject;
+        /** The Track requester for when u provide encodedTrack / identifer */
+        requester?: unknown;
+    };
 }
-type LavalinkPlayerVoiceOptions = Omit<LavalinkPlayerVoice, 'connected' | 'ping'>;
-interface FailingAddress {
-    /** The failing address */
-    failingAddress: string;
-    /** The timestamp when the address failed */
-    failingTimestamp: number;
-    /** The timestamp when the address failed as a pretty string */
-    failingTime: string;
+interface PlayOptions extends LavalinkPlayOptions {
+    /** Whether to not replace the track if a play payload is sent. */
+    noReplace?: boolean;
+    /** Adds track on queue and skips to it */
+    clientTrack?: Track | UnresolvedTrack;
 }
-type RoutePlannerTypes = "RotatingIpRoutePlanner" | "NanoIpRoutePlanner" | "RotatingNanoIpRoutePlanner" | "BalancingIpRoutePlanner";
-interface RoutePlanner {
-    class?: RoutePlannerTypes;
-    details?: {
-        /** The ip block being used */
-        ipBlock: {
-            /** The type of the ip block */
-            type: "Inet4Address" | "Inet6Address";
-            /** 	The size of the ip block */
-            size: string;
-        };
-        /** The failing addresses */
-        failingAddresses: FailingAddress[];
-        /** The number of rotations */
-        rotateIndex?: string;
-        /** The current offset in the block	 */
-        ipIndex?: string;
-        /** The current address being used	 */
-        currentAddress?: string;
-        /** The current offset in the ip block */
-        currentAddressIndex?: string;
-        /** The information in which /64 block ips are chosen. This number increases on each ban. */
-        blockIndex?: string;
-    };
+
+/** Ability to manipulate fetch requests */
+type ModifyRequest = (options: RequestInit & {
+    path: string;
+    extraQueryUrlParams?: URLSearchParams;
+}) => void;
+type SponsorBlockSegment = "sponsor" | "selfpromo" | "interaction" | "intro" | "outro" | "preview" | "music_offtopic" | "filler";
+/**
+ * Node Options for creating a lavalink node
+ */
+interface LavalinkNodeOptions {
+    /** The Lavalink Server-Ip / Domain-URL */
+    host: string;
+    /** The Lavalink Connection Port */
+    port: number;
+    /** The Lavalink Password / Authorization-Key */
+    authorization: string;
+    /** Does the Server use ssl (https) */
+    secure?: boolean;
+    /** RESUME THE PLAYER? by providing a sessionid on the node-creation */
+    sessionId?: string;
+    /** Add a Custom ID to the node, for later use */
+    id?: string;
+    /** Voice Regions of this Node */
+    regions?: string[];
+    /** The max amount of retries for this node. */
+    retryAmount?: number;
+    /** The delay of how often to retry a reconnection. */
+    retryDelay?: number;
+    /** How long a retry is a valid retry, it should be at least retryAmount*retryDelay. if <= 0 (default) then this won't be accounted. */
+    retryTimespan?: number;
+    /** signal for cancelling requests - default: AbortSignal.timeout(options.requestSignalTimeoutMS || 10000) - put <= 0 to disable */
+    requestSignalTimeoutMS?: number;
+    /** Close on error */
+    closeOnError?: boolean;
+    /** Heartbeat interval , set to <= 0 to disable heartbeat system */
+    heartBeatInterval?: number;
+    /** Recommended, to check wether the client is still connected or not on the stats endpoint */
+    enablePingOnStatsCheck?: boolean;
 }
-interface Session {
-    /** Wether or not session is resuming or not */
-    resuming: boolean;
-    /** For how long a session is lasting while not connected */
-    timeout: number;
+/**
+ * Memory Stats object from lavalink
+ */
+interface MemoryStats {
+    /** The free memory of the allocated amount. */
+    free: number;
+    /** The used memory of the allocated amount. */
+    used: number;
+    /** The total allocated memory. */
+    allocated: number;
+    /** The reservable memory. */
+    reservable: number;
 }
-interface GuildShardPayload {
-    /** The OP code */
-    op: number;
-    /** Data to send  */
-    d: {
-        /** Guild id to apply voice settings */
-        guild_id: string;
-        /** channel to move/connect to, or null to leave it */
-        channel_id: string | null;
-        /** wether or not mute yourself */
-        self_mute: boolean;
-        /** wether or not deafen yourself */
-        self_deaf: boolean;
-    };
+/**
+ * CPU Stats object from lavalink
+ */
+interface CPUStats {
+    /** The core amount the host machine has. */
+    cores: number;
+    /** The system load. */
+    systemLoad: number;
+    /** The lavalink load. */
+    lavalinkLoad: number;
 }
-interface PlayerUpdateInfo {
-    /** guild id of the player */
-    guildId: string;
-    /** Player options to provide to lavalink */
-    playerOptions: LavalinkPlayOptions;
-    /** Whether or not replace the current track with the new one (true is recommended) */
-    noReplace?: boolean;
+/**
+ * FrameStats Object from lavalink
+ */
+interface FrameStats {
+    /** The amount of sent frames. */
+    sent?: number;
+    /** The amount of nulled frames. */
+    nulled?: number;
+    /** The amount of deficit frames. */
+    deficit?: number;
 }
-interface LavalinkPlayer {
-    /** Guild Id of the player */
-    guildId: string;
-    /** IF playing a track, all of the track information */
-    track?: LavalinkTrack;
-    /** Lavalink volume (mind volumedecrementer) */
-    volume: number;
-    /** Wether it's paused or not */
-    paused: boolean;
-    /** Voice Endpoint data */
-    voice: LavalinkPlayerVoice;
-    /** All Audio Filters */
-    filters: Partial<LavalinkFilterData>;
-    /** Lavalink-Voice-State Variables */
-    state: {
-        /** Time since connection established */
-        time: number;
-        /** Position of the track */
-        position: number;
-        /** COnnected or not */
-        connected: boolean;
-        /** Ping to voice server */
-        ping: number;
-    };
+/**
+ * BaseNodeStats object from Lavalink
+ */
+interface BaseNodeStats {
+    /** The amount of players on the node. */
+    players: number;
+    /** The amount of playing players on the node. */
+    playingPlayers: number;
+    /** The uptime for the node. */
+    uptime: number;
+    /** The memory stats for the node. */
+    memory: MemoryStats;
+    /** The cpu stats for the node. */
+    cpu: CPUStats;
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
 }
-interface ChannelDeletePacket {
-    /** Packet key for channel delete */
-    t: "CHANNEL_DELETE";
-    /** data which is sent and relevant */
-    d: {
-        /** guild id */
-        guild_id: string;
-        /** Channel id */
-        id: string;
-    };
+/**
+ * Interface for nodeStats from lavalink
+ */
+interface NodeStats extends BaseNodeStats {
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
 }
-interface VoiceState {
-    /** OP key from lavalink */
-    op: "voiceUpdate";
-    /** GuildId provided by lavalink */
-    guildId: string;
-    /** Event data */
-    event: VoiceServer;
-    /** Session Id of the voice connection */
-    sessionId?: string;
-    /** guild id of the voice channel */
-    guild_id: string;
-    /** user id from the voice connection */
-    user_id: string;
-    /** Session Id of the voice connection */
-    session_id: string;
-    /** Voice Channel Id */
-    channel_id: string;
-    /** Server Mute status */
-    mute: boolean;
-    /** Server Deaf status */
-    deaf: boolean;
-    /** Self Deaf status */
-    self_deaf: boolean;
-    /** Self Mute status */
-    self_mute: boolean;
-    /** Self Video (Camera) status */
-    self_video: boolean;
-    /** Self Stream status */
-    self_stream: boolean;
-    /** Wether the user requests to speak (stage channel) */
-    request_to_speak_timestamp: boolean;
-    /** Self suppressed status (stage channel) */
-    suppress: boolean;
+/**
+ * Entire lavalink information object from lavalink
+ */
+interface LavalinkInfo {
+    /** The version of this Lavalink server */
+    version: VersionObject;
+    /** The millisecond unix timestamp when this Lavalink jar was built */
+    buildTime: number;
+    /** The git information of this Lavalink server */
+    git: GitObject;
+    /** The JVM version this Lavalink server runs on */
+    jvm: string;
+    /** The Lavaplayer version being used by this server */
+    lavaplayer: string;
+    /** The enabled source managers for this server */
+    sourceManagers: string[];
+    /** The enabled filters for this server */
+    filters: string[];
+    /** The enabled plugins for this server */
+    plugins: PluginObject[];
 }
-/** The Base64 decodes tring by lavalink */
-type Base64 = string;
-interface VoiceServer {
-    /** Voice Token */
-    token: string;
-    /** Guild Id of the voice server connection */
-    guild_id: string;
-    /** Server Endpoint */
-    endpoint: string;
+/**
+ * Lavalink's version object from lavalink
+ */
+interface VersionObject {
+    /** The full version string of this Lavalink server */
+    semver: string;
+    /** The major version of this Lavalink server */
+    major: number;
+    /** The minor version of this Lavalink server */
+    minor: number;
+    /** The patch version of this Lavalink server */
+    patch: number;
+    /** The pre-release version according to semver as a . separated list of identifiers */
+    preRelease?: string;
+    /** The build metadata according to semver as a . separated list of identifiers */
+    build?: string;
 }
-interface VoicePacket {
-    /** Voice Packet Keys to send */
-    t?: "VOICE_SERVER_UPDATE" | "VOICE_STATE_UPDATE";
-    /** Voice Packets to send */
-    d: VoiceState | VoiceServer;
+/**
+ * Git information object from lavalink
+ */
+interface GitObject {
+    /** The branch this Lavalink server was built on */
+    branch: string;
+    /** The commit this Lavalink server was built on */
+    commit: string;
+    /** The millisecond unix timestamp for when the commit was created */
+    commitTime: string;
 }
-interface NodeMessage extends NodeStats {
-    /** The type of the event */
-    type: PlayerEventType;
-    /** what ops are applying to that event */
-    op: "stats" | "playerUpdate" | "event";
-    /** The specific guild id for that message */
-    guildId: string;
+/**
+ * Lavalink's plugins object from lavalink's plugin
+ */
+interface PluginObject {
+    /** The name of the plugin */
+    name: string;
+    /** The version of the plugin */
+    version: string;
 }
-/** Specific types to filter for lavasearch, will be filtered to correct types */
-type LavaSearchType = "track" | "album" | "artist" | "playlist" | "text" | "tracks" | "albums" | "artists" | "playlists" | "texts";
-interface LavaSearchFilteredResponse {
-    /** The Information of a playlist provided by lavasearch */
-    info: PlaylistInfo;
-    /** additional plugin information */
-    pluginInfo: PluginInfo;
-    /** List of tracks  */
-    tracks: Track[];
+interface LyricsResult {
+    /**The name of the source */
+    sourceName: string;
+    /**The name of the provider */
+    provider: string;
+    /**The result text */
+    text: string | null;
+    /**The lyrics lines */
+    lines: LyricsLine[];
+    /**Information about the plugin */
+    plugin: PluginInfo;
 }
-interface LavaSearchResponse {
-    /** An array of tracks, only present if track is in types */
-    tracks: Track[];
-    /** An array of albums, only present if album is in types */
-    albums: LavaSearchFilteredResponse[];
-    /** 	An array of artists, only present if artist is in types */
-    artists: LavaSearchFilteredResponse[];
-    /** 	An array of playlists, only present if playlist is in types */
-    playlists: LavaSearchFilteredResponse[];
-    /** An array of text results, only present if text is in types */
-    texts: {
-        text: string;
-        pluginInfo: PluginInfo;
-    }[];
-    /** Addition result data provided by plugins */
-    pluginInfo: PluginInfo;
+interface LyricsLine {
+    /**The millisecond timestamp */
+    timestamp: number;
+    /**The line duration in milliseconds */
+    duration: number | null;
+    /**The line text */
+    line: string;
+    /**Information about the plugin */
+    plugin: PluginInfo;
+}
+type LavalinkNodeIdentifier = string;
+interface NodeManagerEvents {
+    /**
+     * Emitted when a Node is created.
+     * @event Manager.nodeManager#create
+     */
+    "create": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is destroyed.
+     * @event Manager.nodeManager#destroy
+     */
+    "destroy": (node: LavalinkNode, destroyReason?: DestroyReasonsType) => void;
+    /**
+     * Emitted when a Node is connected.
+     * @event Manager.nodeManager#connect
+     */
+    "connect": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is reconnecting.
+     * @event Manager.nodeManager#reconnecting
+    */
+    "reconnecting": (node: LavalinkNode) => void;
+    /**
+     * Emitted When a node starts to reconnect (if you have a reconnection delay, the reconnecting event will be emitted after the retryDelay.)
+     * Useful to check wether the internal node reconnect system works or not
+     * @event Manager.nodeManager#reconnectinprogress
+     */
+    "reconnectinprogress": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is disconnects.
+     * @event Manager.nodeManager#disconnect
+    */
+    "disconnect": (node: LavalinkNode, reason: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    /**
+     * Emitted when a Node is error.
+     * @event Manager.nodeManager#error
+    */
+    "error": (node: LavalinkNode, error: Error, payload?: unknown) => void;
+    /**
+     * Emits every single Node event.
+     * @event Manager.nodeManager#raw
+    */
+    "raw": (node: LavalinkNode, payload: unknown) => void;
+    /**
+     * Emits when the node connects resumed. You then need to create all players within this event for your usecase.
+     * Aka for that you need to be able to save player data like vc channel + text channel in a db and then sync it again
+     * @event Manager.nodeManager#nodeResumed
+     */
+    "resumed": (node: LavalinkNode, payload: {
+        resumed: true;
+        sessionId: string;
+        op: "ready";
+    }, players: LavalinkPlayer[] | InvalidLavalinkRestRequest) => void;
+}
+declare enum ReconnectionState {
+    IDLE = "IDLE",
+    RECONNECTING = "RECONNECTING",
+    PENDING = "PENDING",
+    DESTROYING = "DESTROYING"
 }
-/** SearchQuery Object for raw lavalink requests */
-type SearchQuery = {
-    /** lavalink search Query / identifier string */
-    query: string;
-    /** Extra url query params to use, e.g. for flowertts */
-    extraQueryUrlParams?: URLSearchParams;
-    /** Source to append to the search query string */
-    source?: SearchPlatform;
-} | /** Our just the search query / identifier string */ string;
-/** SearchQuery Object for Lavalink LavaSearch Plugin requests */
-type LavaSearchQuery = {
-    /** lavalink search Query / identifier string */
-    query: string;
-    /** Source to append to the search query string */
-    source: LavaSrcSearchPlatformBase;
-    /** The Types to filter the search to */
-    types?: LavaSearchType[];
-};
-type Awaitable<T> = Promise<T> | T;
 
 /**
  * Lavalink Node creator class
@@ -2195,11 +2203,13 @@ declare class LavalinkNode {
     };
     /** Actual Lavalink Information of the Node */
     info: LavalinkInfo | null;
+    /** current state of the Reconnections */
+    reconnectionState: ReconnectionState;
     /** The Node Manager of this Node */
     private NodeManager;
     /** The Reconnection Timeout */
     private reconnectTimeout?;
-    /** The Reconnection Attempt counter */
+    /** The Reconnection Attempt counter (array of datetimes when it tried it.) */
     private reconnectAttempts;
     /** The Socket of the Lavalink */
     private socket;
@@ -2584,17 +2594,38 @@ declare class LavalinkNode {
      * Get the rest Adress for making requests
      */
     private get restAddress();
+    /**
+     * If already trying to reconnect or pending, return
+     */
+    get isNodeReconnecting(): boolean;
     /**
      * Reconnect to the lavalink node
-     * @param instaReconnect @default false wether to instantly try to reconnect
+     * @param force @default false Wether to instantly try to reconnect (force it)
      * @returns void
      *
      * @example
      * ```ts
-     * await player.node.reconnect();
+     * await player.node.reconnect(true); //true forcefully trys the reconnect
      * ```
      */
     private reconnect;
+    get reconnectionAttemptCount(): number;
+    /**
+     * Private Utility function to execute the reconnection
+    */
+    private executeReconnect;
+    /**
+     * Private function to reset the reconnection attempts
+     * @returns
+     */
+    private resetReconnectionAttempts;
+    /**
+     * Private function to reset timeouts/intervals for heartbeating/pinging
+     * @param heartbeat
+     * @param ping
+     * @returns
+     */
+    private resetAckTimeouts;
     /** @private util function for handling opening events from websocket */
     private open;
     /** @private util function for handling closing events from websocket */
@@ -3299,4 +3330,4 @@ declare const LavalinkPlugins: {
 /** Lavalink Sources regexes for url validations */
 declare const SourceLinksRegexes: Record<SourcesRegex, RegExp>;
 
-export { type AudioOutputs, type Awaitable, type Base64, type BaseNodeStats, type BasePlayOptions, type BotClientOptions, type CPUStats, type ChannelDeletePacket, type ChannelMixFilter, type ClientCustomSearchPlatformUtils, type ClientSearchPlatform, DebugEvents, type DeepRequired, DefaultQueueStore, DefaultSources, DestroyReasons, type DestroyReasonsType, DisconnectReasons, type DisconnectReasonsType, type DistortionFilter, type DuncteSearchPlatform, type EQBand, EQList, type Exception, type FailingAddress, type FilterData, FilterManager, type FloatNumber, type FrameStats, type GitObject, type GuildShardPayload, type IntegerNumber, type InvalidLavalinkRestRequest, type JioSaavnSearchPlatform, type KaraokeFilter, type LavaSearchFilteredResponse, type LavaSearchQuery, type LavaSearchResponse, type LavaSearchType, type LavaSrcSearchPlatform, type LavaSrcSearchPlatformBase, type LavalinkClientSearchPlatform, type LavalinkClientSearchPlatformResolve, type LavalinkFilterData, type LavalinkInfo, LavalinkManager, type LavalinkManagerEvents, LavalinkNode, type LavalinkNodeIdentifier, type LavalinkNodeOptions, type LavalinkPlayOptions, type LavalinkPlayer, type LavalinkPlayerVoice, type LavalinkPlayerVoiceOptions, type LavalinkPlugin_JioSaavn_SourceNames, type LavalinkPlugin_LavaSrc_SourceNames, LavalinkPlugins, type LavalinkSearchPlatform, type LavalinkSourceNames, type LavalinkTrack, type LavalinkTrackInfo, type LoadTypes, type LowPassFilter, type LyricsEvent, type LyricsEventType, type LyricsFoundEvent, type LyricsLine, type LyricsLineEvent, type LyricsNotFoundEvent, type LyricsResult, type ManagerOptions, type ManagerPlayerOptions, type ManagerQueueOptions, ManagerUtils, type MemoryStats, MiniMap, type MiniMapConstructor, type ModifyRequest, NodeManager, type NodeManagerEvents, type NodeMessage, type NodeStats, NodeSymbol, type Opaque, type PlayOptions, Player, type PlayerEvent, type PlayerEventType, type PlayerEvents, type PlayerFilters, type PlayerJson, type PlayerOptions, type PlayerUpdateInfo, type PlaylistInfo, type PluginInfo, type PluginObject, Queue, type QueueChangesWatcher, QueueSaver, type QueueStoreManager, QueueSymbol, type RepeatMode, type RequiredManagerOptions, type RotationFilter, type RoutePlanner, type RoutePlannerTypes, type SearchPlatform, type SearchQuery, type SearchResult, type Session, type Severity, SourceLinksRegexes, type SourceNames, type SourcesRegex, type SponsorBlockChapterStarted, type SponsorBlockChaptersLoaded, type SponsorBlockSegment, type SponsorBlockSegmentEventType, type SponsorBlockSegmentEvents, type SponsorBlockSegmentSkipped, type SponsorBlockSegmentsLoaded, type State, type StoredQueue, type TimescaleFilter, type Track, type TrackEndEvent, type TrackEndReason, type TrackExceptionEvent, type TrackInfo, type TrackStartEvent, type TrackStuckEvent, TrackSymbol, type TremoloFilter, type UnresolvedQuery, type UnresolvedSearchResult, type UnresolvedTrack, type UnresolvedTrackInfo, UnresolvedTrackSymbol, type VersionObject, type VibratoFilter, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent, type anyObject, audioOutputsData, parseLavalinkConnUrl, queueTrackEnd, safeStringify, validSponsorBlocks };
+export { type AudioOutputs, type Awaitable, type Base64, type BaseNodeStats, type BasePlayOptions, type BotClientOptions, type CPUStats, type ChannelDeletePacket, type ChannelMixFilter, type ClientCustomSearchPlatformUtils, type ClientSearchPlatform, DebugEvents, type DeepRequired, DefaultQueueStore, DefaultSources, DestroyReasons, type DestroyReasonsType, DisconnectReasons, type DisconnectReasonsType, type DistortionFilter, type DuncteSearchPlatform, type EQBand, EQList, type Exception, type FailingAddress, type FilterData, FilterManager, type FloatNumber, type FrameStats, type GitObject, type GuildShardPayload, type IntegerNumber, type InvalidLavalinkRestRequest, type JioSaavnSearchPlatform, type KaraokeFilter, type LavaSearchFilteredResponse, type LavaSearchQuery, type LavaSearchResponse, type LavaSearchType, type LavaSrcSearchPlatform, type LavaSrcSearchPlatformBase, type LavalinkClientSearchPlatform, type LavalinkClientSearchPlatformResolve, type LavalinkFilterData, type LavalinkInfo, LavalinkManager, type LavalinkManagerEvents, LavalinkNode, type LavalinkNodeIdentifier, type LavalinkNodeOptions, type LavalinkPlayOptions, type LavalinkPlayer, type LavalinkPlayerVoice, type LavalinkPlayerVoiceOptions, type LavalinkPlugin_JioSaavn_SourceNames, type LavalinkPlugin_LavaSrc_SourceNames, LavalinkPlugins, type LavalinkSearchPlatform, type LavalinkSourceNames, type LavalinkTrack, type LavalinkTrackInfo, type LoadTypes, type LowPassFilter, type LyricsEvent, type LyricsEventType, type LyricsFoundEvent, type LyricsLine, type LyricsLineEvent, type LyricsNotFoundEvent, type LyricsResult, type ManagerOptions, type ManagerPlayerOptions, type ManagerQueueOptions, ManagerUtils, type MemoryStats, MiniMap, type MiniMapConstructor, type ModifyRequest, NodeManager, type NodeManagerEvents, type NodeMessage, type NodeStats, NodeSymbol, type Opaque, type PlayOptions, Player, type PlayerEvent, type PlayerEventType, type PlayerEvents, type PlayerFilters, type PlayerJson, type PlayerOptions, type PlayerUpdateInfo, type PlaylistInfo, type PluginInfo, type PluginObject, Queue, type QueueChangesWatcher, QueueSaver, type QueueStoreManager, QueueSymbol, ReconnectionState, type RepeatMode, type RequiredManagerOptions, type RotationFilter, type RoutePlanner, type RoutePlannerTypes, type SearchPlatform, type SearchQuery, type SearchResult, type Session, type Severity, SourceLinksRegexes, type SourceNames, type SourcesRegex, type SponsorBlockChapterStarted, type SponsorBlockChaptersLoaded, type SponsorBlockSegment, type SponsorBlockSegmentEventType, type SponsorBlockSegmentEvents, type SponsorBlockSegmentSkipped, type SponsorBlockSegmentsLoaded, type State, type StoredQueue, type TimescaleFilter, type Track, type TrackEndEvent, type TrackEndReason, type TrackExceptionEvent, type TrackInfo, type TrackStartEvent, type TrackStuckEvent, TrackSymbol, type TremoloFilter, type UnresolvedQuery, type UnresolvedSearchResult, type UnresolvedTrack, type UnresolvedTrackInfo, UnresolvedTrackSymbol, type VersionObject, type VibratoFilter, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent, type anyObject, audioOutputsData, parseLavalinkConnUrl, queueTrackEnd, safeStringify, validSponsorBlocks };