lavalink-client 1.1.4 → 1.1.6

package/dist/cjs/structures/Filters.d.ts

@@ -1,14 +1,24 @@
 import { Player } from "./Player";
-export type AudioOutputs = "mono" | "stereo" | "left" | "right";
-export interface FilterManager {
-    player: Player;
-}
+import { FloatNumber, IntegerNumber } from "./Utils";
+/**
+ * The FilterManager for each player
+ */
 export declare class FilterManager {
+    /** The Equalizer bands currently applied to the Lavalink Server */
     equalizerBands: EQBand[];
+    /** Private Util for the instaFix Filters option */
     filterUpdatedState: number;
+    /** 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
+     */
     applyPlayerFilters(): Promise<void>;
     /**
      * Checks if the filters are correctly stated (active / not-active)
@@ -20,10 +30,16 @@ export declare class FilterManager {
      * Reset all Filters
      */
     resetFilters(): Promise<PlayerFilters>;
+    /**
+     * Set the Filter Volume
+     * @param volume
+     * @returns
+     */
     setVolume(volume: number): Promise<boolean>;
     /**
      * Set the AudioOutput Filter
      * @param type
+     * @returns
      */
     setAudioOutput(type: AudioOutputs): Promise<AudioOutputs>;
     /**
@@ -119,32 +135,11 @@ export declare class FilterManager {
     /** Clears the equalizer bands. */
     clearEQ(): Promise<this>;
 }
-export declare const audioOutputsData: {
-    mono: {
-        leftToLeft: number;
-        leftToRight: number;
-        rightToLeft: number;
-        rightToRight: number;
-    };
-    stereo: {
-        leftToLeft: number;
-        leftToRight: number;
-        rightToLeft: number;
-        rightToRight: number;
-    };
-    left: {
-        leftToLeft: number;
-        leftToRight: number;
-        rightToLeft: number;
-        rightToRight: number;
-    };
-    right: {
-        leftToLeft: number;
-        leftToRight: number;
-        rightToLeft: number;
-        rightToRight: number;
-    };
-};
+/** The Audio Outputs type */
+export type AudioOutputs = "mono" | "stereo" | "left" | "right";
+/**  The audio Outputs Data map declaration */
+export declare const audioOutputsData: Record<AudioOutputs, ChannelMixFilter>;
+/** The "active" / "disabled" Player Filters */
 export interface PlayerFilters {
     /** Sets nightcore to false, and vaporwave to false */
     custom: boolean;
@@ -152,42 +147,91 @@ export interface PlayerFilters {
     nightcore: boolean;
     /** Sets custom to false, and nightcore to false */
     vaporwave: boolean;
-    /** only with the custom lavalink filter plugin */
-    echo: boolean;
-    /** only with the custom lavalink filter plugin */
-    reverb: 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;
+    /** only with the custom lavalink filter plugin */
+    echo: boolean;
+    /** only with the custom lavalink filter plugin */
+    reverb: 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.
+ */
 export interface EQBand {
-    band: number;
-    gain: number;
+    /** On what band position (0-14) it should work */
+    band: IntegerNumber;
+    /** The gain (-0.25 to 1.0) */
+    gain: FloatNumber;
 }
+/**
+ * Uses equalization to eliminate part of a band, usually targeting vocals.
+ */
 export 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
+ */
 export interface TimescaleFilter {
+    /** The playback speed 0.0 ≤ x */
     speed?: number;
+    /** The pitch 0.0 ≤ x */
     pitch?: number;
+    /** The rate 0.0 ≤ x */
     rate?: number;
 }
-export interface FreqFilter {
+/**
+ * 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
+ */
+export 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.
+ */
+export 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).
+ */
 export 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.
+ */
 export interface DistortionFilter {
     sinOffset?: number;
     sinScale?: number;
@@ -198,29 +242,52 @@ export interface DistortionFilter {
     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.
+ */
 export 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.
+ */
 export interface LowPassFilter {
+    /** The smoothing factor (1.0 < x) */
     smoothing?: number;
 }
+/**
+ * A Plugin Filter
+ */
 export interface EchoFilter {
     delay: number;
     decay: number;
 }
+/**
+ * A Plugin Filter
+ */
 export interface ReverbFilter {
     delay: number;
     decay: number;
 }
+/**
+ * Filter Data stored in the Client and partially sent to Lavalink
+ */
 export interface FilterData {
     volume?: number;
     karaoke?: KaraokeFilter;
     timescale?: TimescaleFilter;
-    tremolo?: FreqFilter;
-    vibrato?: FreqFilter;
+    tremolo?: TremoloFilter;
+    vibrato?: VibratoFilter;
     rotation?: RotationFilter;
     distortion?: DistortionFilter;
     channelMix?: ChannelMixFilter;
@@ -228,6 +295,33 @@ export interface FilterData {
     echo: EchoFilter;
     reverb: ReverbFilter;
 }
+/**
+ * Actual Filter Data sent to Lavalink
+ */
 export interface LavalinkFilterData extends FilterData {
     equalizer?: EQBand[];
 }
+export 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[];
+};

package/dist/cjs/structures/Filters.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.audioOutputsData = exports.FilterManager = void 0;
+exports.EQList = exports.audioOutputsData = exports.FilterManager = void 0;
+/**
+ * The FilterManager for each player
+ */
 class FilterManager {
+    /** The Equalizer bands currently applied to the Lavalink Server */
     equalizerBands = [];
+    /** Private Util for the instaFix Filters option */
     filterUpdatedState = 0;
+    /** All "Active" / "disabled" Player Filters */
     filters = {
         volume: false,
         vaporwave: false,
@@ -18,6 +24,7 @@ class FilterManager {
         lowPass: false,
         audioOutput: "stereo",
     };
+    /** The Filter Data sent to Lavalink, only if the filter is enabled (ofc.) */
     data = {
         lowPass: {
             smoothing: 0
@@ -64,10 +71,16 @@ class FilterManager {
             scale: 1
         }*/
     };
+    /** The Player assigned to this Filter Manager */
+    player;
+    /** The Constructor for the FilterManager */
     constructor(player) {
+        /** Assign the player to the filter manager */
         this.player = player;
     }
-    // function to update all filters at ONCE (and eqs)
+    /**
+     * Apply Player filters for lavalink filter sending data, if the filter is enabled / not
+     */
     async applyPlayerFilters() {
         const sendData = { ...this.data };
         if (!this.filters.volume)
@@ -188,6 +201,11 @@ class FilterManager {
         await this.applyPlayerFilters();
         return this.filters;
     }
+    /**
+     * Set the Filter Volume
+     * @param volume
+     * @returns
+     */
     async setVolume(volume) {
         if (volume < 0 || volume > 5)
             throw new SyntaxError("Volume-Filter must be between 0 and 5");
@@ -198,6 +216,7 @@ class FilterManager {
     /**
      * Set the AudioOutput Filter
      * @param type
+     * @returns
      */
     async setAudioOutput(type) {
         if (this.player.node.info && !this.player.node.info?.filters?.includes("channelMix"))
@@ -453,6 +472,7 @@ class FilterManager {
     }
 }
 exports.FilterManager = FilterManager;
+/**  The audio Outputs Data map declaration */
 exports.audioOutputsData = {
     mono: {
         leftToLeft: 0.5,
@@ -479,3 +499,202 @@ exports.audioOutputsData = {
         rightToRight: 1,
     },
 };
+exports.EQList = {
+    /** A Bassboost Equalizer, so high it distorts the audio */
+    BassboostEarrape: [
+        { band: 0, gain: 0.6 * 0.375 },
+        { band: 1, gain: 0.67 * 0.375 },
+        { band: 2, gain: 0.67 * 0.375 },
+        { band: 3, gain: 0.4 * 0.375 },
+        { band: 4, gain: -0.5 * 0.375 },
+        { band: 5, gain: 0.15 * 0.375 },
+        { band: 6, gain: -0.45 * 0.375 },
+        { band: 7, gain: 0.23 * 0.375 },
+        { band: 8, gain: 0.35 * 0.375 },
+        { band: 9, gain: 0.45 * 0.375 },
+        { band: 10, gain: 0.55 * 0.375 },
+        { band: 11, gain: -0.6 * 0.375 },
+        { band: 12, gain: 0.55 * 0.375 },
+        { band: 13, gain: -0.5 * 0.375 },
+        { band: 14, gain: -0.75 * 0.375 },
+    ],
+    /** A High and decent Bassboost Equalizer */
+    BassboostHigh: [
+        { band: 0, gain: 0.6 * 0.25 },
+        { band: 1, gain: 0.67 * 0.25 },
+        { band: 2, gain: 0.67 * 0.25 },
+        { band: 3, gain: 0.4 * 0.25 },
+        { band: 4, gain: -0.5 * 0.25 },
+        { band: 5, gain: 0.15 * 0.25 },
+        { band: 6, gain: -0.45 * 0.25 },
+        { band: 7, gain: 0.23 * 0.25 },
+        { band: 8, gain: 0.35 * 0.25 },
+        { band: 9, gain: 0.45 * 0.25 },
+        { band: 10, gain: 0.55 * 0.25 },
+        { band: 11, gain: -0.6 * 0.25 },
+        { band: 12, gain: 0.55 * 0.25 },
+        { band: 13, gain: -0.5 * 0.25 },
+        { band: 14, gain: -0.75 * 0.25 },
+    ],
+    /** A decent Bassboost Equalizer */
+    BassboostMedium: [
+        { band: 0, gain: 0.6 * 0.1875 },
+        { band: 1, gain: 0.67 * 0.1875 },
+        { band: 2, gain: 0.67 * 0.1875 },
+        { band: 3, gain: 0.4 * 0.1875 },
+        { band: 4, gain: -0.5 * 0.1875 },
+        { band: 5, gain: 0.15 * 0.1875 },
+        { band: 6, gain: -0.45 * 0.1875 },
+        { band: 7, gain: 0.23 * 0.1875 },
+        { band: 8, gain: 0.35 * 0.1875 },
+        { band: 9, gain: 0.45 * 0.1875 },
+        { band: 10, gain: 0.55 * 0.1875 },
+        { band: 11, gain: -0.6 * 0.1875 },
+        { band: 12, gain: 0.55 * 0.1875 },
+        { band: 13, gain: -0.5 * 0.1875 },
+        { band: 14, gain: -0.75 * 0.1875 },
+    ],
+    /** A slight Bassboost Equalizer */
+    BassboostLow: [
+        { band: 0, gain: 0.6 * 0.125 },
+        { band: 1, gain: 0.67 * 0.125 },
+        { band: 2, gain: 0.67 * 0.125 },
+        { band: 3, gain: 0.4 * 0.125 },
+        { band: 4, gain: -0.5 * 0.125 },
+        { band: 5, gain: 0.15 * 0.125 },
+        { band: 6, gain: -0.45 * 0.125 },
+        { band: 7, gain: 0.23 * 0.125 },
+        { band: 8, gain: 0.35 * 0.125 },
+        { band: 9, gain: 0.45 * 0.125 },
+        { band: 10, gain: 0.55 * 0.125 },
+        { band: 11, gain: -0.6 * 0.125 },
+        { band: 12, gain: 0.55 * 0.125 },
+        { band: 13, gain: -0.5 * 0.125 },
+        { band: 14, gain: -0.75 * 0.125 },
+    ],
+    /** Makes the Music slightly "better" */
+    BetterMusic: [
+        { band: 0, gain: 0.25 },
+        { band: 1, gain: 0.025 },
+        { band: 2, gain: 0.0125 },
+        { band: 3, gain: 0 },
+        { band: 4, gain: 0 },
+        { band: 5, gain: -0.0125 },
+        { band: 6, gain: -0.025 },
+        { band: 7, gain: -0.0175 },
+        { band: 8, gain: 0 },
+        { band: 9, gain: 0 },
+        { band: 10, gain: 0.0125 },
+        { band: 11, gain: 0.025 },
+        { band: 12, gain: 0.25 },
+        { band: 13, gain: 0.125 },
+        { band: 14, gain: 0.125 },
+    ],
+    /** Makes the Music sound like rock music / sound rock music better */
+    Rock: [
+        { band: 0, gain: 0.300 },
+        { band: 1, gain: 0.250 },
+        { band: 2, gain: 0.200 },
+        { band: 3, gain: 0.100 },
+        { band: 4, gain: 0.050 },
+        { band: 5, gain: -0.050 },
+        { band: 6, gain: -0.150 },
+        { band: 7, gain: -0.200 },
+        { band: 8, gain: -0.100 },
+        { band: 9, gain: -0.050 },
+        { band: 10, gain: 0.050 },
+        { band: 11, gain: 0.100 },
+        { band: 12, gain: 0.200 },
+        { band: 13, gain: 0.250 },
+        { band: 14, gain: 0.300 },
+    ],
+    /** Makes the Music sound like Classic music / sound Classic music better */
+    Classic: [
+        { band: 0, gain: 0.375 },
+        { band: 1, gain: 0.350 },
+        { band: 2, gain: 0.125 },
+        { band: 3, gain: 0 },
+        { band: 4, gain: 0 },
+        { band: 5, gain: 0.125 },
+        { band: 6, gain: 0.550 },
+        { band: 7, gain: 0.050 },
+        { band: 8, gain: 0.125 },
+        { band: 9, gain: 0.250 },
+        { band: 10, gain: 0.200 },
+        { band: 11, gain: 0.250 },
+        { band: 12, gain: 0.300 },
+        { band: 13, gain: 0.250 },
+        { band: 14, gain: 0.300 },
+    ],
+    /** Makes the Music sound like Pop music / sound Pop music better */
+    Pop: [
+        { band: 0, gain: 0.2635 },
+        { band: 1, gain: 0.22141 },
+        { band: 2, gain: -0.21141 },
+        { band: 3, gain: -0.1851 },
+        { band: 4, gain: -0.155 },
+        { band: 5, gain: 0.21141 },
+        { band: 6, gain: 0.22456 },
+        { band: 7, gain: 0.237 },
+        { band: 8, gain: 0.237 },
+        { band: 9, gain: 0.237 },
+        { band: 10, gain: -0.05 },
+        { band: 11, gain: -0.116 },
+        { band: 12, gain: 0.192 },
+        { band: 13, gain: 0 },
+    ],
+    /** Makes the Music sound like Electronic music / sound Electronic music better */
+    Electronic: [
+        { band: 0, gain: 0.375 },
+        { band: 1, gain: 0.350 },
+        { band: 2, gain: 0.125 },
+        { band: 3, gain: 0 },
+        { band: 4, gain: 0 },
+        { band: 5, gain: -0.125 },
+        { band: 6, gain: -0.125 },
+        { band: 7, gain: 0 },
+        { band: 8, gain: 0.25 },
+        { band: 9, gain: 0.125 },
+        { band: 10, gain: 0.15 },
+        { band: 11, gain: 0.2 },
+        { band: 12, gain: 0.250 },
+        { band: 13, gain: 0.350 },
+        { band: 14, gain: 0.400 },
+    ],
+    /** Boosts all Bands slightly for louder and fuller sound */
+    FullSound: [
+        { band: 0, gain: 0.25 + 0.375 },
+        { band: 1, gain: 0.25 + 0.025 },
+        { band: 2, gain: 0.25 + 0.0125 },
+        { band: 3, gain: 0.25 + 0 },
+        { band: 4, gain: 0.25 + 0 },
+        { band: 5, gain: 0.25 + -0.0125 },
+        { band: 6, gain: 0.25 + -0.025 },
+        { band: 7, gain: 0.25 + -0.0175 },
+        { band: 8, gain: 0.25 + 0 },
+        { band: 9, gain: 0.25 + 0 },
+        { band: 10, gain: 0.25 + 0.0125 },
+        { band: 11, gain: 0.25 + 0.025 },
+        { band: 12, gain: 0.25 + 0.375 },
+        { band: 13, gain: 0.25 + 0.125 },
+        { band: 14, gain: 0.25 + 0.125 },
+    ],
+    /** Boosts basses + lower highs for a pro gaming sound */
+    Gaming: [
+        { band: 0, gain: 0.350 },
+        { band: 1, gain: 0.300 },
+        { band: 2, gain: 0.250 },
+        { band: 3, gain: 0.200 },
+        { band: 4, gain: 0.150 },
+        { band: 5, gain: 0.100 },
+        { band: 6, gain: 0.050 },
+        { band: 7, gain: -0.0 },
+        { band: 8, gain: -0.050 },
+        { band: 9, gain: -0.100 },
+        { band: 10, gain: -0.150 },
+        { band: 11, gain: -0.200 },
+        { band: 12, gain: -0.250 },
+        { band: 13, gain: -0.300 },
+        { band: 14, gain: -0.350 },
+    ],
+};

package/dist/cjs/structures/LavalinkManager.d.ts

@@ -2,13 +2,13 @@
 import { EventEmitter } from "events";
 import { NodeManager } from "./NodeManager";
 import { ManagerQueueOptions } from "./Queue";
-import { GuildShardPayload, ManagerUitls, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
+import { GuildShardPayload, ManagerUtils, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
 import { LavalinkNodeOptions } from "./Node";
 import { DestroyReasonsType, Player, PlayerJson, PlayerOptions } from "./Player";
 import { Track, UnresolvedTrack } from "./Track";
 export interface LavalinkManager {
     nodeManager: NodeManager;
-    utils: ManagerUitls;
+    utils: ManagerUtils;
 }
 export interface BotClientOptions {
     /** Bot Client Id */
@@ -16,7 +16,7 @@ export interface BotClientOptions {
     /** Bot Client Username */
     username?: string;
     /** So users can pass entire objects / classes */
-    [x: string | number | symbol | undefined]: any;
+    [x: string | number | symbol | undefined]: unknown;
 }
 export interface ManagerPlayerOptions {
     /** If the Lavalink Volume should be decremented by x number */

package/dist/cjs/structures/LavalinkManager.js

@@ -90,7 +90,7 @@ class LavalinkManager extends events_1.EventEmitter {
             throw new SyntaxError("No Manager Options Provided");
         // create options
         this.options = options;
-        this.utils = new Utils_1.ManagerUitls(this);
+        this.utils = new Utils_1.ManagerUtils(this);
         // use the validators
         this.validateAndApply(options);
         this.applyDefaultOptions();

package/dist/cjs/structures/Node.js

@@ -67,6 +67,7 @@ class LavalinkNode {
             throw new SyntaxError("If secure is true, then the port must be 443");
         this.rest = new undici_1.Pool(this.poolAddress, this.options.poolOptions);
         this.options.regions = (this.options.regions || []).map(a => a.toLowerCase());
+        Object.defineProperty(this, Utils_1.NodeSymbol, { configurable: true, value: true });
     }
     /**
      * Makes an API call to the Node

package/dist/cjs/structures/Player.js

@@ -131,10 +131,10 @@ class Player {
         }
         if (!this.queue.current && this.queue.tracks.length)
             await (0, Utils_1.queueTrackEnd)(this);
-        // @ts-ignore
         if (this.queue.current && this.LavalinkManager.utils.isUnresolvedTrack(this.queue.current)) {
-            try { // @ts-ignore
-                this.queue.current = await this.queue.current.resolve(this);
+            try {
+                // resolve the unresolved track
+                await this.queue.current.resolve(this);
             }
             catch (error) {
                 this.LavalinkManager.emit("trackError", this, this.queue.current, error);

package/dist/cjs/structures/Queue.d.ts

@@ -7,13 +7,13 @@ export interface StoredQueue {
 }
 export interface QueueStoreManager extends Record<string, any> {
     /** @async get a Value (MUST RETURN UNPARSED!) */
-    get: (guildId: unknown) => Promise<any>;
+    get: (guildId: unknown) => Promise<unknown>;
     /** @async Set a value inside a guildId (MUST BE UNPARSED) */
-    set: (guildId: unknown, value: unknown) => Promise<any>;
+    set: (guildId: unknown, value: unknown) => Promise<unknown>;
     /** @async Delete a Database Value based of it's guildId */
-    delete: (guildId: unknown) => Promise<any>;
+    delete: (guildId: unknown) => Promise<unknown>;
     /** @async Transform the value(s) inside of the QueueStoreManager (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
-    stringify: (value: unknown) => Promise<any>;
+    stringify: (value: unknown) => Promise<unknown>;
     /** @async Parse the saved value back to the Queue (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
     parse: (value: unknown) => Promise<Partial<StoredQueue>>;
 }
@@ -33,8 +33,8 @@ export interface QueueSaver {
 export declare class QueueSaver {
     constructor(options: ManagerQueueOptions);
     get(guildId: string): Promise<Partial<StoredQueue>>;
-    delete(guildId: string): Promise<any>;
-    set(guildId: string, value: any): Promise<any>;
+    delete(guildId: string): Promise<unknown>;
+    set(guildId: string, value: any): Promise<unknown>;
     sync(guildId: string): Promise<Partial<StoredQueue>>;
 }
 export declare class DefaultQueueStore implements QueueStoreManager {
@@ -66,7 +66,6 @@ export declare class Queue {
     private managerUtils;
     private queueChanges;
     constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: ManagerQueueOptions);
-    private applyData;
     /**
      * Utils for a Queue
      */
@@ -74,13 +73,13 @@ export declare class Queue {
         /**
          * Save the current cached Queue on the database/server (overides the server)
          */
-        save: () => Promise<any>;
+        save: () => Promise<unknown>;
         /**
          * Sync the current queue database/server with the cached one
          * @returns {void}
          */
         sync: (override?: boolean, dontSyncCurrent?: boolean) => Promise<void>;
-        destroy: () => Promise<any>;
+        destroy: () => Promise<unknown>;
         /**
          * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
          */

package/dist/cjs/structures/Queue.js

@@ -50,7 +50,7 @@ class Queue {
     options = { maxPreviousTracks: 25 };
     guildId = "";
     QueueSaver = null;
-    managerUtils = new Utils_1.ManagerUitls();
+    managerUtils = new Utils_1.ManagerUtils();
     queueChanges;
     constructor(guildId, data = {}, QueueSaver, queueOptions) {
         this.queueChanges = queueOptions.queueChangesWatcher || null;
@@ -60,8 +60,7 @@ class Queue {
         this.current = this.managerUtils.isTrack(data.current) ? data.current : null;
         this.previous = Array.isArray(data.previous) && data.previous.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) ? data.previous.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) : [];
         this.tracks = Array.isArray(data.tracks) && data.tracks.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) ? data.tracks.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) : [];
-    }
-    applyData(data) {
+        Object.defineProperty(this, Utils_1.QueueSymbol, { configurable: true, value: true });
     }
     /**
      * Utils for a Queue