lavalink-client 2.2.2 → 2.3.1

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

@@ -1,62 +1,79 @@
-import { Track, UnresolvedTrack } from "./Track";
 import { MiniMap } from "./Utils";
-export interface StoredQueue {
-    current: Track | null;
-    previous: Track[];
-    tracks: Track[];
-}
-export interface QueueStoreManager extends Record<string, any> {
-    /** @async get a Value (MUST RETURN UNPARSED!) */
-    get: (guildId: unknown) => Promise<unknown>;
-    /** @async Set a value inside a guildId (MUST BE UNPARSED) */
-    set: (guildId: unknown, value: unknown) => Promise<unknown>;
-    /** @async Delete a Database Value based of it's guildId */
-    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<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>>;
-}
-export 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;
-}
-export interface QueueSaver {
-    /** @private */
-    _: QueueStoreManager;
-    /** @private */
+import type { Track, UnresolvedTrack } from "./Types/Track";
+import type { ManagerQueueOptions, QueueStoreManager, StoredQueue } from "./Types/Queue";
+export declare class QueueSaver {
+    /**
+     * The queue store manager
+     */
+    private _;
+    /**
+     * The options for the queue saver
+     */
     options: {
         maxPreviousTracks: number;
     };
-}
-export declare class QueueSaver {
     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<unknown>;
-    set(guildId: string, value: any): Promise<unknown>;
+    /**
+     * 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>;
+    /**
+     * Sync the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
     sync(guildId: string): Promise<Partial<StoredQueue>>;
 }
 export 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: any): Promise<unknown>;
-    set(guildId: any, stringifiedValue: any): Promise<MiniMap<unknown, unknown>>;
+    /**
+     * 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>>;
+    /**
+     * Delete the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
     delete(guildId: any): Promise<boolean>;
+    /**
+     * Stringify the queue for a guild
+     * @param value The queue to stringify
+     * @returns The stringified queue
+     */
     stringify(value: any): Promise<any>;
+    /**
+     * Parse the queue for a guild
+     * @param value The queue to parse
+     * @returns The parsed queue
+     */
     parse(value: any): Promise<Partial<StoredQueue>>;
 }
-export interface QueueChangesWatcher {
-    /** get a Value (MUST RETURN UNPARSED!) */
-    tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => any;
-    /** Set a value inside a guildId (MUST BE UNPARSED) */
-    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => any;
-    /** Set a value inside a guildId (MUST BE UNPARSED) */
-    shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => any;
-}
 export declare class Queue {
     readonly tracks: (Track | UnresolvedTrack)[];
     readonly previous: Track[];
@@ -68,6 +85,13 @@ export declare class Queue {
     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

package/dist/cjs/structures/Queue.js

@@ -3,41 +3,96 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Queue = exports.DefaultQueueStore = exports.QueueSaver = void 0;
 const Utils_1 = require("./Utils");
 class QueueSaver {
+    /**
+     * The queue store manager
+     */
+    _;
+    /**
+     * The options for the queue saver
+     */
+    options;
     constructor(options) {
         this._ = options?.queueStore || new DefaultQueueStore();
         this.options = {
             maxPreviousTracks: options?.maxPreviousTracks || 25,
         };
     }
+    /**
+     * Get the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
     async get(guildId) {
-        return await this._.parse(await this._.get(guildId));
+        return this._.parse(await this._.get(guildId));
     }
+    /**
+     * Delete the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
     async delete(guildId) {
-        return await this._.delete(guildId);
+        return this._.delete(guildId);
     }
-    async set(guildId, value) {
-        return await this._.set(guildId, await this._.stringify(value));
+    /**
+     * Set the queue for a guild
+     * @param guildId The guild ID
+     * @param valueToStringify The queue to set
+     * @returns The queue for the guild
+     */
+    async set(guildId, valueToStringify) {
+        return this._.set(guildId, await this._.stringify(valueToStringify));
     }
+    /**
+     * Sync the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
     async sync(guildId) {
-        return await this.get(guildId);
+        return this.get(guildId);
     }
 }
 exports.QueueSaver = QueueSaver;
 class DefaultQueueStore {
     data = new Utils_1.MiniMap();
     constructor() { }
+    /**
+     * Get the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
     async get(guildId) {
         return await this.data.get(guildId);
     }
-    async set(guildId, stringifiedValue) {
-        return await this.data.set(guildId, stringifiedValue);
+    /**
+     * Set the queue for a guild
+     * @param guildId The guild ID
+     * @param valueToStringify The queue to set
+     * @returns The queue for the guild
+     */
+    async set(guildId, valueToStringify) {
+        return await this.data.set(guildId, valueToStringify);
     }
+    /**
+     * Delete the queue for a guild
+     * @param guildId The guild ID
+     * @returns The queue for the guild
+     */
     async delete(guildId) {
         return await this.data.delete(guildId);
     }
+    /**
+     * Stringify the queue for a guild
+     * @param value The queue to stringify
+     * @returns The stringified queue
+     */
     async stringify(value) {
         return value; // JSON.stringify(value);
     }
+    /**
+     * Parse the queue for a guild
+     * @param value The queue to parse
+     * @returns The parsed queue
+     */
     async parse(value) {
         return value; // JSON.parse(value)
     }
@@ -52,6 +107,13 @@ class Queue {
     QueueSaver = null;
     managerUtils = new Utils_1.ManagerUtils();
     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, data = {}, QueueSaver, queueOptions) {
         this.queueChanges = queueOptions.queueChangesWatcher || null;
         this.guildId = guildId;
@@ -235,7 +297,6 @@ class Queue {
                 return null;
             const removed = this.tracks.splice(removeQueryTrack, 1);
             await this.utils.save();
-            console.log("0st", removed, toRemove);
             return { removed };
         }
         if (Array.isArray(removeQueryTrack)) {
@@ -245,7 +306,6 @@ class Queue {
                     if (this.tracks[i])
                         removed.push(...this.tracks.splice(i, 1));
                 }
-                console.log("1st", removed, removeQueryTrack);
                 if (!removed.length)
                     return null;
                 await this.utils.save();
@@ -266,7 +326,6 @@ class Queue {
                     removed.push(...this.tracks.splice(i, 1));
             }
             await this.utils.save();
-            console.log("2nd", removed, tracksToRemove);
             return { removed };
         }
         const toRemove = this.tracks.findIndex((v) => removeQueryTrack.encoded && removeQueryTrack.encoded === v.encoded ||
@@ -279,7 +338,6 @@ class Queue {
             return null;
         const removed = this.tracks.splice(toRemove, 1);
         await this.utils.save();
-        console.log("3rd", removed, toRemove);
         return { removed };
     }
     /**

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

@@ -0,0 +1,190 @@
+import type { FloatNumber, IntegerNumber } from "./Utils";
+/** The Audio Outputs type */
+export type AudioOutputs = "mono" | "stereo" | "left" | "right";
+/** The "active" / "disabled" Player Filters */
+export 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.
+ */
+export 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.
+ */
+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;
+}
+/**
+ * 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;
+    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.
+ */
+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;
+}
+/**
+ * Filter Data stored in the Client and partially sent to Lavalink
+ */
+export 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
+ */
+export interface LavalinkFilterData extends FilterData {
+    equalizer?: EQBand[];
+}

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

@@ -0,0 +1,184 @@
+import type { Player } from "../Player";
+import type { LavalinkNodeOptions } from "./Node";
+import type { DestroyReasonsType, PlayerJson } from "./Player";
+import type { ManagerQueueOptions } from "./Queue";
+import type { Track, UnresolvedTrack } from "./Track";
+import type { GuildShardPayload, SearchPlatform, SponsorBlockChaptersLoaded, SponsorBlockChapterStarted, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, TrackExceptionEvent, TrackEndEvent, TrackStuckEvent, WebSocketClosedEvent, TrackStartEvent } from "./Utils";
+/**
+ * The events from the lavalink Manager
+ */
+export interface LavalinkManagerEvents {
+    /**
+     * Emitted when a Track started playing.
+     * @event Manager#trackStart
+     */
+    "trackStart": (player: Player, track: Track | null, payload: TrackStartEvent) => void;
+    /**
+     * Emitted when a Track finished.
+     * @event Manager#trackEnd
+     */
+    "trackEnd": (player: Player, track: Track | null, payload: TrackEndEvent) => void;
+    /**
+     * Emitted when a Track got stuck while playing.
+     * @event Manager#trackStuck
+     */
+    "trackStuck": (player: Player, track: Track | null, payload: TrackStuckEvent) => void;
+    /**
+     * Emitted when a Track errored.
+     * @event Manager#trackError
+     */
+    "trackError": (player: Player, track: Track | UnresolvedTrack | null, payload: TrackExceptionEvent) => void;
+    /**
+     * Emitted when the Playing finished and no more tracks in the queue.
+     * @event Manager#queueEnd
+     */
+    "queueEnd": (player: Player, track: Track | UnresolvedTrack | null, payload: TrackEndEvent | TrackStuckEvent | TrackExceptionEvent) => void;
+    /**
+     * Emitted when a Player is created.
+     * @event Manager#playerCreate
+     */
+    "playerCreate": (player: Player) => void;
+    /**
+     * Emitted when a Player is moved within the channel.
+     * @event Manager#playerMove
+     */
+    "playerMove": (player: Player, oldVoiceChannelId: string, newVoiceChannelId: string) => void;
+    /**
+     * Emitted when a Player is disconnected from a channel.
+     * @event Manager#playerDisconnect
+     */
+    "playerDisconnect": (player: Player, voiceChannelId: string) => void;
+    /**
+     * Emitted when a Node-Socket got closed for a specific Player.
+     * Usually emits when the audio websocket to discord is closed, This can happen for various reasons (normal and abnormal), e.g. when using an expired voice server update. 4xxx codes are usually bad.
+     *
+     * So this is just information, normally lavalink should handle disconnections
+     *
+     * Discord Docs:
+     * @link https://discord.com/developers/docs/topics/opcodes-and-status-codes#voice-voice-close-event-codes
+     *
+     * Lavalink Docs:
+     * @link https://lavalink.dev/api/websocket.html#websocketclosedevent
+     * @event Manager#playerSocketClosed
+     */
+    "playerSocketClosed": (player: Player, payload: WebSocketClosedEvent) => void;
+    /**
+     * Emitted when a Player get's destroyed
+     * @event Manager#playerDestroy
+     */
+    "playerDestroy": (player: Player, destroyReason?: DestroyReasonsType) => void;
+    /**
+     * Always emits when the player (on lavalink side) got updated
+     * @event Manager#playerUpdate
+     */
+    "playerUpdate": (oldPlayerJson: PlayerJson, newPlayer: Player) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when Segments are loaded
+     * @link https://github.com/topi314/Sponsorblock-Plugin#segmentsloaded
+     * @event Manager#trackError
+     */
+    "SegmentsLoaded": (player: Player, track: Track | UnresolvedTrack | null, payload: SponsorBlockSegmentsLoaded) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when a specific Segment was skipped
+     * @link https://github.com/topi314/Sponsorblock-Plugin#segmentskipped
+     * @event Manager#trackError
+     */
+    "SegmentSkipped": (player: Player, track: Track | UnresolvedTrack | null, payload: SponsorBlockSegmentSkipped) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when a specific Chapter starts playing
+     * @link https://github.com/topi314/Sponsorblock-Plugin#chapterstarted
+     * @event Manager#trackError
+     */
+    "ChapterStarted": (player: Player, track: Track | UnresolvedTrack | null, payload: SponsorBlockChapterStarted) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when Chapters are loaded
+     * @link https://github.com/topi314/Sponsorblock-Plugin#chaptersloaded
+     * @event Manager#trackError
+     */
+    "ChaptersLoaded": (player: Player, track: Track | UnresolvedTrack | null, payload: SponsorBlockChaptersLoaded) => void;
+}
+/**
+ * The Bot client Options needed for the manager
+ */
+export interface BotClientOptions {
+    /** Bot Client Id */
+    id: string;
+    /** Bot Client Username */
+    username?: string;
+    /** So users can pass entire objects / classes */
+    [x: string | number | symbol]: unknown;
+}
+/** Sub Manager Options, for player specific things */
+export interface ManagerPlayerOptions {
+    /** If the Lavalink Volume should be decremented by x number */
+    volumeDecrementer?: number;
+    /** How often it should update the the player Position */
+    clientBasedPositionUpdateInterval?: number;
+    /** What should be used as a searchPlatform, if no source was provided during the query */
+    defaultSearchPlatform?: SearchPlatform;
+    /** Applies the volume via a filter, not via the lavalink volume transformer */
+    applyVolumeAsFilter?: boolean;
+    /** Transforms the saved data of a requested user */
+    requesterTransformer?: (requester: unknown) => unknown;
+    /** What lavalink-client should do when the player reconnects */
+    onDisconnect?: {
+        /** Try to reconnect? -> If fails -> Destroy */
+        autoReconnect?: boolean;
+        /** Instantly destroy player (overrides autoReconnect) | Don't provide == disable feature*/
+        destroyPlayer?: boolean;
+    };
+    onEmptyQueue?: {
+        /** Get's executed onEmptyQueue -> You can do any track queue previous transformations, if you add a track to the queue -> it will play it, if not queueEnd will execute! */
+        autoPlayFunction?: (player: Player, lastPlayedTrack: Track) => Promise<void>;
+        destroyAfterMs?: number;
+    };
+    useUnresolvedData?: boolean;
+}
+/** Manager Options used to create the manager */
+export interface ManagerOptions {
+    /** The Node Options, for all Nodes! (on init) */
+    nodes: LavalinkNodeOptions[];
+    /** @async The Function to send the voice connection changes from Lavalink to Discord */
+    sendToShard: (guildId: string, payload: GuildShardPayload) => void;
+    /** The Bot Client's Data for Authorization */
+    client?: BotClientOptions;
+    /** QueueOptions for all Queues */
+    queueOptions?: ManagerQueueOptions;
+    /** PlayerOptions for all Players */
+    playerOptions?: ManagerPlayerOptions;
+    /** If it should skip to the next Track on TrackEnd / TrackError etc. events */
+    autoSkip?: boolean;
+    /** If it should skip to the next Track if track.resolve errors while trying to play a track. */
+    autoSkipOnResolveError?: boolean;
+    /** If it should emit only new (unique) songs and not when a looping track (or similar) is plaid, default false */
+    emitNewSongsOnly?: boolean;
+    /** Only allow link requests with links either matching some of that regExp or including some of that string */
+    linksWhitelist?: (RegExp | string)[];
+    /** Never allow link requests with links either matching some of that regExp or including some of that string (doesn't even allow if it's whitelisted) */
+    linksBlacklist?: (RegExp | string)[];
+    /** If links should be allowed or not. If set to false, it will throw an error if a link was provided. */
+    linksAllowed?: boolean;
+    /** Advanced Options for the Library, which may or may not be "library breaking" */
+    advancedOptions?: {
+        /** Max duration for that the filter fix duration works (in ms) - default is 8mins */
+        maxFilterFixDuration?: number;
+        /** optional */
+        debugOptions?: {
+            /** For logging custom searches */
+            logCustomSearches?: boolean;
+            /** logs for debugging the "no-Audio" playing error */
+            noAudio?: boolean;
+            /** For Logging the Destroy function */
+            playerDestroy?: {
+                /** To show the debug reason at all times. */
+                debugLog?: boolean;
+                /** If you get 'Error: Use Player#destroy("reason") not LavalinkManager#deletePlayer() to stop the Player' put it on true */
+                dontThrowError?: boolean;
+            };
+        };
+    };
+}

package/dist/cjs/structures/Types/Manager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });