lavalink-client 2.5.7 → 2.5.8

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

@@ -1,223 +0,0 @@
-import { FilterManager } from "./Filters";
-import { Queue } from "./Queue";
-import type { DestroyReasons } from "./Constants";
-import type { Track } from "./Types/Track";
-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 */
-    LavalinkManager: LavalinkManager;
-    /** Player options currently used, mutation doesn't affect player's state */
-    options: PlayerOptions;
-    /** The lavalink node assigned the the player, don't change it manually */
-    node: LavalinkNode;
-    /** The queue from the player */
-    queue: Queue;
-    /** The Guild Id of the Player */
-    guildId: string;
-    /** The Voice Channel Id of the Player */
-    voiceChannelId: string | null;
-    /** The Text Channel Id of the Player */
-    textChannelId: string | null;
-    /** States if the Bot is supposed to be outputting audio */
-    playing: boolean;
-    /** States if the Bot is paused or not */
-    paused: boolean;
-    /** Repeat Mode of the Player */
-    repeatMode: RepeatMode;
-    /** Player's ping */
-    ping: {
-        lavalink: number;
-        ws: number;
-    };
-    /** The Display Volume */
-    volume: number;
-    /** The Volume Lavalink actually is outputting */
-    lavalinkVolume: number;
-    /** The current Positin of the player (Calculated) */
-    get position(): number;
-    /** The timestamp when the last position change update happened */
-    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;
-    voiceState: {
-        selfDeaf: boolean;
-        selfMute: boolean;
-        serverDeaf: boolean;
-        serverMute: boolean;
-        suppress: boolean;
-    };
-    /** Custom data for the player */
-    private readonly data;
-    /**
-     * Create a new Player
-     * @param options
-     * @param LavalinkManager
-     */
-    constructor(options: PlayerOptions, LavalinkManager: LavalinkManager, dontEmitPlayerCreateEvent?: boolean);
-    /**
-     * Set custom data.
-     * @param key
-     * @param value
-     */
-    set(key: string, value: unknown): this;
-    /**
-     * Get custom data.
-     * @param key
-     */
-    get<T>(key: string): T;
-    /**
-     * CLears all the custom data.
-     */
-    clearData(): this;
-    /**
-     * Get all custom Data
-     */
-    getAllData(): Record<string, unknown>;
-    /**
-     * Play the next track from the queue / a specific track, with playoptions for Lavalink
-     * @param options
-     */
-    play(options?: Partial<PlayOptions>): any;
-    /**
-     * Set the Volume for the Player
-     * @param volume The Volume in percent
-     * @param ignoreVolumeDecrementer If it should ignore the volumedecrementer option
-     */
-    setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
-    /**
-     * 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").LavaSearchResponse | import("./Types/Utils").SearchResult>;
-    /**
-     * 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("./Types/Utils").UnresolvedSearchResult | import("./Types/Utils").SearchResult>;
-    /**
-     * Pause the player
-     */
-    pause(): Promise<this>;
-    /**
-     * Resume the Player
-     */
-    resume(): Promise<this>;
-    /**
-     * Seek to a specific Position
-     * @param position
-     */
-    seek(position: number): Promise<this>;
-    /**
-     * Set the Repeatmode of the Player
-     * @param repeatMode
-     */
-    setRepeatMode(repeatMode: RepeatMode): Promise<this>;
-    /**
-     * 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): Promise<this>;
-    /**
-     * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
-     * @returns
-     */
-    stopPlaying(clearQueue?: boolean, executeAutoplay?: boolean): Promise<this>;
-    /**
-     * Connects the Player to the Voice Channel
-     * @returns
-     */
-    connect(): Promise<this>;
-    changeVoiceState(data: {
-        voiceChannelId?: string;
-        selfDeaf?: boolean;
-        selfMute?: boolean;
-    }): Promise<this>;
-    /**
-     * Disconnects the Player from the Voice Channel, but keeps the player in the cache
-     * @param force If false it throws an error, if player thinks it's already disconnected
-     * @returns
-     */
-    disconnect(force?: boolean): Promise<this>;
-    /**
-     * Destroy the player and disconnect from the voice channel
-     */
-    destroy(reason?: DestroyReasons | string, disconnect?: boolean): Promise<this>;
-    /**
-     * Get the current lyrics of the track currently playing on the guild
-     * @param guildId The guild id to get the current lyrics for
-     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
-     * @returns The current lyrics
-     * @example
-     * ```ts
-     * const lyrics = await player.getCurrentLyrics();
-     * ```
-     */
-    getCurrentLyrics(skipTrackSource?: boolean): Promise<import("./Types/Node").LyricsResult>;
-    /**
-     * Get the lyrics of a specific track
-     * @param track The track to get the lyrics for
-     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
-     * @returns The lyrics of the track
-     * @example
-     * ```ts
-     * const lyrics = await player.getLyrics(player.queue.tracks[0], true);
-     * ```
-     */
-    getLyrics(track: Track, skipTrackSource?: boolean): Promise<import("./Types/Node").LyricsResult>;
-    /**
-     * Subscribe to the lyrics event on a specific guild to active live lyrics events
-     * @returns The unsubscribe function
-     * @example
-     * ```ts
-     * const lyrics = await player.subscribeLyrics();
-     * ```
-     */
-    subscribeLyrics(): Promise<unknown>;
-    /**
-     * Unsubscribe from the lyrics event on a specific guild to disable live lyrics events
-     * @returns The unsubscribe function
-     * @example
-     * ```ts
-     * const lyrics = await player.unsubscribeLyrics();
-     * ```
-     */
-    unsubscribeLyrics(): Promise<void>;
-    /**
-     * Move the player on a different Audio-Node
-     * @param newNode New Node / New Node Id
-     * @param checkSources If it should check if the sources are supported by the new node
-     */
-    changeNode(newNode: LavalinkNode | string, checkSources?: boolean): Promise<string>;
-    /** Converts the Player including Queue to a Json state */
-    toJSON(): PlayerJson;
-}

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

@@ -1,186 +0,0 @@
-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;
-    };
-    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<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<boolean | void>;
-    /**
-     * 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: string): 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: string, valueToStringify: any): boolean;
-    /**
-     * Delete the queue for a guild
-     * @param guildId The guild ID
-     * @returns The queue for the guild
-     */
-    delete(guildId: string): boolean;
-    /**
-     * Stringify the queue for a guild
-     * @param value The queue to stringify
-     * @returns The stringified queue
-     */
-    stringify(value: StoredQueue | string): StoredQueue | string;
-    /**
-     * Parse the queue for a guild
-     * @param value The queue to parse
-     * @returns The parsed queue
-     */
-    parse(value: StoredQueue | string): Partial<StoredQueue>;
-}
-export declare class Queue {
-    readonly tracks: (Track | UnresolvedTrack)[];
-    readonly previous: Track[];
-    current: Track | null;
-    options: {
-        maxPreviousTracks: number;
-    };
-    private readonly guildId;
-    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
-     */
-    utils: {
-        /**
-         * Save the current cached Queue on the database/server (overides the server)
-         */
-        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<boolean | void>;
-        /**
-         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
-         */
-        toJSON: () => StoredQueue;
-        /**
-         * Get the Total Duration of the Queue-Songs summed up
-         * @returns {number}
-         */
-        totalDuration: () => number;
-    };
-    /**
-     * Shuffles the current Queue, then saves it
-     * @returns Amount of Tracks in the Queue
-     */
-    shuffle(): Promise<number>;
-    /**
-     * Add a Track to the Queue, and after saved in the "db" it returns the amount of the Tracks
-     * @param {Track | Track[]} TrackOrTracks
-     * @param {number} index At what position to add the Track
-     * @returns {number} Queue-Size (for the next Tracks)
-     */
-    add(TrackOrTracks: Track | UnresolvedTrack | (Track | UnresolvedTrack)[], index?: number): any;
-    /**
-     * Splice the tracks in the Queue
-     * @param {number} index Where to remove the Track
-     * @param {number} amount How many Tracks to remove?
-     * @param {Track | Track[]} TrackOrTracks Want to Add more Tracks?
-     * @returns {Track} Spliced Track
-     */
-    splice(index: number, amount: number, TrackOrTracks?: Track | UnresolvedTrack | (Track | UnresolvedTrack)[]): any;
-    /**
-     * Remove stuff from the queue.tracks array
-     *  - single Track | UnresolvedTrack
-     *  - multiple Track | UnresovedTrack
-     *  - at the index or multiple indexes
-     * @param removeQueryTrack
-     * @returns null (if nothing was removed) / { removed } where removed is an array with all removed elements
-     *
-     * @example
-     * ```js
-     * // remove single track
-     *
-     * const track = player.queue.tracks[4];
-     * await player.queue.remove(track);
-     *
-     * // if you already have the index you can straight up pass it too
-     * await player.queue.remove(4);
-     *
-     *
-     * // if you want to remove multiple tracks, e.g. from position 4 to position 10 you can do smt like this
-     * await player.queue.remove(player.queue.tracks.slice(4, 10)) // get's the tracks from 4 - 10, which then get's found in the remove function to be removed
-     *
-     * // I still highly suggest to use .splice!
-     *
-     * await player.queue.splice(4, 10); // removes at index 4, 10 tracks
-     *
-     * await player.queue.splice(1, 1); // removes at index 1, 1 track
-     *
-     * await player.queue.splice(4, 0, ...tracks) // removes 0 tracks at position 4, and then inserts all tracks after position 4.
-     * ```
-     */
-    remove<T extends Track | UnresolvedTrack | number | Track[] | UnresolvedTrack[] | number[] | (number | Track | UnresolvedTrack)[]>(removeQueryTrack: T): Promise<{
-        removed: (Track | UnresolvedTrack)[];
-    } | null>;
-    /**
-     * Shifts the previous array, to return the last previous track & thus remove it from the previous queue
-     * @returns
-     *
-     * @example
-     * ```js
-     * // example on how to play the previous track again
-     * const previous = await player.queue.shiftPrevious(); // get the previous track and remove it from the previous queue array!!
-     * if(!previous) return console.error("No previous track found");
-     * await player.play({ clientTrack: previous }); // play it again
-     * ```
-     */
-    shiftPrevious(): Promise<Track>;
-}

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

@@ -1,190 +0,0 @@
-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[];
-}