lavalink-client 1.0.0 → 1.0.2

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

@@ -0,0 +1,191 @@
+import { FilterManager, LavalinkFilterData } from "./Filters";
+import { LavalinkManager } from "./LavalinkManager";
+import { LavalinkNode } from "./Node";
+import { Queue } from "./Queue";
+import { Track } from "./Track";
+import { LavalinkPlayerVoiceOptions, SearchPlatform, SearchResult } from "./Utils";
+type PlayerDestroyReasons = "QueueEmpty" | "NodeDestroy" | "NodeDeleted" | "LavalinkNoVoice" | "NodeReconnectFail" | "PlayerReconnectFail" | "Disconnected" | "ChannelDeleted";
+export type DestroyReasonsType = PlayerDestroyReasons | string;
+export declare const DestroyReasons: Record<PlayerDestroyReasons, PlayerDestroyReasons>;
+export type RepeatMode = "queue" | "track" | "off";
+export interface PlayerOptions {
+    guildId: string;
+    voiceChannelId: string;
+    volume?: number;
+    vcRegion?: string;
+    selfDeaf?: boolean;
+    selfMute?: boolean;
+    textChannelId?: string;
+    node?: LavalinkNode | string;
+    instaUpdateFiltersFix?: boolean;
+    applyVolumeAsFilter?: boolean;
+}
+export interface PlayOptions {
+    /** Which Track to play | don't provide, if it should pick from the Queue */
+    track?: Track;
+    /** Encoded Track to use, instead of the queue system... */
+    encodedTrack?: string | null;
+    /** Encoded Track to use&search, instead of the queue system (yt only)... */
+    identifier?: string;
+    /** The position to start the track. */
+    position?: number;
+    /** The position to end the track. */
+    endTime?: number;
+    /** Whether to not replace the track if a play payload is sent. */
+    noReplace?: boolean;
+    /** 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?: LavalinkPlayerVoiceOptions;
+}
+export interface Player {
+    filterManager: FilterManager;
+    LavalinkManager: LavalinkManager;
+    options: PlayerOptions;
+    node: LavalinkNode;
+    queue: Queue;
+}
+export declare class Player {
+    /** 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) */
+    position: number;
+    /** The current Positin of the player (from Lavalink) */
+    lastPosition: 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;
+    private readonly data;
+    /**
+     * Create a new Player
+     * @param options
+     * @param LavalinkManager
+     */
+    constructor(options: PlayerOptions, LavalinkManager: LavalinkManager);
+    /**
+     * Set custom data.
+     * @param key
+     * @param value
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Get custom data.
+     * @param key
+     */
+    get<T>(key: string): T;
+    /**
+     * CLears all the custom data.
+     */
+    clearData(): void;
+    /**
+     * 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>): Promise<void>;
+    /**
+     * 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<void>;
+    /**
+     *
+     * @param query Query for your data
+     * @param requestUser
+     */
+    search(query: {
+        query: string;
+        source?: SearchPlatform;
+    } | string, requestUser: unknown): Promise<SearchResult>;
+    /**
+     * Pause the player
+     */
+    pause(): Promise<void>;
+    /**
+     * Resume the Player
+     */
+    resume(): Promise<void>;
+    /**
+     * Seek to a specific Position
+     * @param position
+     */
+    seek(position: number): Promise<any>;
+    /**
+     * Set the Repeatmode of the Player
+     * @param repeatMode
+     */
+    setRepeatMode(repeatMode: RepeatMode): Promise<void>;
+    /**
+     * 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): Promise<true | void>;
+    /**
+     * Connects the Player to the Voice Channel
+     * @returns
+     */
+    connect(): Promise<void>;
+    /**
+     * 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<void>;
+    /**
+     * Destroy the player and disconnect from the voice channel
+     */
+    destroy(reason?: string): Promise<void>;
+    /**
+     * Move the player on a different Audio-Node
+     * @param newNode New Node / New Node Id
+     */
+    changeNode(newNode: LavalinkNode | string): Promise<string>;
+    /** Converts the Player including Queue to a Json state */
+    toJSON(): {
+        guildId: string;
+        voiceChannelId: string;
+        textChannelId: string;
+        position: number;
+        lastPosition: number;
+        volume: number;
+        lavalinkVolume: number;
+        repeatMode: RepeatMode;
+        paused: boolean;
+        playing: boolean;
+        createdTimeStamp: number;
+        filters: {};
+        equalizer: import("./Filters").EQBand[];
+        queue: import("./Queue").StoredQueue;
+        nodeId: string;
+    };
+}
+export {};

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

@@ -0,0 +1,107 @@
+import { Track } from "./Track";
+export interface StoredQueue {
+    current: Track | null;
+    previous: Track[];
+    tracks: Track[];
+}
+export interface StoreManager extends Record<any, any> {
+    /** @async get a Value (MUST RETURN UNPARSED!) */
+    get: (guildId: unknown) => Promise<any>;
+    /** @async Set a value inside a guildId (MUST BE UNPARSED) */
+    set: (guildId: unknown, value: unknown) => Promise<any>;
+    /** @async Delete a Database Value based of it's guildId */
+    delete: (guildId: unknown) => Promise<any>;
+    /** @async Transform the value(s) inside of the StoreManager (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
+    stringify: (value: unknown) => Promise<any>;
+    /** @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 QueueSaverOptions {
+    maxPreviousTracks: number;
+}
+export interface QueueSaver {
+    /** @private */
+    _: StoreManager;
+    /** @private */
+    options: QueueSaverOptions;
+}
+export declare class QueueSaver {
+    constructor(storeManager: StoreManager, options: QueueSaverOptions);
+    get(guildId: string): Promise<Partial<StoredQueue>>;
+    delete(guildId: string): Promise<any>;
+    set(guildId: string, value: any): Promise<any>;
+    sync(guildId: string): Promise<Partial<StoredQueue>>;
+}
+export declare class DefaultQueueStore {
+    private data;
+    constructor();
+    get(guildId: any): Promise<any>;
+    set(guildId: any, stringifiedValue: any): Promise<Map<any, any>>;
+    delete(guildId: any): Promise<boolean>;
+    stringify(value: any): Promise<any>;
+    parse(value: any): Promise<Partial<StoredQueue>>;
+}
+export declare class QueueChangesWatcher {
+    constructor();
+    tracksAdd(guildId: string, tracks: Track[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+    tracksRemoved(guildId: string, tracks: Track[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+    shuffled(guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+}
+export declare class Queue {
+    readonly tracks: Track[];
+    readonly previous: Track[];
+    current: Track | null;
+    options: {
+        maxPreviousTracks: number;
+    };
+    private readonly guildId;
+    protected readonly QueueSaver: QueueSaver | null;
+    static readonly StaticSymbol: Symbol;
+    private managerUtils;
+    private queueChanges;
+    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueChangesWatcher?: QueueChangesWatcher);
+    /**
+     * Utils for a Queue
+     */
+    utils: {
+        /**
+         * Save the current cached Queue on the database/server (overides the server)
+         */
+        save: () => Promise<any>;
+        /**
+         * Sync the current queue database/server with the cached one
+         * @returns {void}
+         */
+        sync: (override?: boolean, dontSyncCurrent?: boolean) => Promise<void>;
+        destroy: () => Promise<any>;
+        /**
+         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the storeManager
+         */
+        getStored: () => 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 | Track[], 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 | Track[]): any;
+}

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

@@ -0,0 +1,47 @@
+import { Base64 } from "./Utils";
+export interface TrackInfo {
+    identifier: string;
+    title: string;
+    author: string;
+    duration: number;
+    artworkUrl: string | null;
+    uri: string;
+    sourceName: string;
+    isSeekable: boolean;
+    isStream: boolean;
+    isrc: string | null;
+}
+export interface PluginInfo {
+    /** The Type provided by a plugin */
+    type?: string;
+    /** The Identifier provided by a plugin */
+    identifier?: string;
+    /** The ArtworkUrl provided by a plugin */
+    artworkUrl?: string;
+    /** The Author Information provided by a plugin */
+    author?: string;
+    /** The Url provided by a Plugin */
+    url?: string;
+    /** The Url provided by a Plugin */
+    uri?: string;
+}
+export interface LavalinkTrack {
+    /** The Base 64 encoded String */
+    encoded?: Base64;
+    /** Track Information */
+    info: TrackInfo;
+    /** Plugin Information from Lavalink */
+    pluginInfo: Partial<PluginInfo>;
+}
+export interface Track extends LavalinkTrack {
+    /** The Track's Requester */
+    requester?: unknown;
+}
+export interface UnresolvedQuery {
+    /** The base64 of the unresolved track to "encode" */
+    encoded?: Base64;
+    /** Search for the closest track possible, by providing as much information as you can! */
+    info?: Partial<TrackInfo>;
+    /** The Track's Requester */
+    requester?: unknown;
+}

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

@@ -0,0 +1,258 @@
+import { LavalinkFilterData } from "./Filters";
+import { LavalinkManager } from "./LavalinkManager";
+import { LavalinkNode, NodeStats } from "./Node";
+import { PlayOptions } from "./Player";
+import { Queue } from "./Queue";
+import { PluginInfo, Track } from "./Track";
+export declare const TrackSymbol: unique symbol;
+export declare const UnresolvedTrackSymbol: unique symbol;
+export declare const QueueSymbol: unique symbol;
+export declare const NodeSymbol: unique symbol;
+export type LavalinkSearchPlatform = "ytsearch" | "ytmsearch" | "scsearch" | "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "sprec" | "ymsearch" | "speak" | "tts";
+export type ClientSearchPlatform = "youtube" | "yt" | "yt" | "youtube music" | "youtubemusic" | "ytm" | "soundcloud" | "sc" | "am" | "apple music" | "applemusic" | "apple" | "yandex music" | "sp" | "sprec" | "spsuggestion" | "spotify" | "dz" | "deezer" | "yandex" | "yandexmusic";
+export type SearchPlatform = LavalinkSearchPlatform | ClientSearchPlatform;
+export type SourcesRegex = "YoutubeRegex" | "YoutubeMusicRegex" | "SoundCloudRegex" | "SoundCloudMobileRegex" | "DeezerTrackRegex" | "DeezerArtistRegex" | "DeezerEpisodeRegex" | "DeezerMixesRegex" | "DeezerPageLinkRegex" | "DeezerPlaylistRegex" | "DeezerAlbumRegex" | "AllDeezerRegex" | "AllDeezerRegexWithoutPageLink" | "SpotifySongRegex" | "SpotifyPlaylistRegex" | "SpotifyArtistRegex" | "SpotifyEpisodeRegex" | "SpotifyShowRegex" | "SpotifyAlbumRegex" | "AllSpotifyRegex" | "mp3Url" | "m3uUrl" | "m3u8Url" | "mp4Url" | "m4aUrl" | "wavUrl" | "aacpUrl" | "tiktok" | "mixcloud" | "musicYandex" | "radiohost" | "bandcamp" | "appleMusic" | "TwitchTv" | "vimeo";
+export interface PlaylistInfo {
+    /** The playlist title. */
+    title: string;
+    /** The Playlist Author */
+    author?: string;
+    /** The Playlist Thumbnail */
+    thumbnail?: string;
+    /** A Uri to the playlist */
+    uri?: string;
+    /** The playlist selected track. */
+    selectedTrack: Track | null;
+    /** The duration of the entire playlist. (calcualted) */
+    duration: number;
+}
+export interface SearchResult {
+    loadType: LoadTypes;
+    exception: Exception | null;
+    pluginInfo: PluginInfo;
+    playlist: PlaylistInfo | null;
+    tracks: Track[];
+}
+export interface ManagerUitls {
+    /** @private */
+    manager: LavalinkManager;
+}
+export declare class ManagerUitls {
+    constructor(LavalinkManager?: LavalinkManager);
+    buildTrack(data: any, requester: any): Track;
+    /**
+     * Validate if a data is euqal to a track
+     * @param {Track|any} data the Track to validate
+     * @returns {boolean}
+     */
+    isTrack(data: Track | any): boolean;
+    validatedQuery(queryString: string, node: LavalinkNode): void;
+}
+/**
+ * @internal
+ */
+export interface MiniMapConstructor {
+    new (): MiniMap<unknown, unknown>;
+    new <K, V>(entries?: ReadonlyArray<readonly [K, V]> | null): MiniMap<K, V>;
+    new <K, V>(iterable: Iterable<readonly [K, V]>): MiniMap<K, V>;
+    readonly prototype: MiniMap<unknown, unknown>;
+    readonly [Symbol.species]: MiniMapConstructor;
+}
+/**
+ * Separate interface for the constructor so that emitted js does not have a constructor that overwrites itself
+ *
+ * @internal
+ */
+export interface MiniMap<K, V> extends Map<K, V> {
+    constructor: MiniMapConstructor;
+}
+export declare class MiniMap<K, V> extends Map<K, V> {
+    constructor(data?: any[]);
+    /**
+     * Identical to
+     * [Array.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),
+     * but returns a MiniMap instead of an Array.
+     *
+     * @param fn The function to test with (should return boolean)
+     * @param thisArg Value to use as `this` when executing function
+     *
+     * @example
+     * miniMap.filter(user => user.username === 'Bob');
+     */
+    filter<K2 extends K>(fn: (value: V, key: K, miniMap: this) => key is K2): MiniMap<K2, V>;
+    filter<V2 extends V>(fn: (value: V, key: K, miniMap: this) => value is V2): MiniMap<K, V2>;
+    filter(fn: (value: V, key: K, miniMap: this) => boolean): MiniMap<K, V>;
+    filter<This, K2 extends K>(fn: (this: This, value: V, key: K, miniMap: this) => key is K2, thisArg: This): MiniMap<K2, V>;
+    filter<This, V2 extends V>(fn: (this: This, value: V, key: K, miniMap: this) => value is V2, thisArg: This): MiniMap<K, V2>;
+    filter<This>(fn: (this: This, value: V, key: K, miniMap: this) => boolean, thisArg: This): MiniMap<K, V>;
+    /**
+     * Maps each item to another value into an array. Identical in behavior to
+     * [Array.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).
+     *
+     * @param fn Function that produces an element of the new array, taking three arguments
+     * @param thisArg Value to use as `this` when executing function
+     *
+     * @example
+     * miniMap.map(user => user.tag);
+     */
+    map<T>(fn: (value: V, key: K, miniMap: this) => T): T[];
+    map<This, T>(fn: (this: This, value: V, key: K, miniMap: this) => T, thisArg: This): T[];
+}
+export type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent;
+export type Severity = "COMMON" | "SUSPICIOUS" | "FAULT";
+export interface Exception {
+    severity: Severity;
+    message: string;
+    cause: string;
+}
+export interface PlayerEvent {
+    op: "event";
+    type: PlayerEventType;
+    guildId: string;
+}
+export interface TrackStartEvent extends PlayerEvent {
+    type: "TrackStartEvent";
+    track: string;
+}
+export interface TrackEndEvent extends PlayerEvent {
+    type: "TrackEndEvent";
+    track: string;
+    reason: TrackEndReason;
+}
+export interface TrackExceptionEvent extends PlayerEvent {
+    type: "TrackExceptionEvent";
+    exception?: Exception;
+    error: string;
+}
+export interface TrackStuckEvent extends PlayerEvent {
+    type: "TrackStuckEvent";
+    thresholdMs: number;
+}
+export interface WebSocketClosedEvent extends PlayerEvent {
+    type: "WebSocketClosedEvent";
+    code: number;
+    byRemote: boolean;
+    reason: string;
+}
+export type LoadTypes = "track" | "playlist" | "search" | "error" | "empty";
+export type State = "CONNECTED" | "CONNECTING" | "DISCONNECTED" | "DISCONNECTING" | "DESTROYING";
+export type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent";
+export type TrackEndReason = "finished" | "loadFailed" | "stopped" | "replaced" | "cleanup";
+export interface InvalidLavalinkRestRequest {
+    timestamp: number;
+    status: number;
+    error: string;
+    message?: string;
+    path: string;
+}
+export interface LavalinkPlayerVoice {
+    token: string;
+    endpoint: string;
+    sessionId: string;
+    connected?: boolean;
+    ping?: number;
+}
+export interface LavalinkPlayerVoiceOptions extends Omit<LavalinkPlayerVoice, 'connected' | 'ping'> {
+}
+export interface FailingAddress {
+    /** The failing address */
+    failingAddress: string;
+    /** The timestamp when the address failed */
+    failingTimestamp: number;
+    /** The timestamp when the address failed as a pretty string */
+    failingTime: string;
+}
+type RoutePlannerTypes = "RotatingIpRoutePlanner" | "NanoIpRoutePlanner" | "RotatingNanoIpRoutePlanner" | "BalancingIpRoutePlanner";
+export interface RoutePlanner {
+    class?: RoutePlannerTypes;
+    details?: {
+        /** The ip block being used */
+        ipBlock: {
+            /** The type of the ip block */
+            type: "Inet4Address" | "Inet6Address";
+            /** 	The size of the ip block */
+            size: string;
+        };
+        /** The failing addresses */
+        failingAddresses: FailingAddress[];
+        /** The number of rotations */
+        rotateIndex?: string;
+        /** The current offset in the block	 */
+        ipIndex?: string;
+        /** The current address being used	 */
+        currentAddress?: string;
+        /** The current offset in the ip block */
+        currentAddressIndex?: string;
+        /** The information in which /64 block ips are chosen. This number increases on each ban. */
+        blockIndex?: string;
+    };
+}
+export interface Session {
+    resuming: boolean;
+    timeout: number;
+}
+export interface GuildShardPayload {
+    /** The OP code */
+    op: number;
+    d: {
+        guild_id: string;
+        channel_id: string | null;
+        self_mute: boolean;
+        self_deaf: boolean;
+    };
+}
+export interface PlayerUpdateInfo {
+    guildId: string;
+    playerOptions: PlayOptions;
+    noReplace?: boolean;
+}
+export interface LavalinkPlayer {
+    guildId: string;
+    track?: {
+        encoded?: string;
+        info: {
+            identifier: string;
+            title: string;
+            author: string;
+            length: number;
+            artworkUrl: string | null;
+            uri: string;
+            sourceName: string;
+            isSeekable: boolean;
+            isStream: boolean;
+            isrc: string | null;
+            position?: number;
+        };
+    };
+    volume: number;
+    paused: boolean;
+    voice: LavalinkPlayerVoice;
+    filters: Partial<LavalinkFilterData>;
+}
+export interface VoiceState {
+    op: "voiceUpdate";
+    guildId: string;
+    event: VoiceServer;
+    sessionId?: string;
+    guild_id: string;
+    user_id: string;
+    session_id: string;
+    channel_id: string;
+}
+export type Base64 = string;
+export interface VoiceServer {
+    token: string;
+    guild_id: string;
+    endpoint: string;
+}
+export interface VoicePacket {
+    t?: "VOICE_SERVER_UPDATE" | "VOICE_STATE_UPDATE";
+    d: VoiceState | VoiceServer;
+}
+export interface NodeMessage extends NodeStats {
+    type: PlayerEventType;
+    op: "stats" | "playerUpdate" | "event";
+    guildId: string;
+}
+export declare function queueTrackEnd(queue: Queue, addBackToQueue?: boolean): Promise<Track>;
+export {};