aqualink/build/index.d.ts

An Lavalink client, focused in pure performance and features

import { EventEmitter } from "events";

declare module "aqualink" {
    export class Aqua extends EventEmitter {
        constructor(client: any, nodes: NodeOptions[], options?: AquaOptions);
        client: any;
        nodes: NodeOptions[];
        nodeMap: Map<string, Node>;
        players: Map<string, Player>;
        clientId: string | null;
        initiated: boolean;
        shouldDeleteMessage: boolean;
        defaultSearchPlatform: string;
        leaveOnEnd: boolean;
        restVersion: string;
        plugins: Plugin[];
        version: string;
        send: (payload: any) => void;
        autoResume: boolean;
        infiniteReconnects: boolean;
        options: AquaOptions;
        failoverOptions: FailoverOptions;
        _leastUsedCache: { nodes: Node[], timestamp: number };

        defaultSendFunction(payload: any): void;
        get leastUsedNodes(): Node[];
        init(clientId: string): Promise<Aqua>;
        createNode(options: NodeOptions): Promise<Node>;
        destroyNode(identifier: string): void;
        updateVoiceState({ d, t }: { d: any, t: string }): void;
        fetchRegion(region: string): Node[];
        calculateLoad(node: Node): number;
        createConnection(options: ConnectionOptions): Player;
        createPlayer(node: Node, options: PlayerOptions): Player;
        destroyPlayer(guildId: string): Promise<void>;
        resolve({ query, source, requester, nodes }: ResolveOptions): Promise<ResolveResponse>;
        getRequestNode(nodes: string | Node): Node;
        ensureInitialized(): void;
        formatQuery(query: string, source: string): string;
        handleNoMatches(rest: Rest, query: string): Promise<any>;
        constructResponse(response: any, requester: any, requestNode: Node): ResolveResponse;
        get(guildId: string): Player;
        search(query: string, requester: any, source?: SearchSource): Promise<Track[] | null>;
        searchSuggestions(query: string, source?: SearchSource): Promise<SearchSuggestion[]>;
        autocomplete(query: string, source?: SearchSource): Promise<AutocompleteResult>;
        cleanupPlayer(player: Player): Promise<void>;
        handleFailover(player: Player, error: Error): Promise<boolean>;
        getHealthyNodes(): Node[];
        isNodeHealthy(node: Node): boolean;
    }

    export class Node {
        constructor(aqua: Aqua, connOptions: NodeOptions, options?: NodeAdditionalOptions);
        aqua: Aqua;
        host: string;
        name: string;
        port: number;
        password: string;
        secure: boolean;
        sessionId: string | null;
        regions: string[];
        wsUrl: string;
        rest: Rest;
        resumeTimeout: number;
        autoResume: boolean;
        reconnectTimeout: number;
        reconnectTries: number;
        infiniteReconnects: boolean;
        connected: boolean;
        info: any;
        ws: WebSocket | null;
        reconnectAttempted: number;
        reconnectTimeoutId: NodeJS.Timeout | null;
        stats: NodeStats;
        lastFailure: number;
        health: NodeHealth;

        initializeStats(): void;
        connect(): Promise<void>;
        destroy(clean?: boolean): void;
        getStats(): Promise<NodeStats>;
        isHealthy(): boolean;
        markFailure(): void;
        markSuccess(): void;
        getHealth(): NodeHealth;
    }

    export class Player extends EventEmitter {
        constructor(aqua: Aqua, nodes: Node, options: PlayerOptions);
        aqua: Aqua;
        nodes: Node;
        guildId: string;
        textChannel: string;
        voiceChannel: string;
        connection: Connection;
        filters: Filters;
        volume: number;
        loop: LoopMode;
        queue: Queue;
        previousTracks: Track[];
        previousTracksIndex: number;
        previousTracksCount: number;
        shouldDeleteMessage: boolean;
        leaveOnEnd: boolean;
        playing: boolean;
        paused: boolean;
        connected: boolean;
        current: Track | null;
        position: number;
        timestamp: number;
        ping: number;
        nowPlayingMessage: any;
        isAutoplayEnabled: boolean;
        isAutoplay: boolean;
        failoverAttempts: number;
        lastFailoverTime: number;

        play(): Promise<void>;
        connect(options: ConnectionOptions): Player;
        destroy(): Player;
        pause(paused: boolean): Player;
        seek(position: number): Player;
        stop(): Player;
        setVolume(volume: number): Player;
        setLoop(mode: LoopMode): Player;
        setTextChannel(channel: string): Player;
        setVoiceChannel(channel: string): Player;
        disconnect(): Player;
        shuffle(): Player;
        getQueue(): Queue;
        replay(): Player;
        skip(): Player;
        searchLyrics(query: string): Promise<any>;
        lyrics(): Promise<any>;
        updatePlayer(data: any): Promise<void>;
        switchNode(newNode: Node, preserveState?: boolean): Promise<boolean>;
        canFailover(): boolean;
    }

    export class Track {
        constructor(data: any, requester: any, nodes: Node);
        info: TrackInfo;
        track: string | null;
        playlist: any;
        requester: any;
        nodes: Node;

        resolveThumbnail(thumbnail: string): string | null;
        resolve(aqua: Aqua): Promise<Track | null>;
    }

    export class Rest {
        constructor(aqua: Aqua, options: RestOptions);
        aqua: Aqua;
        sessionId: string;
        version: string;
        baseUrl: string;
        headers: any;
        secure: boolean;
        timeout: number;
        client: any;

        setSessionId(sessionId: string): void;
        makeRequest(method: string, endpoint: string, body?: any): Promise<any>;
        updatePlayer(options: { guildId: string, data: any }): Promise<any>;
        getPlayers(): Promise<any>;
        destroyPlayer(guildId: string): Promise<any>;
        getTracks(identifier: string): Promise<any>;
        decodeTrack(track: string): Promise<any>;
        decodeTracks(tracks: string[]): Promise<any>;
        getStats(): Promise<any>;
        getInfo(): Promise<any>;
        getRoutePlannerStatus(): Promise<any>;
        getRoutePlannerAddress(address: string): Promise<any>;
        getLyrics(options: { track: Track }): Promise<any>;
        getSearchSuggestions(query: string, source?: SearchSource): Promise<SearchSuggestion[]>;
        getAutocompleteSuggestions(query: string, source?: SearchSource): Promise<AutocompleteResult>;
    }

    export class Queue extends Array<any> {
        constructor(...elements: any[]);
        size: number;
        first: any;
        last: any;

        add(track: any): Queue;
        remove(track: any): void;
        clear(): void;
        shuffle(): void;
        peek(): any;
        toArray(): any[];
        at(index: number): any;
        dequeue(): any;
        isEmpty(): boolean;
        enqueue(track: any): Queue;
    }

    export class Plugin {
        constructor(name: string);
        name: string;

        load(aqua: Aqua): void;
        unload(aqua: Aqua): void;
    }

    export class Filters {
        constructor(player: Player, options?: FilterOptions);
        player: Player;
        volume: number;
        equalizer: any[];
        karaoke: any | null;
        timescale: any | null;
        tremolo: any | null;
        vibrato: any | null;
        rotation: any | null;
        distortion: any | null;
        channelMix: any | null;
        lowPass: any | null;
        bassboost: any | null;
        slowmode: any | null;
        nightcore: any | null;
        vaporwave: any | null;
        _8d: any | null;

        setEqualizer(bands: any[]): Filters;
        setKaraoke(enabled: boolean, options?: any): Filters;
        setTimescale(enabled: boolean, options?: any): Filters;
        setTremolo(enabled: boolean, options?: any): Filters;
        setVibrato(enabled: boolean, options?: any): Filters;
        setRotation(enabled: boolean, options?: any): Filters;
        setDistortion(enabled: boolean, options?: any): Filters;
        setChannelMix(enabled: boolean, options?: any): Filters;
        setLowPass(enabled: boolean, options?: any): Filters;
        setBassboost(enabled: boolean, options?: any): Filters;
        setSlowmode(enabled: boolean, options?: any): Filters;
        setNightcore(enabled: boolean, options?: any): Filters;
        setVaporwave(enabled: boolean, options?: any): Filters;
        set8D(enabled: boolean, options?: any): Filters;
        clearFilters(): Promise<Filters>;
        updateFilters(): Promise<Filters>;
    }

    export class Connection {
        constructor(player: Player);
        playerRef: WeakRef<Player>;
        sessionId: string | null;
        endpoint: string | null;
        token: string | null;
        region: string | null;
        selfDeaf: boolean;
        selfMute: boolean;
        voiceChannel: string;
        guildId: string;
        aqua: Aqua;
        nodes: Node;

        setServerUpdate(data: any): void;
        setStateUpdate(data: any): void;
    }

    // Enhanced interfaces with autocomplete and failover support
    interface AquaOptions {
        shouldDeleteMessage?: boolean;
        defaultSearchPlatform?: SearchSource;
        leaveOnEnd?: boolean;
        restVersion?: RestVersion;
        plugins?: Plugin[];
        send?: (payload: any) => void;
        autoResume?: boolean;
        infiniteReconnects?: boolean;
        failoverOptions?: FailoverOptions;
    }

    interface FailoverOptions {
        enabled?: boolean;
        maxRetries?: number;
        retryDelay?: number;
        preservePosition?: boolean;
        resumePlayback?: boolean;
        cooldownTime?: number;
        maxFailoverAttempts?: number;
        healthCheckInterval?: number;
        unhealthyThreshold?: number;
        recoveryCooldown?: number;
    }

    interface NodeOptions {
        host: string;
        name?: string;
        port?: number;
        password?: string;
        secure?: boolean;
        sessionId?: string;
        regions?: string[];
        priority?: number;
        retryAmount?: number;
        retryDelay?: number;
    }

    interface NodeAdditionalOptions {
        resumeTimeout?: number;
        autoResume?: boolean;
        reconnectTimeout?: number;
        reconnectTries?: number;
        infiniteReconnects?: boolean;
    }

    interface PlayerOptions {
        guildId: string;
        textChannel: string;
        voiceChannel: string;
        defaultVolume?: number;
        loop?: LoopMode;
        shouldDeleteMessage?: boolean;
        leaveOnEnd?: boolean;
        autoplay?: boolean;
        enableFailover?: boolean;
    }

    interface ConnectionOptions {
        guildId: string;
        voiceChannel: string;
        deaf?: boolean;
        mute?: boolean;
    }

    interface ResolveOptions {
        query: string;
        source?: SearchSource;
        requester: any;
        nodes?: string | Node;
    }

    interface ResolveResponse {
        loadType: LoadType;
        exception: LavalinkException | null;
        playlistInfo: PlaylistInfo | null;
        pluginInfo: any;
        tracks: Track[];
    }

    interface RestOptions {
        secure: boolean;
        host: string;
        port: number;
        sessionId: string;
        password: string;
        timeout?: number;
    }

    interface NodeStats {
        players: number;
        playingPlayers: number;
        uptime: number;
        memory: {
            free: number;
            used: number;
            allocated: number;
            reservable: number;
            freePercentage: number;
            usedPercentage: number;
        };
        cpu: {
            cores: number;
            systemLoad: number;
            lavalinkLoad: number;
            lavalinkLoadPercentage: number;
        };
        frameStats: {
            sent: number;
            nulled: number;
            deficit: number;
        };
        ping: number;
    }

    interface TrackInfo {
        identifier: string;
        isSeekable: boolean;
        author: string;
        length: number;
        isStream: boolean;
        title: string;
        uri: string;
        sourceName: string;
        artworkUrl: string;
        position?: number;
    }

    interface FilterOptions {
        volume?: number;
        equalizer?: any[];
        karaoke?: any;
        timescale?: any;
        tremolo?: any;
        vibrato?: any;
        rotation?: any;
        distortion?: any;
        channelMix?: any;
        lowPass?: any;
        bassboost?: any;
        slowmode?: any;
        nightcore?: any;
        vaporwave?: any;
        _8d?: any;
    }

    interface SearchSuggestion {
        text: string;
        highlighted: string;
        type: SuggestionType;
        source: SearchSource;
    }

    interface AutocompleteResult {
        query: string;
        suggestions: SearchSuggestion[];
        hasMore: boolean;
        timestamp: number;
    }

    interface PlaylistInfo {
        name: string;
        selectedTrack: number;
    }

    interface LavalinkException {
        message: string;
        severity: ExceptionSeverity;
        cause: string;
    }

    interface NodeHealth {
        healthy: boolean;
        consecutiveFailures: number;
        lastCheck: number;
        responseTime: number;
        uptime: number;
    }

    type SearchSource = 
        | 'ytsearch'
        | 'ytmsearch' 
        | 'scsearch'
        | 'spsearch'
        | 'amsearch'
        | 'dzsearch'
        | 'yandexsearch'
        | 'soundcloud'
        | 'youtube'
        | 'spotify'
        | 'applemusic'
        | 'deezer'
        | 'bandcamp'
        | 'vimeo'
        | 'twitch'
        | 'http';

    type LoopMode = 'none' | 'track' | 'queue';

    type LoadType = 
        | 'track'
        | 'playlist' 
        | 'search'
        | 'empty'
        | 'error';

    type RestVersion = 'v3' | 'v4';

    type SuggestionType = 
        | 'track'
        | 'artist'
        | 'album'
        | 'playlist'
        | 'query';

    type ExceptionSeverity = 
        | 'common'
        | 'suspicious'
        | 'fault';

    interface AquaEvents {
        'nodeConnect': (node: Node) => void;
        'nodeDisconnect': (node: Node, code: number, reason: string) => void;
        'nodeError': (node: Node, error: Error) => void;
        'nodeReconnect': (node: Node) => void;
        'playerCreate': (player: Player) => void;
        'playerDestroy': (player: Player) => void;
        'trackStart': (player: Player, track: Track) => void;
        'trackEnd': (player: Player, track: Track) => void;
        'trackError': (player: Player, track: Track, error: Error) => void;
        'trackStuck': (player: Player, track: Track, thresholdMs: number) => void;
        'queueEnd': (player: Player) => void;
        'playerMove': (player: Player, oldChannel: string, newChannel: string) => void;
        'playerDisconnect': (player: Player, oldChannel: string) => void;
        'failover': (player: Player, oldNode: Node, newNode: Node) => void;
        'failoverFailed': (player: Player, error: Error) => void;
    }

    interface PlayerEvents {
        'trackStart': (track: Track) => void;
        'trackEnd': (track: Track) => void;
        'trackError': (track: Track, error: Error) => void;
        'trackStuck': (track: Track, thresholdMs: number) => void;
        'playerUpdate': (state: any) => void;
        'queueEnd': () => void;
        'socketClosed': (code: number, reason: string, byRemote: boolean) => void;
        'failover': (oldNode: Node, newNode: Node) => void;
        'failoverFailed': (error: Error) => void;
    }

    export const DEFAULT_OPTIONS: Required<AquaOptions>;
}

declare module "aqualink" {
    interface Aqua {
        on<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
        once<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
        emit<K extends keyof AquaEvents>(event: K, ...args: Parameters<AquaEvents[K]>): boolean;
    }

    interface Player {
        on<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
        once<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
        emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
    }
}