lavalink-client 1.0.3 → 1.0.5

package/dist/esm/structures/Queue.js

@@ -1,8 +1,10 @@
-import { ManagerUitls, QueueSymbol } from "./Utils";
+import { ManagerUitls } from "./Utils";
 export class QueueSaver {
-    constructor(storeManager, options) {
-        this._ = storeManager;
-        this.options = options;
+    constructor(options) {
+        this._ = options.queueStore || new DefaultQueueStore();
+        this.options = {
+            maxPreviousTracks: options.maxPreviousTracks
+        };
     }
     async get(guildId) {
         return await this._.parse(await this._.get(guildId));
@@ -57,17 +59,18 @@ export class Queue {
     options = { maxPreviousTracks: 25 };
     guildId = "";
     QueueSaver = null;
-    static StaticSymbol = QueueSymbol;
     managerUtils = new ManagerUitls();
     queueChanges;
-    constructor(guildId, data = {}, QueueSaver, queueChangesWatcher) {
-        this.queueChanges = queueChangesWatcher || null;
+    constructor(guildId, data = {}, QueueSaver, queueOptions) {
+        this.queueChanges = queueOptions.queueChangesWatcher || null;
         this.guildId = guildId;
         this.QueueSaver = QueueSaver;
         this.options.maxPreviousTracks = this.QueueSaver?.options?.maxPreviousTracks ?? this.options.maxPreviousTracks;
         this.current = this.managerUtils.isTrack(data.current) ? data.current : null;
-        this.previous = Array.isArray(data.previous) && data.previous.some(track => this.managerUtils.isTrack(track)) ? data.previous.filter(track => this.managerUtils.isTrack(track)) : [];
-        this.tracks = Array.isArray(data.tracks) && data.tracks.some(track => this.managerUtils.isTrack(track)) ? data.tracks.filter(track => this.managerUtils.isTrack(track)) : [];
+        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) {
     }
     /**
      * Utils for a Queue
@@ -79,7 +82,7 @@ export class Queue {
         save: async () => {
             if (this.previous.length > this.options.maxPreviousTracks)
                 this.previous.splice(this.options.maxPreviousTracks, this.previous.length);
-            return await this.QueueSaver.set(this.guildId, this.utils.getStored());
+            return await this.QueueSaver.set(this.guildId, this.utils.toJSON());
         },
         /**
          * Sync the current queue database/server with the cached one
@@ -89,12 +92,12 @@ export class Queue {
             const data = await this.QueueSaver.get(this.guildId);
             if (!data)
                 return console.log("No data found to sync for guildId: ", this.guildId);
-            if (!dontSyncCurrent && !this.current && this.managerUtils.isTrack(data.current))
+            if (!dontSyncCurrent && !this.current && (this.managerUtils.isTrack(data.current)))
                 this.current = data.current;
-            if (Array.isArray(data.tracks) && data?.tracks.length && data.tracks.some(track => this.managerUtils.isTrack(track)))
-                this.tracks.splice(override ? 0 : this.tracks.length, override ? this.tracks.length : 0, ...data.tracks.filter(track => this.managerUtils.isTrack(track)));
-            if (Array.isArray(data.previous) && data?.previous.length && data.previous.some(track => this.managerUtils.isTrack(track)))
-                this.previous.splice(0, override ? this.tracks.length : 0, ...data.previous.filter(track => this.managerUtils.isTrack(track)));
+            if (Array.isArray(data.tracks) && data?.tracks.length && data.tracks.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)))
+                this.tracks.splice(override ? 0 : this.tracks.length, override ? this.tracks.length : 0, ...data.tracks.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)));
+            if (Array.isArray(data.previous) && data?.previous.length && data.previous.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)))
+                this.previous.splice(0, override ? this.tracks.length : 0, ...data.previous.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)));
             await this.utils.save();
             return;
         },
@@ -104,13 +107,13 @@ export class Queue {
         /**
          * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the storeManager
          */
-        getStored: () => {
+        toJSON: () => {
             if (this.previous.length > this.options.maxPreviousTracks)
                 this.previous.splice(this.options.maxPreviousTracks, this.previous.length);
             return {
-                current: this.current,
-                previous: this.previous,
-                tracks: this.tracks,
+                current: this.current ? { ...this.current } : null,
+                previous: this.previous ? [...this.previous] : [],
+                tracks: this.tracks ? [...this.tracks] : [],
             };
         },
         /**
@@ -126,7 +129,7 @@ export class Queue {
      * @returns Amount of Tracks in the Queue
      */
     async shuffle() {
-        const oldStored = typeof this.queueChanges?.shuffled === "function" ? this.utils.getStored() : null;
+        const oldStored = typeof this.queueChanges?.shuffled === "function" ? this.utils.toJSON() : null;
         if (this.tracks.length <= 1)
             return this.tracks.length;
         // swap #1 and #2 if only 2 tracks.
@@ -141,7 +144,7 @@ export class Queue {
         }
         // LOG
         if (typeof this.queueChanges?.shuffled === "function")
-            this.queueChanges.shuffled(this.guildId, oldStored, this.utils.getStored());
+            this.queueChanges.shuffled(this.guildId, oldStored, this.utils.toJSON());
         await this.utils.save();
         return this.tracks.length;
     }
@@ -153,14 +156,14 @@ export class Queue {
      */
     async add(TrackOrTracks, index) {
         if (typeof index === "number" && index >= 0 && index < this.tracks.length)
-            return await this.splice(index, 0, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)));
-        const oldStored = typeof this.queueChanges?.tracksAdd === "function" ? this.utils.getStored() : null;
+            return await this.splice(index, 0, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)));
+        const oldStored = typeof this.queueChanges?.tracksAdd === "function" ? this.utils.toJSON() : null;
         // add the track(s)
-        this.tracks.push(...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)));
+        this.tracks.push(...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)));
         // log if available
         if (typeof this.queueChanges?.tracksAdd === "function")
             try {
-                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)), this.tracks.length, oldStored, this.utils.getStored());
+                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)), this.tracks.length, oldStored, this.utils.toJSON());
             }
             catch (e) { /*  */ }
         // save the queue
@@ -176,7 +179,7 @@ export class Queue {
      * @returns {Track} Spliced Track
      */
     async splice(index, amount, TrackOrTracks) {
-        const oldStored = typeof this.queueChanges?.tracksAdd === "function" || typeof this.queueChanges?.tracksRemoved === "function" ? this.utils.getStored() : null;
+        const oldStored = typeof this.queueChanges?.tracksAdd === "function" || typeof this.queueChanges?.tracksRemoved === "function" ? this.utils.toJSON() : null;
         // if no tracks to splice, add the tracks
         if (!this.tracks.length) {
             if (TrackOrTracks)
@@ -186,17 +189,17 @@ export class Queue {
         // Log if available
         if ((TrackOrTracks) && typeof this.queueChanges?.tracksAdd === "function")
             try {
-                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)), index, oldStored, this.utils.getStored());
+                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)), index, oldStored, this.utils.toJSON());
             }
             catch (e) { /*  */ }
         // remove the tracks (and add the new ones)
-        let spliced = TrackOrTracks ? this.tracks.splice(index, amount, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v))) : this.tracks.splice(index, amount);
+        let spliced = TrackOrTracks ? this.tracks.splice(index, amount, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v))) : this.tracks.splice(index, amount);
         // get the spliced array
         spliced = (Array.isArray(spliced) ? spliced : [spliced]);
         // Log if available
         if (typeof this.queueChanges?.tracksRemoved === "function")
             try {
-                this.queueChanges.tracksRemoved(this.guildId, spliced, index, oldStored, this.utils.getStored());
+                this.queueChanges.tracksRemoved(this.guildId, spliced, index, oldStored, this.utils.toJSON());
             }
             catch (e) { /* */ }
         // save the queue

package/dist/esm/structures/Track.d.ts

@@ -1,3 +1,4 @@
+import { Player } from "./Player";
 import { Base64 } from "./Utils";
 type LavalinkSourceNames = "youtube" | "youtubemusic" | "soundcloud" | "bandcamp" | "twitch";
 type LavalinkPlugin_LavaSrc_SourceNames = "deezer" | "spotify" | "applemusic" | "yandexmusic" | "flowery-tts";
@@ -44,11 +45,21 @@ export interface Track extends LavalinkTrack {
     /** The Track's Requester */
     requester?: unknown;
 }
-export interface UnresolvedQuery {
+export interface UnresolvedTrackInfo extends Partial<TrackInfo> {
+    /** Required */
+    title: string;
+}
+export interface UnresolvedQuery extends UnresolvedTrackInfo {
     /** The base64 of the unresolved track to "encode" */
     encoded?: Base64;
-    /** Search for the closest track possible, by providing as much information as you can! */
-    info?: Partial<TrackInfo>;
+}
+export interface UnresolvedTrack {
+    /** Required */
+    resolve: (player: Player) => Promise<void>;
+    /** The Base 64 encoded String */
+    encoded?: Base64;
+    /** Track Information */
+    info: UnresolvedTrackInfo;
     /** The Track's Requester */
     requester?: unknown;
 }

package/dist/esm/structures/Utils.d.ts

@@ -1,9 +1,8 @@
 import { LavalinkFilterData } from "./Filters";
 import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode, NodeStats } from "./Node";
-import { PlayOptions } from "./Player";
-import { Queue } from "./Queue";
-import { PluginInfo, Track } from "./Track";
+import { LavalinkNode, LavalinkNodeOptions, NodeStats } from "./Node";
+import { PlayOptions, Player } from "./Player";
+import { PluginInfo, Track, UnresolvedTrack, UnresolvedQuery } from "./Track";
 export declare const TrackSymbol: unique symbol;
 export declare const UnresolvedTrackSymbol: unique symbol;
 export declare const QueueSymbol: unique symbol;
@@ -40,12 +39,39 @@ export interface ManagerUitls {
 export declare class ManagerUitls {
     constructor(LavalinkManager?: LavalinkManager);
     buildTrack(data: any, requester: any): Track;
+    /**
+     * Validate if a data is equal to a node
+     * @param data
+     */
+    isNode(data: LavalinkNode): boolean;
+    /**
+     * Validate if a data is equal to node options
+     * @param data
+     */
+    isNodeOptions(data: LavalinkNodeOptions | any): boolean;
     /**
      * Validate if a data is euqal to a track
-     * @param {Track|any} data the Track to validate
-     * @returns {boolean}
+     * @param data the Track to validate
+     * @returns
      */
     isTrack(data: Track | any): boolean;
+    /**
+     * Checks if the provided argument is a valid UnresolvedTrack.
+     * @param track
+     */
+    isUnresolvedTrack(data: UnresolvedTrack | any): boolean;
+    /**
+     * Checks if the provided argument is a valid UnresolvedTrack.
+     * @param track
+     */
+    isUnresolvedTrackQuery(data: UnresolvedTrack | any): boolean;
+    getClosestTrack(data: UnresolvedTrack, player: Player): Promise<Track>;
+    /**
+     * Builds a UnresolvedTrack to be resolved before being played  .
+     * @param query
+     * @param requester
+     */
+    buildUnresolvedTrack(query: UnresolvedQuery | UnresolvedTrack, requester: unknown): UnresolvedTrack;
     validatedQuery(queryString: string, node: LavalinkNode): void;
 }
 /**
@@ -85,6 +111,7 @@ export declare class MiniMap<K, V> extends Map<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(): 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).
@@ -254,5 +281,5 @@ export interface NodeMessage extends NodeStats {
     op: "stats" | "playerUpdate" | "event";
     guildId: string;
 }
-export declare function queueTrackEnd(queue: Queue, addBackToQueue?: boolean): Promise<Track>;
+export declare function queueTrackEnd(player: Player): Promise<Track>;
 export {};

package/dist/esm/structures/Utils.js

@@ -38,14 +38,103 @@ export class ManagerUitls {
             throw new RangeError(`Argument "data" is not a valid track: ${error.message}`);
         }
     }
+    /**
+     * Validate if a data is equal to a node
+     * @param data
+     */
+    isNode(data) {
+        if (!data)
+            return false;
+        const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(data));
+        if (!keys.includes("constructor"))
+            return false;
+        if (!keys.length)
+            return false;
+        // all required functions
+        if (!["connect", "destroy", "destroyPlayer", "fetchAllPlayers", "fetchInfo", "fetchPlayer", "fetchStats", "fetchVersion", "request", "updatePlayer", "updateSession"].every(v => keys.includes(v)))
+            return false;
+        return true;
+    }
+    /**
+     * Validate if a data is equal to node options
+     * @param data
+     */
+    isNodeOptions(data) {
+        if (!data || typeof data !== "object" || Array.isArray(data))
+            return false;
+        if (typeof data.host !== "string" || !data.host.length)
+            return false;
+        if (typeof data.port !== "number" || isNaN(data.port) || data.port < 0 || data.port > 65535)
+            return false;
+        if (typeof data.authorization !== "string" || !data.authorization.length)
+            return false;
+        if ("secure" in data && typeof data.secure !== "boolean")
+            return false;
+        if ("sessionId" in data && typeof data.sessionId !== "string")
+            return false;
+        if ("id" in data && typeof data.id !== "string")
+            return false;
+        if ("regions" in data && (!Array.isArray(data.regions) || !data.regions.every(v => typeof v === "string")))
+            return false;
+        if ("poolOptions" in data && typeof data.poolOptions !== "object")
+            return false;
+        if ("retryAmount" in data && (typeof data.retryAmount !== "number" || isNaN(data.retryAmount) || data.retryAmount <= 0))
+            return false;
+        if ("retryDelay" in data && (typeof data.retryDelay !== "number" || isNaN(data.retryDelay) || data.retryDelay <= 0))
+            return false;
+        if ("requestTimeout" in data && (typeof data.requestTimeout !== "number" || isNaN(data.requestTimeout) || data.requestTimeout <= 0))
+            return false;
+        return true;
+    }
     /**
      * Validate if a data is euqal to a track
-     * @param {Track|any} data the Track to validate
-     * @returns {boolean}
+     * @param data the Track to validate
+     * @returns
      */
     isTrack(data) {
         return typeof data?.encoded === "string" && typeof data?.info === "object";
     }
+    /**
+     * Checks if the provided argument is a valid UnresolvedTrack.
+     * @param track
+     */
+    isUnresolvedTrack(data) {
+        return typeof data === "object" && "info" in data && typeof data.info.title === "string" && typeof data.resolve === "function";
+    }
+    /**
+     * Checks if the provided argument is a valid UnresolvedTrack.
+     * @param track
+     */
+    isUnresolvedTrackQuery(data) {
+        return typeof data === "object" && !("info" in data) && typeof data.title === "string";
+    }
+    async getClosestTrack(data, player) {
+        return getClosestTrack(data, player, this);
+    }
+    /**
+     * Builds a UnresolvedTrack to be resolved before being played  .
+     * @param query
+     * @param requester
+     */
+    buildUnresolvedTrack(query, requester) {
+        if (typeof query === "undefined")
+            throw new RangeError('Argument "query" must be present.');
+        const unresolvedTrack = {
+            encoded: query.encoded || undefined,
+            info: query.info ?? query,
+            requester: typeof this.manager.options?.playerOptions?.requesterTransformer === "function" ? this.manager.options?.playerOptions?.requesterTransformer((query?.requester || requester)) : requester,
+            async resolve(player) {
+                const closest = await getClosestTrack(this, player, player.LavalinkManager.utils);
+                if (!closest)
+                    throw new SyntaxError("No closest Track found");
+                Object.getOwnPropertyNames(this).forEach(prop => delete this[prop]);
+                Object.assign(this, closest);
+                return;
+            }
+        };
+        Object.defineProperty(unresolvedTrack, UnresolvedTrackSymbol, { configurable: true, value: true });
+        return unresolvedTrack;
+    }
     validatedQuery(queryString, node) {
         if (!node.info)
             throw new Error("No Lavalink Node was provided");
@@ -148,6 +237,10 @@ export class MiniMap extends Map {
         }
         return results;
     }
+    toJSON() {
+        // toJSON is called recursively by JSON.stringify.
+        return [...this.values()];
+    }
     map(fn, thisArg) {
         if (typeof thisArg !== 'undefined')
             fn = fn.bind(thisArg);
@@ -159,19 +252,49 @@ export class MiniMap extends Map {
         });
     }
 }
-export async function queueTrackEnd(queue, addBackToQueue = false) {
-    if (queue.current) { // if there was a current Track -> Add it
-        queue.previous.unshift(queue.current);
-        if (queue.previous.length > queue.options.maxPreviousTracks)
-            queue.previous.splice(queue.options.maxPreviousTracks, queue.previous.length);
+export async function queueTrackEnd(player) {
+    if (player.queue.current) { // if there was a current Track -> Add it
+        player.queue.previous.unshift(player.queue.current);
+        if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
+            player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
     }
-    // change the current Track to the next upcoming one
-    queue.current = queue.tracks.shift() || null;
     // and if repeatMode == queue, add it back to the queue!
-    if (addBackToQueue && queue.current)
-        queue.tracks.push(queue.current);
+    if (player.repeatMode === "queue" && player.queue.current)
+        player.queue.tracks.push(player.queue.current);
+    // change the current Track to the next upcoming one
+    const nextSong = player.queue.tracks.shift();
+    if (player.LavalinkManager.utils.isUnresolvedTrack(nextSong))
+        await nextSong.resolve(player);
+    player.queue.current = nextSong || null;
     // save it in the DB
-    await queue.utils.save();
+    await player.queue.utils.save();
     // return the new current Track
-    return queue.current;
+    return player.queue.current;
+}
+async function getClosestTrack(data, player, utils) {
+    if (!player || !player.node)
+        throw new RangeError("No player with a lavalink node was provided");
+    if (utils.isTrack(data))
+        return utils.buildTrack(data, data.requester);
+    if (!utils.isUnresolvedTrack(data))
+        throw new RangeError("Track is not an unresolved Track");
+    if (!data?.info?.title)
+        throw new SyntaxError("the track title is required for unresolved tracks");
+    if (!data.requester)
+        throw new SyntaxError("The requester is required");
+    if (typeof data.encoded === "string") {
+        const r = await player.node.decode.singleTrack(data.encoded);
+        if (r)
+            return utils.buildTrack(r, data.requester);
+    }
+    if (typeof data.info.uri === "string") {
+        const r = await player.search({ query: data?.info?.uri }, data.requester).then(v => v.tracks[0]);
+        if (r)
+            return r;
+    }
+    const query = [data.info?.title, data.info?.author].filter(str => !!str).join(" by ");
+    const sourceName = data.info?.sourceName;
+    return await player.search({
+        query, source: sourceName !== "bandcamp" && sourceName !== "twitch" && sourceName !== "flowery-tts" ? sourceName : player.LavalinkManager.options?.playerOptions?.defaultSearchPlatform,
+    }, data.requester).then(v => v.tracks[0]);
 }

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

@@ -1,17 +1,16 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
 import { NodeManager } from "./NodeManager";
-import { QueueChangesWatcher, QueueSaverOptions, StoreManager } from "./Queue";
+import { QueueSaverOptions } from "./Queue";
 import { GuildShardPayload, LavalinkSearchPlatform, ManagerUitls, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
 import { LavalinkNodeOptions } from "./Node";
 import { DestroyReasonsType, Player, PlayerOptions } from "./Player";
-import { Track } from "./Track";
+import { Track, UnresolvedTrack } from "./Track";
 export interface LavalinkManager {
     nodeManager: NodeManager;
     utils: ManagerUitls;
 }
 export interface BotClientOptions {
-    shards?: number | number[] | "auto";
     id: string;
     username?: string;
     /** So users can pass entire objects / classes */
@@ -44,8 +43,6 @@ export interface LavalinkPlayerOptions {
 export interface ManagerOptions {
     nodes: LavalinkNodeOptions[];
     queueOptions?: QueueSaverOptions;
-    queueStore?: StoreManager;
-    queueChangesWatcher?: QueueChangesWatcher;
     client?: BotClientOptions;
     playerOptions?: LavalinkPlayerOptions;
     autoSkip?: boolean;
@@ -55,32 +52,32 @@ export interface ManagerOptions {
 interface LavalinkManagerEvents {
     /**
      * Emitted when a Track started playing.
-     * @event Manager.playerManager#trackStart
+     * @event Manager#trackStart
      */
     "trackStart": (player: Player, track: Track, payload: TrackStartEvent) => void;
     /**
      * Emitted when a Track finished.
-     * @event Manager.playerManager#trackEnd
+     * @event Manager#trackEnd
      */
     "trackEnd": (player: Player, track: Track, payload: TrackEndEvent) => void;
     /**
      * Emitted when a Track got stuck while playing.
-     * @event Manager.playerManager#trackStuck
+     * @event Manager#trackStuck
      */
     "trackStuck": (player: Player, track: Track, payload: TrackStuckEvent) => void;
     /**
      * Emitted when a Track errored.
-     * @event Manager.playerManager#trackError
+     * @event Manager#trackError
      */
-    "trackError": (player: Player, track: Track, payload: TrackExceptionEvent) => void;
+    "trackError": (player: Player, track: Track | UnresolvedTrack, payload: TrackExceptionEvent) => void;
     /**
      * Emitted when the Playing finished and no more tracks in the queue.
-     * @event Manager.playerManager#queueEnd
+     * @event Manager#queueEnd
      */
     "queueEnd": (player: Player, track: Track, payload: TrackEndEvent | TrackStuckEvent | TrackExceptionEvent) => void;
     /**
      * Emitted when a Player is created.
-     * @event Manager.playerManager#create
+     * @event Manager#playerCreate
      */
     "playerCreate": (player: Player) => void;
     /**
@@ -90,19 +87,24 @@ interface LavalinkManagerEvents {
     "playerMove": (player: Player, oldVoiceChannelId: string, newVoiceChannelId: string) => void;
     /**
      * Emitted when a Player is disconnected from a channel.
-     * @event Manager.playerManager#disconnect
+     * @event Manager#playerDisconnect
      */
     "playerDisconnect": (player: Player, voiceChannelId: string) => void;
     /**
      * Emitted when a Node-Socket got closed for a specific Player.
-     * @event Manager.playerManager#socketClosed
+     * @event Manager#playerSocketClosed
      */
     "playerSocketClosed": (player: Player, payload: WebSocketClosedEvent) => void;
     /**
      * Emitted when a Player get's destroyed
-     * @event Manager.playerManager#destroy
+     * @event Manager#playerDestroy
      */
     "playerDestroy": (player: Player, destroyReason?: DestroyReasonsType) => void;
+    /**
+     * Always emits when the player (on lavalink side) got updated
+     * @event Manager#playerUpdate
+     */
+    "playerUpdate": (player: Player) => void;
 }
 export interface LavalinkManager {
     options: ManagerOptions;

package/dist/types/structures/NodeManager.d.ts

@@ -55,7 +55,7 @@ export declare class NodeManager extends EventEmitter {
     nodes: MiniMap<string, LavalinkNode>;
     constructor(LavalinkManager: LavalinkManager);
     createNode(options: LavalinkNodeOptions): LavalinkNode;
-    get leastUsedNodes(): LavalinkNode[];
+    leastUsedNodes(sortType?: "memory" | "cpuLavalink" | "cpuSystem" | "calls" | "playingPlayers" | "players"): LavalinkNode[];
     deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
 }
 export {};

package/dist/types/structures/Player.d.ts

@@ -110,7 +110,7 @@ export declare class Player {
      * Play the next track from the queue / a specific track, with playoptions for Lavalink
      * @param options
      */
-    play(options?: Partial<PlayOptions>): Promise<void>;
+    play(options?: Partial<PlayOptions>): any;
     /**
      * Set the Volume for the Player
      * @param volume The Volume in percent
@@ -143,12 +143,12 @@ export declare class Player {
      * Set the Repeatmode of the Player
      * @param repeatMode
      */
-    setRepeatMode(repeatMode: RepeatMode): Promise<void>;
+    setRepeatMode(repeatMode: RepeatMode): Promise<RepeatMode>;
     /**
      * 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): Promise<true | void>;
+    skip(skipTo?: number): Promise<any>;
     /**
      * Connects the Player to the Voice Channel
      * @returns
@@ -172,6 +172,7 @@ export declare class Player {
     /** Converts the Player including Queue to a Json state */
     toJSON(): {
         guildId: string;
+        options: PlayerOptions;
         voiceChannelId: string;
         textChannelId: string;
         position: number;
@@ -184,7 +185,6 @@ export declare class Player {
         createdTimeStamp: number;
         filters: {};
         equalizer: import("./Filters").EQBand[];
-        queue: import("./Queue").StoredQueue;
         nodeId: string;
     };
 }

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

@@ -1,4 +1,4 @@
-import { Track } from "./Track";
+import { Track, UnresolvedTrack } from "./Track";
 export interface StoredQueue {
     current: Track | null;
     previous: Track[];
@@ -18,6 +18,8 @@ export interface StoreManager extends Record<any, any> {
 }
 export interface QueueSaverOptions {
     maxPreviousTracks: number;
+    queueStore?: StoreManager;
+    queueChangesWatcher?: QueueChangesWatcher;
 }
 export interface QueueSaver {
     /** @private */
@@ -26,7 +28,7 @@ export interface QueueSaver {
     options: QueueSaverOptions;
 }
 export declare class QueueSaver {
-    constructor(storeManager: StoreManager, options: QueueSaverOptions);
+    constructor(options: QueueSaverOptions);
     get(guildId: string): Promise<Partial<StoredQueue>>;
     delete(guildId: string): Promise<any>;
     set(guildId: string, value: any): Promise<any>;
@@ -43,23 +45,23 @@ export declare class DefaultQueueStore {
 }
 export declare class QueueChangesWatcher {
     constructor();
-    tracksAdd(guildId: string, tracks: Track[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
-    tracksRemoved(guildId: string, tracks: Track[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+    tracksAdd(guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+    tracksRemoved(guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
     shuffled(guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
 }
 export declare class Queue {
-    readonly tracks: Track[];
+    readonly tracks: (Track | UnresolvedTrack)[];
     readonly previous: Track[];
     current: Track | null;
     options: {
         maxPreviousTracks: number;
     };
     private readonly guildId;
-    protected readonly QueueSaver: QueueSaver | null;
-    static readonly StaticSymbol: Symbol;
+    private readonly QueueSaver;
     private managerUtils;
     private queueChanges;
-    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueChangesWatcher?: QueueChangesWatcher);
+    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: QueueSaverOptions);
+    private applyData;
     /**
      * Utils for a Queue
      */
@@ -77,7 +79,7 @@ export declare class Queue {
         /**
          * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the storeManager
          */
-        getStored: () => StoredQueue;
+        toJSON: () => StoredQueue;
         /**
          * Get the Total Duration of the Queue-Songs summed up
          * @returns {number}
@@ -95,7 +97,7 @@ export declare class Queue {
      * @param {number} index At what position to add the Track
      * @returns {number} Queue-Size (for the next Tracks)
      */
-    add(TrackOrTracks: Track | Track[], index?: number): any;
+    add(TrackOrTracks: Track | UnresolvedTrack | (Track | UnresolvedTrack)[], index?: number): any;
     /**
      * Splice the tracks in the Queue
      * @param {number} index Where to remove the Track
@@ -103,5 +105,5 @@ export declare class Queue {
      * @param {Track | Track[]} TrackOrTracks Want to Add more Tracks?
      * @returns {Track} Spliced Track
      */
-    splice(index: number, amount: number, TrackOrTracks?: Track | Track[]): any;
+    splice(index: number, amount: number, TrackOrTracks?: Track | UnresolvedTrack | (Track | UnresolvedTrack)[]): any;
 }