lavalink-client 2.3.6 → 2.4.0

package/dist/esm/structures/NodeManager.js

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import { DestroyReasons } from "./Constants.js";
+import { DestroyReasons, DisconnectReasons } from "./Constants.js";
 import { LavalinkNode } from "./Node.js";
 import { MiniMap } from "./Utils.js";
 export class NodeManager extends EventEmitter {
@@ -70,18 +70,24 @@ export class NodeManager extends EventEmitter {
     /**
      * Disconnects all Nodes from lavalink ws sockets
      * @param deleteAllNodes if the nodes should also be deleted from nodeManager.nodes
+     * @param destroyPlayers if the players should be destroyed
      * @returns amount of disconnected Nodes
      */
-    async disconnectAll(deleteAllNodes = false) {
+    async disconnectAll(deleteAllNodes = false, destroyPlayers = true) {
         if (!this.nodes.size)
             throw new Error("There are no nodes to disconnect (no nodes in the nodemanager)");
         if (!this.nodes.filter(v => v.connected).size)
             throw new Error("There are no nodes to disconnect (all nodes disconnected)");
         let counter = 0;
-        for (const node of [...this.nodes.values()]) {
+        for (const node of this.nodes.values()) {
             if (!node.connected)
                 continue;
-            await node.destroy(DestroyReasons.DisconnectAllNodes, deleteAllNodes);
+            if (destroyPlayers) {
+                await node.destroy(DestroyReasons.DisconnectAllNodes, deleteAllNodes);
+            }
+            else {
+                await node.disconnect(DisconnectReasons.DisconnectAllNodes);
+            }
             counter++;
         }
         return counter;
@@ -96,7 +102,7 @@ export class NodeManager extends EventEmitter {
         if (!this.nodes.filter(v => !v.connected).size)
             throw new Error("There are no nodes to connect (all nodes connected)");
         let counter = 0;
-        for (const node of [...this.nodes.values()]) {
+        for (const node of this.nodes.values()) {
             if (node.connected)
                 continue;
             await node.connect();
@@ -112,7 +118,7 @@ export class NodeManager extends EventEmitter {
         if (!this.nodes.size)
             throw new Error("There are no nodes to reconnect (no nodes in the nodemanager)");
         let counter = 0;
-        for (const node of [...this.nodes.values()]) {
+        for (const node of this.nodes.values()) {
             const sessionId = node.sessionId ? `${node.sessionId}` : undefined;
             await node.destroy(DestroyReasons.ReconnectAllNodes, false);
             await node.connect(sessionId);
@@ -138,53 +144,47 @@ export class NodeManager extends EventEmitter {
      * @returns
      */
     leastUsedNodes(sortType = "players") {
+        const connectedNodes = Array.from(this.nodes.values()).filter((node) => node.connected);
         switch (sortType) {
             case "memory":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0)); // sort after memor
                 }
                 break;
             case "cpuLavalink":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.cpu?.lavalinkLoad || 0) - (b.stats?.cpu?.lavalinkLoad || 0)); // sort after memor
                 }
                 break;
             case "cpuSystem":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.cpu?.systemLoad || 0) - (b.stats?.cpu?.systemLoad || 0)); // sort after memor
                 }
                 break;
             case "calls":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => a.calls - b.calls); // client sided sorting
                 }
                 break;
             case "playingPlayers":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0));
                 }
                 break;
             case "players":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
                 }
                 break;
             default:
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
                 }
                 break;

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

@@ -52,6 +52,13 @@ export declare class Player {
     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;
     /**
@@ -97,7 +104,7 @@ export declare class Player {
      * @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<import("./Types/Utils.js").SearchResult | import("./Types/Utils.js").LavaSearchResponse>;
+    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils.js").LavaSearchResponse | import("./Types/Utils.js").SearchResult>;
     /**
      * Set the SponsorBlock
      * @param segments The segments to set
@@ -196,7 +203,7 @@ export declare class Player {
      * const lyrics = await player.subscribeLyrics();
      * ```
      */
-    subscribeLyrics(): Promise<any>;
+    subscribeLyrics(): Promise<unknown>;
     /**
      * Unsubscribe from the lyrics event on a specific guild to disable live lyrics events
      * @param guildId The guild id to unsubscribe from
@@ -206,7 +213,7 @@ export declare class Player {
      * const lyrics = await player.unsubscribeLyrics();
      * ```
      */
-    unsubscribeLyrics(guildId: string): Promise<any>;
+    unsubscribeLyrics(guildId: string): Promise<void>;
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id

package/dist/esm/structures/Player.js

@@ -56,6 +56,13 @@ export class Player {
         sessionId: null,
         token: null
     };
+    voiceState = {
+        selfDeaf: false,
+        selfMute: false,
+        serverDeaf: false,
+        serverMute: false,
+        suppress: false,
+    };
     /** Custom data for the player */
     data = {};
     /**
@@ -142,6 +149,7 @@ export class Player {
                     functionLayer: "Player > play()",
                 });
             }
+            this.LavalinkManager.emit("playerQueueEmptyCancel", this);
             clearTimeout(this.get("internal_queueempty"));
             this.set("internal_queueempty", undefined);
         }
@@ -540,6 +548,10 @@ export class Player {
     async destroy(reason, disconnect = true) {
         if (this.LavalinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
             console.log(`Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Destroy-Reason: ${String(reason)}`);
+        if (this.get("internal_queueempty")) {
+            clearTimeout(this.get("internal_queueempty"));
+            this.set("internal_queueempty", undefined);
+        }
         if (this.get("internal_destroystatus") === true) {
             if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
                 this.LavalinkManager.emit("debug", DebugEvents.PlayerDestroyingSomewhereElse, {

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

@@ -1,4 +1,3 @@
-import { MiniMap } from "./Utils.js";
 import type { Track, UnresolvedTrack } from "./Types/Track.js";
 import type { ManagerQueueOptions, QueueStoreManager, StoredQueue } from "./Types/Queue.js";
 export declare class QueueSaver {
@@ -24,14 +23,14 @@ export declare class QueueSaver {
      * @param guildId The guild ID
      * @returns The queue for the guild
      */
-    delete(guildId: string): Promise<unknown>;
+    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<unknown>;
+    set(guildId: string, valueToStringify: StoredQueue): Promise<boolean | void>;
     /**
      * Sync the queue for a guild
      * @param guildId The guild ID
@@ -47,32 +46,32 @@ export declare class DefaultQueueStore implements QueueStoreManager {
      * @param guildId The guild ID
      * @returns The queue for the guild
      */
-    get(guildId: any): Promise<unknown>;
+    get(guildId: string): Promise<StoredQueue>;
     /**
      * 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: any, valueToStringify: any): Promise<MiniMap<unknown, unknown>>;
+    set(guildId: string, valueToStringify: any): Promise<boolean>;
     /**
      * Delete the queue for a guild
      * @param guildId The guild ID
      * @returns The queue for the guild
      */
-    delete(guildId: any): Promise<boolean>;
+    delete(guildId: string): Promise<boolean>;
     /**
      * Stringify the queue for a guild
      * @param value The queue to stringify
      * @returns The stringified queue
      */
-    stringify(value: any): Promise<any>;
+    stringify(value: StoredQueue): Promise<StoredQueue>;
     /**
      * Parse the queue for a guild
      * @param value The queue to parse
      * @returns The parsed queue
      */
-    parse(value: any): Promise<Partial<StoredQueue>>;
+    parse(value: StoredQueue): Promise<StoredQueue>;
 }
 export declare class Queue {
     readonly tracks: (Track | UnresolvedTrack)[];
@@ -100,13 +99,13 @@ export declare class Queue {
         /**
          * Save the current cached Queue on the database/server (overides the server)
          */
-        save: () => Promise<unknown>;
+        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<unknown>;
+        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
          */

package/dist/esm/structures/Queue.js

@@ -57,7 +57,7 @@ export class DefaultQueueStore {
      * @returns The queue for the guild
      */
     async get(guildId) {
-        return await this.data.get(guildId);
+        return this.data.get(guildId);
     }
     /**
      * Set the queue for a guild
@@ -66,7 +66,7 @@ export class DefaultQueueStore {
      * @returns The queue for the guild
      */
     async set(guildId, valueToStringify) {
-        return await this.data.set(guildId, valueToStringify);
+        return this.data.set(guildId, valueToStringify) ? true : false;
     }
     /**
      * Delete the queue for a guild
@@ -74,7 +74,7 @@ export class DefaultQueueStore {
      * @returns The queue for the guild
      */
     async delete(guildId) {
-        return await this.data.delete(guildId);
+        return this.data.delete(guildId);
     }
     /**
      * Stringify the queue for a guild

package/dist/esm/structures/Types/Manager.d.ts

@@ -73,6 +73,46 @@ export interface LavalinkManagerEvents {
      * @event Manager#playerUpdate
      */
     "playerUpdate": (oldPlayerJson: PlayerJson, newPlayer: Player) => void;
+    /**
+     * Emitted when the player's selfMuted or serverMuted state changed (true -> false | false -> true)
+     * @event Manager#playerMuteChange
+     */
+    "playerMuteChange": (player: Player, selfMuted: boolean, serverMuted: boolean) => void;
+    /**
+     * Emitted when the player's selfDeafed or serverDeafed state changed (true -> false | false -> true)
+     * @event Manager#playerDeafChange
+     */
+    "playerDeafChange": (player: Player, selfDeafed: boolean, serverDeafed: boolean) => void;
+    /**
+     * Emitted when the player's suppressed (true -> false | false -> true)
+     * @event Manager#playerSuppressChange
+     */
+    "playerSuppressChange": (player: Player, suppress: boolean) => void;
+    /**
+     * Emitted when the player's queue got empty, and the timeout started
+     * @event Manager#playerQueueEmptyStart
+     */
+    "playerQueueEmptyStart": (player: Player, timeoutMs: number) => void;
+    /**
+     * Emitted when the player's queue got empty, and the timeout finished leading to destroying the player
+     * @event Manager#playerQueueEmptyEnd
+     */
+    "playerQueueEmptyEnd": (player: Player) => void;
+    /**
+     * Emitted when the player's queue got empty, and the timeout got cancelled becuase a track got re-added to it.
+     * @event Manager#playerQueueEmptyEnd
+     */
+    "playerQueueEmptyCancel": (player: Player) => void;
+    /**
+     * Emitted, when a user joins the voice channel, while there is a player existing
+     * @event Manager#playerQueueEmptyStart
+     */
+    "playerVoiceJoin": (player: Player, userId: string) => void;
+    /**
+     * Emitted, when a user leaves the voice channel, while there is a player existing
+     * @event Manager#playerQueueEmptyEnd
+     */
+    "playerVoiceLeave": (player: Player, userId: string) => void;
     /**
      * SPONSORBLOCK-PLUGIN EVENT
      * Emitted when Segments are loaded

package/dist/esm/structures/Types/Node.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type internal from "stream";
 import type { LavalinkNode } from "../Node.js";
 import type { DestroyReasonsType } from "./Player.js";

package/dist/esm/structures/Types/Player.d.ts

@@ -1,9 +1,11 @@
-import type { DestroyReasons } from "../Constants.js";
+import type { DestroyReasons, DisconnectReasons } from "../Constants.js";
 import type { LavalinkNode } from "../Node.js";
 import type { EQBand, FilterData, LavalinkFilterData } from "./Filters.js";
+import type { StoredQueue } from "./Queue.js";
 import type { Track, UnresolvedTrack } from "./Track.js";
 import type { Base64, LavalinkPlayerVoiceOptions } from "./Utils.js";
 export type DestroyReasonsType = keyof typeof DestroyReasons | string;
+export type DisconnectReasonsType = keyof typeof DisconnectReasons | string;
 export interface PlayerJson {
     /** Guild Id where the player was playing in */
     guildId: string;
@@ -46,6 +48,8 @@ export interface PlayerJson {
     nodeId?: string;
     /** The SessionId of the node */
     nodeSessionId?: string;
+    /** The stored queue */
+    queue?: StoredQueue;
 }
 export type RepeatMode = "queue" | "track" | "off";
 export interface PlayerOptions {

package/dist/esm/structures/Types/Queue.d.ts

@@ -4,17 +4,17 @@ export interface StoredQueue {
     previous: Track[];
     tracks: (Track | UnresolvedTrack)[];
 }
-export interface QueueStoreManager extends Record<string, any> {
+export interface QueueStoreManager {
     /** @async get a Value (MUST RETURN UNPARSED!) */
-    get: (guildId: unknown) => Promise<unknown>;
+    get: (guildId: string) => Promise<StoredQueue | string>;
     /** @async Set a value inside a guildId (MUST BE UNPARSED) */
-    set: (guildId: unknown, value: unknown) => Promise<unknown>;
+    set: (guildId: string, value: StoredQueue | string) => Promise<void | boolean>;
     /** @async Delete a Database Value based of it's guildId */
-    delete: (guildId: unknown) => Promise<unknown>;
+    delete: (guildId: string) => Promise<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: unknown) => Promise<unknown>;
+    stringify: (value: StoredQueue | string) => Promise<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: unknown) => Promise<Partial<StoredQueue>>;
+    parse: (value: StoredQueue | string) => Promise<Partial<StoredQueue>>;
 }
 export interface ManagerQueueOptions {
     /** Maximum Amount of tracks for the queue.previous array. Set to 0 to not save previous songs. Defaults to 25 Tracks */

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

@@ -5,8 +5,10 @@ import type { Base64 } from "./Utils.js";
 export type LavalinkSourceNames = "youtube" | "youtubemusic" | "soundcloud" | "bandcamp" | "twitch";
 /** Source Names provided by lava src plugin */
 export type LavalinkPlugin_LavaSrc_SourceNames = "deezer" | "spotify" | "applemusic" | "yandexmusic" | "flowery-tts";
+/** Source Names provided by jiosaavan plugin */
+export type LavalinkPlugin_JioSaavn_SourceNames = "jiosaavn";
 /** The SourceNames provided by lavalink */
-export type SourceNames = LavalinkSourceNames | LavalinkPlugin_LavaSrc_SourceNames;
+export type SourceNames = LavalinkSourceNames | LavalinkPlugin_LavaSrc_SourceNames | LavalinkPlugin_JioSaavn_SourceNames;
 export interface LavalinkTrackInfo {
     /** The Identifier of the Track */
     identifier: string;

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

@@ -236,8 +236,7 @@ export interface LavalinkPlayerVoice {
     /** The Ping to the voice server */
     ping?: number;
 }
-export interface LavalinkPlayerVoiceOptions extends Omit<LavalinkPlayerVoice, 'connected' | 'ping'> {
-}
+export type LavalinkPlayerVoiceOptions = Omit<LavalinkPlayerVoice, 'connected' | 'ping'>;
 export interface FailingAddress {
     /** The failing address */
     failingAddress: string;
@@ -353,6 +352,22 @@ export interface VoiceState {
     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;
 }
 /** The Base64 decodes tring by lavalink */
 export type Base64 = string;

package/dist/esm/structures/Utils.js

@@ -296,9 +296,6 @@ export class ManagerUtils {
         if (SourceLinksRegexes.AllDeezerRegex.test(queryString) && !node.info?.sourceManagers?.includes("deezer")) {
             throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'deezer' enabled");
         }
-        if (SourceLinksRegexes.AllDeezerRegex.test(queryString) && node.info?.sourceManagers?.includes("deezer") && !node.info?.sourceManagers?.includes("http")) {
-            throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'http' enabled, which is required to have 'deezer' to work");
-        }
         if (SourceLinksRegexes.musicYandex.test(queryString) && !node.info?.sourceManagers?.includes("yandexmusic")) {
             throw new Error("Query / Link Provided for this Source but Lavalink Node has not 'yandexmusic' enabled");
         }
@@ -357,9 +354,6 @@ export class ManagerUtils {
         if (source === "dzisrc" && node.info?.sourceManagers?.includes("deezer") && !node.info?.sourceManagers?.includes("http")) {
             throw new Error("Lavalink Node has not 'http' enabled, which is required to have 'dzisrc' to work");
         }
-        if (source === "dzsearch" && node.info?.sourceManagers?.includes("deezer") && !node.info?.sourceManagers?.includes("http")) {
-            throw new Error("Lavalink Node has not 'http' enabled, which is required to have 'dzsearch' to work");
-        }
         if (source === "jsrec" && !node.info?.sourceManagers?.includes("jiosaavn")) {
             throw new Error("Lavalink Node has not 'jiosaavn' (via jiosaavn-plugin) enabled, which is required to have 'jsrec' to work");
         }
@@ -413,7 +407,6 @@ export class MiniMap extends Map {
         const iter = this.entries();
         return Array.from({ length: this.size }, () => {
             const [key, value] = iter.next().value;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return fn(value, key, this);
         });
     }

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

@@ -55,6 +55,10 @@ export declare enum DestroyReasons {
     TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
     TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime"
 }
+export declare enum DisconnectReasons {
+    Disconnected = "Disconnected",
+    DisconnectAllNodes = "DisconnectAllNodes"
+}
 export declare const validSponsorBlocks: string[];
 /**  The audio Outputs Data map declaration */
 export declare const audioOutputsData: Record<AudioOutputs, ChannelMixFilter>;

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

@@ -87,9 +87,33 @@ export declare class FilterManager {
      */
     toggleLowPass(smoothing?: number): Promise<boolean>;
     lavalinkLavaDspxPlugin: {
+        /**
+         * Enables / Disables the LowPass effect, (Optional: provide your Own Data)
+         * @param boostFactor
+         * @param cutoffFrequency
+         * @returns
+         */
         toggleLowPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<boolean>;
+        /**
+         * Enables / Disables the HighPass effect, (Optional: provide your Own Data)
+         * @param boostFactor
+         * @param cutoffFrequency
+         * @returns
+         */
         toggleHighPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<boolean>;
+        /**
+         * 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<boolean>} - The state of the filter after execution.
+         */
         toggleNormalization: (maxAmplitude?: number, adaptive?: boolean) => Promise<boolean>;
+        /**
+         * 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<boolean>} - The state of the filter after execution.
+         */
         toggleEcho: (decay?: number, echoLength?: number) => Promise<boolean>;
     };
     lavalinkFilterPlugin: {

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { EventEmitter } from "events";
 import { NodeManager } from "./NodeManager";
 import { Player } from "./Player";
@@ -137,7 +136,7 @@ export declare class LavalinkManager extends EventEmitter {
      * ```
      * @returns
      */
-    getPlayer(guildId: string): Player;
+    getPlayer(guildId: string): Player | undefined;
     /**
      * Create a Music-Player. If a player exists, then it returns it before creating a new one
      * @param options
@@ -175,7 +174,7 @@ export declare class LavalinkManager extends EventEmitter {
      * // recommend to do it on the player tho: player.destroy("forcefully destroyed the player");
      * ```
      */
-    destroyPlayer(guildId: string, destroyReason?: string): Promise<Player>;
+    destroyPlayer(guildId: string, destroyReason?: string): Promise<void | Player>;
     /**
      * Delete's a player from the cache without destroying it on lavalink (only works when it's disconnected)
      * @param guildId
@@ -187,7 +186,7 @@ export declare class LavalinkManager extends EventEmitter {
      * // shouldn't be used except you know what you are doing.
      * ```
      */
-    deletePlayer(guildId: string): boolean;
+    deletePlayer(guildId: string): boolean | void;
     /**
      * Checks wether the the lib is useable based on if any node is connected
      *
@@ -213,7 +212,7 @@ export declare class LavalinkManager extends EventEmitter {
      * });
      * ```
      */
-    init(clientData: BotClientOptions): Promise<this>;
+    init(clientData: BotClientOptions): Promise<LavalinkManager>;
     /**
      * Sends voice data to the Lavalink server.
      * ! Without this the library won't work