lavalink-client 2.2.2 → 2.3.0

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

@@ -1,68 +1,56 @@
 /// <reference types="node" />
 import { EventEmitter } from "stream";
-import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode, LavalinkNodeOptions } from "./Node";
-import { DestroyReasonsType } from "./Player";
-import { LavalinkPlayer, MiniMap } from "./Utils";
-type LavalinkNodeIdentifier = string;
-export interface NodeManagerEvents {
+import { LavalinkNode } from "./Node";
+import { MiniMap } from "./Utils";
+import type { LavalinkNodeIdentifier, LavalinkNodeOptions, NodeManagerEvents } from "./Types/Node";
+import type { LavalinkManager } from "./LavalinkManager";
+export declare class NodeManager extends EventEmitter {
     /**
-     * Emitted when a Node is created.
-     * @event Manager.nodeManager#create
+     * Emit an event
+     * @param event The event to emit
+     * @param args The arguments to pass to the event
+     * @returns
      */
-    "create": (node: LavalinkNode) => void;
+    emit<Event extends keyof NodeManagerEvents>(event: Event, ...args: Parameters<NodeManagerEvents[Event]>): boolean;
     /**
-     * Emitted when a Node is destroyed.
-     * @event Manager.nodeManager#destroy
+     * Add an event listener
+     * @param event The event to listen to
+     * @param listener The listener to add
+     * @returns
      */
-    "destroy": (node: LavalinkNode, destroyReason?: DestroyReasonsType) => void;
+    on<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emitted when a Node is connected.
-     * @event Manager.nodeManager#connect
+     * Add an event listener that only fires once
+     * @param event The event to listen to
+     * @param listener The listener to add
+     * @returns
      */
-    "connect": (node: LavalinkNode) => void;
-    /**
-     * Emitted when a Node is reconnecting.
-     * @event Manager.nodeManager#reconnecting
-    */
-    "reconnecting": (node: LavalinkNode) => void;
-    /**
-     * Emitted when a Node is disconnects.
-     * @event Manager.nodeManager#disconnect
-    */
-    "disconnect": (node: LavalinkNode, reason: {
-        code?: number;
-        reason?: string;
-    }) => void;
+    once<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emitted when a Node is error.
-     * @event Manager.nodeManager#error
-    */
-    "error": (node: LavalinkNode, error: Error, payload?: unknown) => void;
+     * Remove an event listener
+     * @param event The event to remove the listener from
+     * @param listener The listener to remove
+     * @returns
+     */
+    off<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emits every single Node event.
-     * @event Manager.nodeManager#raw
-    */
-    "raw": (node: LavalinkNode, payload: unknown) => void;
+     * Remove an event listener
+     * @param event The event to remove the listener from
+     * @param listener The listener to remove
+     * @returns
+     */
+    removeListener<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emits when the node connects resumed. You then need to create all players within this event for your usecase.
-     * Aka for that you need to be able to save player data like vc channel + text channel in a db and then sync it again
-     * @event Manager.nodeManager#nodeResumed
+     * The LavalinkManager that created this NodeManager
      */
-    "resumed": (node: LavalinkNode, paylaod: {
-        resumed: true;
-        sessionId: string;
-        op: "ready";
-    }, players: LavalinkPlayer[]) => void;
-}
-export declare interface NodeManager {
-    on<U extends keyof NodeManagerEvents>(event: U, listener: NodeManagerEvents[U]): this;
-    emit<U extends keyof NodeManagerEvents>(event: U, ...args: Parameters<NodeManagerEvents[U]>): boolean;
-    /** @private */
     LavalinkManager: LavalinkManager;
-}
-export declare class NodeManager extends EventEmitter {
+    /**
+     * A map of all nodes in the nodeManager
+     */
     nodes: MiniMap<string, LavalinkNode>;
+    /**
+     * @param LavalinkManager The LavalinkManager that created this NodeManager
+     */
     constructor(LavalinkManager: LavalinkManager);
     /**
      * Disconnects all Nodes from lavalink ws sockets
@@ -80,8 +68,22 @@ export declare class NodeManager extends EventEmitter {
      * @returns amount of nodes
      */
     reconnectAll(): Promise<number>;
+    /**
+     * Create a node and add it to the nodeManager
+     * @param options The options for the node
+     * @returns The node that was created
+     */
     createNode(options: LavalinkNodeOptions): LavalinkNode;
+    /**
+     * Get the nodes sorted for the least usage, by a sorttype
+     * @param sortType The type of sorting to use
+     * @returns
+     */
     leastUsedNodes(sortType?: "memory" | "cpuLavalink" | "cpuSystem" | "calls" | "playingPlayers" | "players"): LavalinkNode[];
+    /**
+     * Delete a node from the nodeManager and destroy it
+     * @param node The node to delete
+     * @returns
+     */
     deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
 }
-export {};

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

@@ -1,123 +1,12 @@
-import { EQBand, FilterData, FilterManager, LavalinkFilterData } from "./Filters";
-import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode, SponsorBlockSegment } from "./Node";
+import { FilterManager } from "./Filters";
 import { Queue } from "./Queue";
-import { Track, UnresolvedTrack } from "./Track";
-import { Base64, LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Utils";
-export declare enum DestroyReasons {
-    QueueEmpty = "QueueEmpty",
-    NodeDestroy = "NodeDestroy",
-    NodeDeleted = "NodeDeleted",
-    LavalinkNoVoice = "LavalinkNoVoice",
-    NodeReconnectFail = "NodeReconnectFail",
-    Disconnected = "Disconnected",
-    PlayerReconnectFail = "PlayerReconnectFail",
-    ChannelDeleted = "ChannelDeleted",
-    DisconnectAllNodes = "DisconnectAllNodes",
-    ReconnectAllNodes = "ReconnectAllNodes"
-}
-export type DestroyReasonsType = keyof typeof DestroyReasons | string;
-export interface PlayerJson {
-    /** Guild Id where the player was playing in */
-    guildId: string;
-    /** Options provided to the player */
-    options: PlayerOptions;
-    /** Voice Channel Id the player was playing in */
-    voiceChannelId: string;
-    /** Text Channel Id the player was synced to */
-    textChannelId?: string;
-    /** Position the player was at */
-    position: number;
-    /** Lavalink's position the player was at */
-    lastPosition: number;
-    /** Last time the position was sent from lavalink */
-    lastPositionChange: number;
-    /** Volume in % from the player (without volumeDecrementer) */
-    volume: number;
-    /** Real Volume used in lavalink (with the volumeDecrementer) */
-    lavalinkVolume: number;
-    /** The repeatmode from the player */
-    repeatMode: RepeatMode;
-    /** Pause state */
-    paused: boolean;
-    /** Wether the player was playing or not */
-    playing: boolean;
-    /** When the player was created */
-    createdTimeStamp?: number;
-    /** All current used fitlers Data */
-    filters: FilterData;
-    /** The player's ping object */
-    ping: {
-        /** Ping to the voice websocket server */
-        ws: number;
-        /** Avg. calc. Ping to the lavalink server */
-        lavalink: number;
-    };
-    /** Equalizer Bands used in lavalink */
-    equalizer: EQBand[];
-    /** The Id of the last used node */
-    nodeId?: string;
-}
-export type RepeatMode = "queue" | "track" | "off";
-export interface PlayerOptions {
-    /** Guild id of the player */
-    guildId: string;
-    /** The Voice Channel Id */
-    voiceChannelId: string;
-    /** The Text Channel Id of the Player */
-    textChannelId?: string;
-    /** instantly change volume with the one play request */
-    volume?: number;
-    /** VC Region for node selections */
-    vcRegion?: string;
-    /** if it should join deafened */
-    selfDeaf?: boolean;
-    /** If it should join muted */
-    selfMute?: boolean;
-    /** If it should use a specific lavalink node */
-    node?: LavalinkNode | string;
-    /** If when applying filters, it should use the insta apply filters fix  */
-    instaUpdateFiltersFix?: boolean;
-    /** If a volume should be applied via filters instead of lavalink-volume */
-    applyVolumeAsFilter?: boolean;
-}
-export type anyObject = {
-    [key: string | number]: string | number | null | anyObject;
-};
-export interface BasePlayOptions {
-    /** The position to start the track. */
-    position?: number;
-    /** The position to end the track. */
-    endTime?: number;
-    /** If to start "paused" */
-    paused?: boolean;
-    /** The Volume to start with */
-    volume?: number;
-    /** The Lavalink Filters to use | only with the new REST API */
-    filters?: Partial<LavalinkFilterData>;
-    /** Voice Update for Lavalink */
-    voice?: LavalinkPlayerVoiceOptions;
-}
-export interface LavalinkPlayOptions extends BasePlayOptions {
-    /** Which Track to play | don't provide, if it should pick from the Queue */
-    track?: {
-        /** The track encoded base64 string to use instead of the one from the queue system */
-        encoded?: Base64 | null;
-        /** The identifier of the track to use */
-        identifier?: string;
-        /** Custom User Data for the track to provide, will then be on the userData object from the track */
-        userData?: anyObject;
-        /** The Track requester for when u provide encodedTrack / identifer */
-        requester?: unknown;
-    };
-}
-export interface PlayOptions extends LavalinkPlayOptions {
-    /** Whether to not replace the track if a play payload is sent. */
-    noReplace?: boolean;
-    /** Adds track on queue and skips to it */
-    clientTrack?: Track | UnresolvedTrack;
-}
-export interface Player {
+import type { DestroyReasons } from "./Constants";
+import type { LavalinkNode } from "./Node";
+import type { SponsorBlockSegment } from "./Types/Node";
+import type { PlayerJson, PlayerOptions, PlayOptions, RepeatMode } from "./Types/Player";
+import type { LavalinkManager } from "./LavalinkManager";
+import type { LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Types/Utils";
+export declare class Player {
     /** Filter Manager per player */
     filterManager: FilterManager;
     /** circular reference to the lavalink Manager from the Player for easier use */
@@ -128,8 +17,6 @@ export interface Player {
     node: LavalinkNode;
     /** The queue from the player */
     queue: Queue;
-}
-export declare class Player {
     /** The Guild Id of the Player */
     guildId: string;
     /** The Voice Channel Id of the Player */
@@ -157,12 +44,14 @@ export declare class Player {
     lastPositionChange: number;
     /** The current Positin of the player (from Lavalink) */
     lastPosition: number;
+    lastSavedPosition: number;
     /** When the player was created [Timestamp in Ms] (from lavalink) */
     createdTimeStamp: number;
     /** The Player Connection's State (from Lavalink) */
     connected: boolean | undefined;
     /** Voice Server Data (from Lavalink) */
     voice: LavalinkPlayerVoiceOptions;
+    /** Custom data for the player */
     private readonly data;
     /**
      * Create a new Player
@@ -200,16 +89,33 @@ export declare class Player {
      * @param ignoreVolumeDecrementer If it should ignore the volumedecrementer option
      */
     setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
-    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Utils").SearchResult | import("./Utils").LavaSearchResponse>;
+    /**
+     * Search for a track
+     * @param query The query to search for
+     * @param requestUser The user that requested the track
+     * @param throwOnEmpty If an error should be thrown if no track is found
+     * @returns The search result
+     */
+    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils").SearchResult | import("./Types/Utils").LavaSearchResponse>;
+    /**
+     * Set the SponsorBlock
+     * @param segments The segments to set
+     */
     setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    /**
+     * Get the SponsorBlock
+     */
     getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    /**
+     * Delete the SponsorBlock
+     */
     deleteSponsorBlock(): Promise<void>;
     /**
      *
      * @param query Query for your data
      * @param requestUser
      */
-    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Utils").SearchResult | import("./Utils").UnresolvedSearchResult>;
+    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils").UnresolvedSearchResult | import("./Types/Utils").SearchResult>;
     /**
      * Pause the player
      */
@@ -228,11 +134,12 @@ export declare class Player {
      * @param repeatMode
      */
     setRepeatMode(repeatMode: RepeatMode): Promise<this>;
+    1: any;
     /**
      * Skip the current song, or a specific amount of songs
      * @param amount provide the index of the next track to skip to
      */
-    skip(skipTo?: number, throwError?: boolean): any;
+    skip(skipTo?: number, throwError?: boolean): Promise<this>;
     /**
      * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
      * @returns

package/dist/types/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/types/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[];
+}