lavalink-client 2.5.7 → 2.5.8

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

@@ -1,90 +0,0 @@
-import type { AudioOutputs, ChannelMixFilter, EQBand } from "./Types/Filters";
-export declare enum DebugEvents {
-    SetSponsorBlock = "SetSponsorBlock",
-    DeleteSponsorBlock = "DeleteSponsorBlock",
-    TrackEndReplaced = "TrackEndReplaced",
-    AutoplayExecution = "AutoplayExecution",
-    AutoplayNoSongsAdded = "AutoplayNoSongsAdded",
-    AutoplayThresholdSpamLimiter = "AutoplayThresholdSpamLimiter",
-    TriggerQueueEmptyInterval = "TriggerQueueEmptyInterval",
-    QueueEnded = "QueueEnded",
-    TrackStartNewSongsOnly = "TrackStartNewSongsOnly",
-    TrackStartNoTrack = "TrackStartNoTrack",
-    ResumingFetchingError = "ResumingFetchingError",
-    PlayerUpdateNoPlayer = "PlayerUpdateNoPlayer",
-    PlayerUpdateFilterFixApply = "PlayerUpdateFilterFixApply",
-    PlayerUpdateSuccess = "PlayerUpdateSuccess",
-    HeartBeatTriggered = "HeartBeatTriggered",
-    NoSocketOnDestroy = "NoSocketOnDestroy",
-    SocketTerminateHeartBeatTimeout = "SocketTerminateHeartBeatTimeout",
-    TryingConnectWhileConnected = "TryingConnectWhileConnected",
-    LavaSearchNothingFound = "LavaSearchNothingFound",
-    SearchNothingFound = "SearchNothingFound",
-    ValidatingBlacklistLinks = "ValidatingBlacklistLinks",
-    ValidatingWhitelistLinks = "ValidatingWhitelistLinks",
-    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
-    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime",
-    PlayerDestroyingSomewhereElse = "PlayerDestroyingSomewhereElse",
-    PlayerCreateNodeNotFound = "PlayerCreateNodeNotFound",
-    PlayerPlayQueueEmptyTimeoutClear = "PlayerPlayQueueEmptyTimeoutClear",
-    PlayerPlayWithTrackReplace = "PlayerPlayWithTrackReplace",
-    PlayerPlayUnresolvedTrack = "PlayerPlayUnresolvedTrack",
-    PlayerPlayUnresolvedTrackFailed = "PlayerPlayUnresolvedTrackFailed",
-    PlayerVolumeAsFilter = "PlayerVolumeAsFilter",
-    BandcampSearchLokalEngine = "BandcampSearchLokalEngine",
-    PlayerChangeNode = "PlayerChangeNode",
-    BuildTrackError = "BuildTrackError",
-    TransformRequesterFunctionFailed = "TransformRequesterFunctionFailed",
-    GetClosestTrackFailed = "GetClosestTrackFailed",
-    PlayerDeleteInsteadOfDestroy = "PlayerDeleteInsteadOfDestroy",
-    FailedToConnectToNodes = "FailedToConnectToNodes",
-    NoAudioDebug = "NoAudioDebug",
-    PlayerAutoReconnect = "PlayerAutoReconnect"
-}
-export declare enum DestroyReasons {
-    QueueEmpty = "QueueEmpty",
-    NodeDestroy = "NodeDestroy",
-    NodeDeleted = "NodeDeleted",
-    LavalinkNoVoice = "LavalinkNoVoice",
-    NodeReconnectFail = "NodeReconnectFail",
-    Disconnected = "Disconnected",
-    PlayerReconnectFail = "PlayerReconnectFail",
-    PlayerChangeNodeFail = "PlayerChangeNodeFail",
-    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
-    ChannelDeleted = "ChannelDeleted",
-    DisconnectAllNodes = "DisconnectAllNodes",
-    ReconnectAllNodes = "ReconnectAllNodes",
-    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>;
-export declare const EQList: {
-    /** A Bassboost Equalizer, so high it distorts the audio */
-    BassboostEarrape: EQBand[];
-    /** A High and decent Bassboost Equalizer */
-    BassboostHigh: EQBand[];
-    /** A decent Bassboost Equalizer */
-    BassboostMedium: EQBand[];
-    /** A slight Bassboost Equalizer */
-    BassboostLow: EQBand[];
-    /** Makes the Music slightly "better" */
-    BetterMusic: EQBand[];
-    /** Makes the Music sound like rock music / sound rock music better */
-    Rock: EQBand[];
-    /** Makes the Music sound like Classic music / sound Classic music better */
-    Classic: EQBand[];
-    /** Makes the Music sound like Pop music / sound Pop music better */
-    Pop: EQBand[];
-    /** Makes the Music sound like Electronic music / sound Electronic music better */
-    Electronic: EQBand[];
-    /** Boosts all Bands slightly for louder and fuller sound */
-    FullSound: EQBand[];
-    /** Boosts basses + lower highs for a pro gaming sound */
-    Gaming: EQBand[];
-};

package/dist/types/structures/CustomSearches/BandCampSearch.d.ts

@@ -1,3 +0,0 @@
-import type { Player } from "../Player";
-import type { UnresolvedSearchResult } from "../Types/Utils";
-export declare const bandCampSearch: (player: Player, query: string, requestUser: unknown) => Promise<UnresolvedSearchResult>;

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

@@ -1,169 +0,0 @@
-import type { Player } from "./Player";
-import type { AudioOutputs, EQBand, FilterData, PlayerFilters, TimescaleFilter } from "./Types/Filters";
-/**
- * The FilterManager for each player
- */
-export declare class FilterManager {
-    /** The Equalizer bands currently applied to the Lavalink Server */
-    equalizerBands: EQBand[];
-    /** Private Util for the instaFix Filters option */
-    filterUpdatedState: boolean;
-    /** All "Active" / "disabled" Player Filters */
-    filters: PlayerFilters;
-    /** The Filter Data sent to Lavalink, only if the filter is enabled (ofc.) */
-    data: FilterData;
-    /** The Player assigned to this Filter Manager */
-    player: Player;
-    /** The Constructor for the FilterManager */
-    constructor(player: Player);
-    /**
-     * Apply Player filters for lavalink filter sending data, if the filter is enabled / not
-     */
-    applyPlayerFilters(): Promise<void>;
-    /**
-     * Checks if the filters are correctly stated (active / not-active)
-     * @param oldFilterTimescale
-     * @returns
-     */
-    checkFiltersState(oldFilterTimescale?: Partial<TimescaleFilter>): boolean;
-    /**
-     * Reset all Filters
-     */
-    resetFilters(): Promise<PlayerFilters>;
-    /**
-     * Set the Filter Volume
-     * @param volume
-     * @returns
-     */
-    setVolume(volume: number): Promise<boolean>;
-    /**
-     * Set the AudioOutput Filter
-     * @param type
-     * @returns
-     */
-    setAudioOutput(type: AudioOutputs): Promise<AudioOutputs>;
-    /**
-     * Set custom filter.timescale#speed . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
-     * @param speed
-     * @returns
-     */
-    setSpeed(speed?: number): Promise<boolean>;
-    /**
-     * Set custom filter.timescale#pitch . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
-     * @param speed
-     * @returns
-     */
-    setPitch(pitch?: number): Promise<boolean>;
-    /**
-     * Set custom filter.timescale#rate . This method disabled both: nightcore & vaporwave. use 1 to reset it to normal
-     * @param speed
-     * @returns
-     */
-    setRate(rate?: number): Promise<boolean>;
-    /**
-     * Enables / Disables the rotation effect, (Optional: provide your Own Data)
-     * @param rotationHz
-     * @returns
-     */
-    toggleRotation(rotationHz?: number): Promise<boolean>;
-    /**
-     * Enables / Disables the Vibrato effect, (Optional: provide your Own Data)
-     * @param frequency
-     * @param depth
-     * @returns
-     */
-    toggleVibrato(frequency?: number, depth?: number): Promise<boolean>;
-    /**
-     * Enables / Disables the Tremolo effect, (Optional: provide your Own Data)
-     * @param frequency
-     * @param depth
-     * @returns
-     */
-    toggleTremolo(frequency?: number, depth?: number): Promise<boolean>;
-    /**
-     * Enables / Disables the LowPass effect, (Optional: provide your Own Data)
-     * @param smoothing
-     * @returns
-     */
-    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: {
-        /**
-         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
-         * @param delay
-         * @param decay
-         * @returns
-         */
-        toggleEcho: (delay?: number, decay?: number) => Promise<boolean>;
-        /**
-         * Enables / Disables the Echo effect, IMPORTANT! Only works with the correct Lavalink Plugin installed. (Optional: provide your Own Data)
-         * @param delays
-         * @param gains
-         * @returns
-         */
-        toggleReverb: (delays?: number[], gains?: number[]) => Promise<boolean>;
-    };
-    /**
-     * Enables / Disables a Nightcore-like filter Effect. Disables/Overrides both: custom and Vaporwave Filter
-     * @param speed
-     * @param pitch
-     * @param rate
-     * @returns
-     */
-    toggleNightcore(speed?: number, pitch?: number, rate?: number): Promise<boolean>;
-    /**
-     * Enables / Disables a Vaporwave-like filter Effect. Disables/Overrides both: custom and nightcore Filter
-     * @param speed
-     * @param pitch
-     * @param rate
-     * @returns
-     */
-    toggleVaporwave(speed?: number, pitch?: number, rate?: number): Promise<boolean>;
-    /**
-     * Enable / Disables a Karaoke like Filter Effect
-     * @param level
-     * @param monoLevel
-     * @param filterBand
-     * @param filterWidth
-     * @returns
-     */
-    toggleKaraoke(level?: number, monoLevel?: number, filterBand?: number, filterWidth?: number): Promise<boolean>;
-    /** Function to find out if currently there is a custom timescamle etc. filter applied */
-    isCustomFilterActive(): boolean;
-    /**
-   * Sets the players equalizer band on-top of the existing ones.
-   * @param bands
-   */
-    setEQ(bands: EQBand | EQBand[]): Promise<this>;
-    /** Clears the equalizer bands. */
-    clearEQ(): Promise<this>;
-}

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

@@ -1,232 +0,0 @@
-import { EventEmitter } from "events";
-import { NodeManager } from "./NodeManager";
-import { Player } from "./Player";
-import { ManagerUtils, MiniMap } from "./Utils";
-import type { ChannelDeletePacket, VoicePacket, VoiceServer, VoiceState } from "./Types/Utils";
-import type { BotClientOptions, LavalinkManagerEvents, ManagerOptions } from "./Types/Manager";
-import type { PlayerOptions } from "./Types/Player";
-export declare class LavalinkManager extends EventEmitter {
-    /**
-     * Emit an event
-     * @param event The event to emit
-     * @param args The arguments to pass to the event
-     * @returns
-     */
-    emit<Event extends keyof LavalinkManagerEvents>(event: Event, ...args: Parameters<LavalinkManagerEvents[Event]>): boolean;
-    /**
-     * Add an event listener
-     * @param event The event to listen to
-     * @param listener The listener to add
-     * @returns
-     */
-    on<Event extends keyof LavalinkManagerEvents>(event: Event, listener: LavalinkManagerEvents[Event]): this;
-    /**
-     * Add an event listener that only fires once
-     * @param event The event to listen to
-     * @param listener The listener to add
-     * @returns
-     */
-    once<Event extends keyof LavalinkManagerEvents>(event: Event, listener: LavalinkManagerEvents[Event]): this;
-    /**
-     * Remove an event listener
-     * @param event The event to remove the listener from
-     * @param listener The listener to remove
-     * @returns
-     */
-    off<Event extends keyof LavalinkManagerEvents>(event: Event, listener: LavalinkManagerEvents[Event]): this;
-    /**
-     * Remove an event listener
-     * @param event The event to remove the listener from
-     * @param listener The listener to remove
-     * @returns
-     */
-    removeListener<Event extends keyof LavalinkManagerEvents>(event: Event, listener: LavalinkManagerEvents[Event]): this;
-    /** The Options of LavalinkManager (changeable) */
-    options: ManagerOptions;
-    /** LavalinkManager's NodeManager to manage all Nodes */
-    nodeManager: NodeManager;
-    /** LavalinkManager's Utils Class */
-    utils: ManagerUtils;
-    /** Wether the manager was initiated or not */
-    initiated: boolean;
-    /** All Players stored in a MiniMap */
-    readonly players: MiniMap<string, Player>;
-    /**
-     * Applies the options provided by the User
-     * @param options
-     * @returns
-     */
-    private applyOptions;
-    /**
-     * Validates the current manager's options
-     * @param options
-     */
-    private validateOptions;
-    /**
-     * Create the Lavalink Manager
-     * @param options
-     *
-     * @example
-     * ```ts
-     * //const client = new Client({...}); // create your BOT Client (e.g. via discord.js)
-     * client.lavalink = new LavalinkManager({
-     *   nodes: [
-     *     {
-     *       authorization: "yourverystrongpassword",
-     *       host: "localhost",
-     *       port: 2333,
-     *       id: "testnode"
-     *     },
-     *     sendToShard(guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
-     *     client: {
-     *       id: process.env.CLIENT_ID,
-     *       username: "TESTBOT"
-     *     },
-     *     // optional Options:
-     *     autoSkip: true,
-     *     playerOptions: {
-     *       applyVolumeAsFilter: false,
-     *       clientBasedPositionUpdateInterval: 150,
-     *       defaultSearchPlatform: "ytmsearch",
-     *       volumeDecrementer: 0.75,
-     *       //requesterTransformer: YourRequesterTransformerFunction,
-     *       onDisconnect: {
-     *         autoReconnect: true,
-     *         destroyPlayer: false
-     *       },
-     *       onEmptyQueue: {
-     *         destroyAfterMs: 30_000,
-     *         //autoPlayFunction: YourAutoplayFunction,
-     *       },
-     *       useUnresolvedData: true
-     *     },
-     *     queueOptions: {
-     *       maxPreviousTracks: 25,
-     *       //queueStore: yourCustomQueueStoreManagerClass,
-     *       //queueChangesWatcher: yourCustomQueueChangesWatcherClass
-     *     },
-     *     linksBlacklist: [],
-     *     linksWhitelist: [],
-     *     advancedOptions: {
-     *       maxFilterFixDuration: 600_000,
-     *       debugOptions: {
-     *         noAudio: false,
-     *         playerDestroy: {
-     *           dontThrowError: false,
-     *           debugLogs: false
-     *         }
-     *       }
-     *     }
-     *   ]
-     * })
-     * ```
-     */
-    constructor(options: ManagerOptions);
-    /**
-     * Get a Player from Lava
-     * @param guildId The guildId of the player
-     *
-     * @example
-     * ```ts
-     * const player = client.lavalink.getPlayer(interaction.guildId);
-     * ```
-     * A quicker and easier way than doing:
-     * ```ts
-     * const player = client.lavalink.players.get(interaction.guildId);
-     * ```
-     * @returns
-     */
-    getPlayer(guildId: string): Player | undefined;
-    /**
-     * Create a Music-Player. If a player exists, then it returns it before creating a new one
-     * @param options
-     * @returns
-     *
-     * @example
-     * ```ts
-     * const player = client.lavalink.createPlayer({
-     *   guildId: interaction.guildId,
-     *   voiceChannelId: interaction.member.voice.channelId,
-     *   // everything below is optional
-     *   textChannelId: interaction.channelId,
-     *   volume: 100,
-     *   selfDeaf: true,
-     *   selfMute: false,
-     *   instaUpdateFiltersFix: true,
-     *   applyVolumeAsFilter: false
-     *   //only needed if you want to autopick node by region (configured by you)
-     *   // vcRegion: interaction.member.voice.rtcRegion,
-     *   // provide a specific node
-     *   // node: client.lavalink.nodeManager.leastUsedNodes("memory")[0]
-     * });
-     * ```
-     */
-    createPlayer(options: PlayerOptions): Player;
-    /**
-     * Destroy a player with optional destroy reason and disconnect it from the voice channel
-     * @param guildId
-     * @param destroyReason
-     * @returns
-     *
-     * @example
-     * ```ts
-     * client.lavalink.destroyPlayer(interaction.guildId, "forcefully destroyed the player");
-     * // recommend to do it on the player tho: player.destroy("forcefully destroyed the 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
-     * @returns
-     *
-     * @example
-     * ```ts
-     * client.lavalink.deletePlayer(interaction.guildId);
-     * // shouldn't be used except you know what you are doing.
-     * ```
-     */
-    deletePlayer(guildId: string): boolean | void;
-    /**
-     * Checks wether the the lib is useable based on if any node is connected
-     *
-     * @example
-     * ```ts
-     * if(!client.lavalink.useable) return console.error("can'T search yet, because there is no useable lavalink node.")
-     * // continue with code e.g. createing a player and searching
-     * ```
-     */
-    get useable(): boolean;
-    /**
-     * Initiates the Manager, creates all nodes and connects all of them
-     * @param clientData
-     *
-     * @example
-     * ```ts
-     * // on the bot ready event
-     * client.on("ready", () => {
-     *   client.lavalink.init({
-     *     id: client.user.id,
-     *     username: client.user.username
-     *   });
-     * });
-     * ```
-     */
-    init(clientData: BotClientOptions): Promise<LavalinkManager>;
-    /**
-     * Sends voice data to the Lavalink server.
-     * ! Without this the library won't work
-     * @param data
-     *
-     * @example
-     *
-     * ```ts
-     * // on the bot "raw" event
-     * client.on("raw", (d) => {
-     *   // required in order to send audio updates and register channel deletion etc.
-     *   client.lavalink.sendRawData(d)
-     * })
-     * ```
-     */
-    sendRawData(data: VoicePacket | VoiceServer | VoiceState | ChannelDeletePacket): Promise<void>;
-}

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

@@ -1,15 +0,0 @@
-import type { ClientCustomSearchPlatformUtils, LavalinkSearchPlatform, SearchPlatform, SourcesRegex } from "./Types/Utils";
-/** Default Sources Record, to allow source parsing with multiple inputs. */
-export declare const DefaultSources: Record<SearchPlatform, LavalinkSearchPlatform | ClientCustomSearchPlatformUtils>;
-/** Lavalink Plugins definiton */
-export declare const LavalinkPlugins: {
-    DuncteBot_Plugin: string;
-    LavaSrc: string;
-    GoogleCloudTTS: string;
-    LavaSearch: string;
-    Jiosaavn_Plugin: string;
-    LavalinkFilterPlugin: string;
-    JavaTimedLyricsPlugin: string;
-};
-/** Lavalink Sources regexes for url validations */
-export declare const SourceLinksRegexes: Record<SourcesRegex, RegExp>;