aqualink 2.11.0 → 2.11.2

package/build/index.d.ts

@@ -1,56 +1,46 @@
 import { EventEmitter } from "events";
 
 declare module "aqualink" {
+    // Main Classes
     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;
+
+       // Additional properties found in implementation
         plugins: Plugin[];
-        version: string;
-        send: (payload: any) => void;
-        autoResume: boolean;
-        infiniteReconnects: boolean;
-        options: AquaOptions;
-        failoverOptions: FailoverOptions;
-        _leastUsedCache: { nodes: Node[], timestamp: number };
+        players: Map<string, Player>;
+        nodeMap: Map<string, Node>;
+        _nodeStates: Map<string, { connected: boolean; failoverInProgress: boolean }>;
+        _failoverQueue: Map<string, number>;
+        _lastFailoverAttempt: Map<string, number>;
+        _brokenPlayers: Map<string, any>;
+        _rebuildLocks: Set<string>;
+        _leastUsedNodesCache: Node[] | null;
+        _leastUsedNodesCacheTime: number;
+        _nodeLoadCache: Map<string, number>;
+        _nodeLoadCacheTime: Map<string, 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;
+        updateVoiceState(data: VoiceStateUpdate): 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;
+        resolve(options: ResolveOptions): Promise<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;
+
+
+        // Missing public methods
+        bypassChecks?: { nodeFetchInfo?: boolean };
     }
 
     export class Node {
         constructor(aqua: Aqua, connOptions: NodeOptions, options?: NodeAdditionalOptions);
+
+        // Core Properties
         aqua: Aqua;
         host: string;
         name: string;
@@ -67,26 +57,32 @@ declare module "aqualink" {
         reconnectTries: number;
         infiniteReconnects: boolean;
         connected: boolean;
-        info: any;
-        ws: WebSocket | null;
+        info: NodeInfo | null;
+        ws: any | null; // WebSocket
         reconnectAttempted: number;
         reconnectTimeoutId: NodeJS.Timeout | null;
+        isDestroyed: boolean;
         stats: NodeStats;
-        lastFailure: number;
-        health: NodeHealth;
+        players: Set<Player>;
+        options: NodeOptions;
 
-        initializeStats(): void;
+        // Methods
         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);
+
+        // Static Properties
+        static readonly LOOP_MODES: {
+            readonly NONE: 0;
+            readonly TRACK: 1;
+            readonly QUEUE: 2;
+        };
+
+        // Core Properties
         aqua: Aqua;
         nodes: Node;
         guildId: string;
@@ -95,16 +91,14 @@ declare module "aqualink" {
         connection: Connection;
         filters: Filters;
         volume: number;
-        loop: LoopMode;
+        loop: LoopModeName | LoopMode;
         queue: Queue;
-        previousTracks: Track[];
-        previousTracksIndex: number;
-        previousTracksCount: number;
         shouldDeleteMessage: boolean;
         leaveOnEnd: boolean;
         playing: boolean;
         paused: boolean;
         connected: boolean;
+        destroyed: boolean;
         current: Track | null;
         position: number;
         timestamp: number;
@@ -112,17 +106,26 @@ declare module "aqualink" {
         nowPlayingMessage: any;
         isAutoplayEnabled: boolean;
         isAutoplay: boolean;
-        failoverAttempts: number;
-        lastFailoverTime: number;
-
-        play(): Promise<void>;
-        connect(options: ConnectionOptions): Player;
-        destroy(): Player;
+        autoplaySeed: AutoplaySeed | null;
+        deaf: boolean;
+        mute: boolean;
+        autoplayRetries: number;
+        reconnectionRetries: number;
+        previousIdentifiers: Set<string>;
+
+        // Getters
+        get previous(): Track | null;
+        get currenttrack(): Track | null;
+
+        // Core Methods
+        play(): Promise<Player>;
+        connect(options?: ConnectionOptions): Player;
+        destroy(options?: { preserveClient?: boolean; skipRemote?: boolean }): Player;
         pause(paused: boolean): Player;
         seek(position: number): Player;
         stop(): Player;
         setVolume(volume: number): Player;
-        setLoop(mode: LoopMode): Player;
+        setLoop(mode: LoopMode | LoopModeName): Player;
         setTextChannel(channel: string): Player;
         setVoiceChannel(channel: string): Player;
         disconnect(): Player;
@@ -130,136 +133,161 @@ declare module "aqualink" {
         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;
+
+        // Advanced Methods
+        getLyrics(options?: LyricsOptions): Promise<LyricsResponse | null>;
+        subscribeLiveLyrics(): Promise<any>;
+        unsubscribeLiveLyrics(): Promise<any>;
+        autoplay(): Promise<Player>;
+        setAutoplay(enabled: boolean): Player;
+        updatePlayer(data: any): Promise<any>;
+        cleanup(): Promise<void>;
+
+        // Data Methods
+        set(key: string, value: any): void;
+        get(key: string): any;
+        clearData(): Player;
+
+        // Utility Methods
+        send(data: any): void;
+        batchUpdatePlayer(data: any, immediate?: boolean): Promise<void>;
     }
 
     export class Track {
-        constructor(data: any, requester: any, nodes: Node);
-        info: TrackInfo;
+        constructor(data?: TrackData, requester?: any, nodes?: Node);
+
+        // Properties
+        identifier: string;
+        isSeekable: boolean;
+        author: string;
+        position: number;
+        duration: number;
+        isStream: boolean;
+        title: string;
+        uri: string;
+        sourceName: string;
+        artworkUrl: string;
         track: string | null;
-        playlist: any;
+        playlist: PlaylistInfo | null;
         requester: any;
         nodes: Node;
 
-        resolveThumbnail(thumbnail: string): string | null;
+        // Getters
+        get info(): TrackInfo;
+        get length(): number;
+        get thumbnail(): string;
+
+        // Methods
+        resolveThumbnail(url?: string): string | null;
         resolve(aqua: Aqua): Promise<Track | null>;
+        isValid(): boolean;
+        dispose(): void;
     }
 
     export class Rest {
-        constructor(aqua: Aqua, options: RestOptions);
+        constructor(aqua: Aqua, node: Node);
+
         aqua: Aqua;
+        node: Node;
         sessionId: string;
-        version: string;
-        baseUrl: string;
-        headers: any;
-        secure: boolean;
-        timeout: number;
-        client: any;
+        calls: number;
 
         setSessionId(sessionId: string): void;
-        makeRequest(method: string, endpoint: string, body?: any): Promise<any>;
-        updatePlayer(options: { guildId: string, data: any }): Promise<any>;
-        getPlayers(): Promise<any>;
+        makeRequest(method: HttpMethod, endpoint: string, body?: any): Promise<any>;
+        updatePlayer(options: UpdatePlayerOptions): 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>;
+        getLyrics(options: GetLyricsOptions): Promise<LyricsResponse>;
+        subscribeLiveLyrics(guildId: string, sync?: boolean): Promise<any>;
+        unsubscribeLiveLyrics(guildId: string): Promise<any>;
+        getStats(): Promise<NodeStats>;
     }
 
-    export class Queue extends Array<any> {
-        constructor(...elements: any[]);
-        size: number;
-        first: any;
-        last: any;
+    export class Queue extends Array<Track> {
+        constructor(...elements: Track[]);
 
-        add(track: any): Queue;
-        remove(track: any): void;
+        // Properties
+        size: number;
+        first: Track | null;
+        last: Track | null;
+
+        // Methods
+        add(...tracks: Track[]): void;
+        push(track: Track): number;
+        unshift(track: Track): number;
+        shift(): Track | undefined;
         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;
+        toArray(): Track[];
     }
 
     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;
+        filters: {
+            volume: number;
+            equalizer: EqualizerBand[];
+            karaoke: KaraokeSettings | null;
+            timescale: TimescaleSettings | null;
+            tremolo: TremoloSettings | null;
+            vibrato: VibratoSettings | null;
+            rotation: RotationSettings | null;
+            distortion: DistortionSettings | null;
+            channelMix: ChannelMixSettings | null;
+            lowPass: LowPassSettings | null;
+        };
+        presets: {
+            bassboost: number | null;
+            slowmode: boolean | null;
+            nightcore: boolean | null;
+            vaporwave: boolean | null;
+            _8d: boolean | null;
+        };
+
+        // Filter Methods
+        setEqualizer(bands: EqualizerBand[]): Filters;
+        setKaraoke(enabled: boolean, options?: KaraokeSettings): Filters;
+        setTimescale(options?: TimescaleSettings): Filters;
+        setTremolo(options?: TremoloSettings): Filters;
+        setVibrato(options?: VibratoSettings): Filters;
+        setRotation( options?: RotationSettings): Filters;
+        setDistortion( options?: DistortionSettings): Filters;
+        setChannelMix(options?: ChannelMixSettings): Filters;
+        setLowPass( options?: LowPassSettings): Filters;
+        setBassboost(enabled: boolean, options?: { value?: number }): Filters;
+        setSlowmode(enabled: boolean, options?: { rate?: number }): Filters;
+        setNightcore(enabled: boolean, options?: { rate?: number }): Filters;
+        setVaporwave(enabled: boolean, options?: { pitch?: number }): Filters;
+        set8D(enabled: boolean, options?: { rotationHz?: number }): Filters;
         clearFilters(): Promise<Filters>;
         updateFilters(): Promise<Filters>;
     }
 
     export class Connection {
         constructor(player: Player);
-        playerRef: WeakRef<Player>;
+
+        voiceChannel: string;
         sessionId: string | null;
         endpoint: string | null;
         token: string | null;
         region: string | null;
-        selfDeaf: boolean;
-        selfMute: boolean;
-        voiceChannel: string;
-        guildId: string;
-        aqua: Aqua;
-        nodes: Node;
+        sequence: number;
 
-        setServerUpdate(data: any): void;
-        setStateUpdate(data: any): void;
+        setServerUpdate(data: VoiceServerUpdate['d']): void;
+        setStateUpdate(data: VoiceStateUpdate['d']): void;
+        updateSequence(seq: number): void;
+        destroy(): void;
     }
 
-    // Enhanced interfaces with autocomplete and failover support
-    interface AquaOptions {
+    export class Plugin {
+        constructor(name: string);
+        name: string;
+        load(aqua: Aqua): void | Promise<void>;
+        unload?(aqua: Aqua): void | Promise<void>;
+    }
+
+    // Configuration Interfaces
+    export interface AquaOptions {
         shouldDeleteMessage?: boolean;
         defaultSearchPlatform?: SearchSource;
         leaveOnEnd?: boolean;
@@ -271,7 +299,7 @@ declare module "aqualink" {
         failoverOptions?: FailoverOptions;
     }
 
-    interface FailoverOptions {
+    export interface FailoverOptions {
         enabled?: boolean;
         maxRetries?: number;
         retryDelay?: number;
@@ -279,12 +307,9 @@ declare module "aqualink" {
         resumePlayback?: boolean;
         cooldownTime?: number;
         maxFailoverAttempts?: number;
-        healthCheckInterval?: number;
-        unhealthyThreshold?: number;
-        recoveryCooldown?: number;
     }
 
-    interface NodeOptions {
+    export interface NodeOptions {
         host: string;
         name?: string;
         port?: number;
@@ -292,63 +317,56 @@ declare module "aqualink" {
         secure?: boolean;
         sessionId?: string;
         regions?: string[];
-        priority?: number;
-        retryAmount?: number;
-        retryDelay?: number;
     }
 
-    interface NodeAdditionalOptions {
+    export interface NodeAdditionalOptions {
         resumeTimeout?: number;
         autoResume?: boolean;
         reconnectTimeout?: number;
         reconnectTries?: number;
         infiniteReconnects?: boolean;
+        timeout?: number;
+        maxPayload?: number;
+        skipUTF8Validation?: boolean;
     }
 
-    interface PlayerOptions {
+    export interface PlayerOptions {
         guildId: string;
         textChannel: string;
         voiceChannel: string;
         defaultVolume?: number;
-        loop?: LoopMode;
-        shouldDeleteMessage?: boolean;
-        leaveOnEnd?: boolean;
-        autoplay?: boolean;
-        enableFailover?: boolean;
+        loop?: LoopModeName;
+        deaf?: boolean;
+        mute?: boolean;
     }
 
-    interface ConnectionOptions {
+    export interface ConnectionOptions {
         guildId: string;
         voiceChannel: string;
+        textChannel?: string;
         deaf?: boolean;
         mute?: boolean;
+        defaultVolume?: number;
+        region?: string;
     }
 
-    interface ResolveOptions {
+    export interface ResolveOptions {
         query: string;
-        source?: SearchSource;
+        source?: SearchSource | string;
         requester: any;
-        nodes?: string | Node;
+        nodes?: string | Node | Node[];
     }
 
-    interface ResolveResponse {
+    // Response and Data Interfaces
+    export interface ResolveResponse {
         loadType: LoadType;
         exception: LavalinkException | null;
         playlistInfo: PlaylistInfo | null;
-        pluginInfo: any;
+        pluginInfo: Record<string, any>;
         tracks: Track[];
     }
 
-    interface RestOptions {
-        secure: boolean;
-        host: string;
-        port: number;
-        sessionId: string;
-        password: string;
-        timeout?: number;
-    }
-
-    interface NodeStats {
+    export interface NodeStats {
         players: number;
         playingPlayers: number;
         uptime: number;
@@ -357,24 +375,44 @@ declare module "aqualink" {
             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;
+        ping?: number;
+    }
+
+    export interface NodeInfo {
+        version: {
+            semver: string;
+            major: number;
+            minor: number;
+            patch: number;
+        };
+        buildTime: number;
+        git: {
+            branch: string;
+            commit: string;
+            commitTime: number;
+        };
+        jvm: string;
+        lavaplayer: string;
+        sourceManagers: string[];
+        filters: string[];
+        plugins: Array<{
+            name: string;
+            version: string;
+        }>;
     }
 
-    interface TrackInfo {
+    export interface TrackInfo {
         identifier: string;
         isSeekable: boolean;
         author: string;
@@ -387,60 +425,171 @@ declare module "aqualink" {
         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;
+    export interface TrackData {
+        encoded?: string;
+        info: TrackInfo;
+        playlist?: PlaylistInfo;
     }
 
-    interface PlaylistInfo {
+    export interface PlaylistInfo {
         name: string;
-        selectedTrack: number;
+        selectedTrack?: number;
+        thumbnail?: string;
     }
 
-    interface LavalinkException {
+    export interface LavalinkException {
         message: string;
-        severity: ExceptionSeverity;
+        severity: string;
         cause: string;
     }
 
-    interface NodeHealth {
-        healthy: boolean;
-        consecutiveFailures: number;
-        lastCheck: number;
-        responseTime: number;
-        uptime: number;
+    // Filter Interfaces
+    export interface FilterOptions {
+        volume?: number;
+        equalizer?: EqualizerBand[];
+        karaoke?: KaraokeSettings;
+        timescale?: TimescaleSettings;
+        tremolo?: TremoloSettings;
+        vibrato?: VibratoSettings;
+        rotation?: RotationSettings;
+        distortion?: DistortionSettings;
+        channelMix?: ChannelMixSettings;
+        lowPass?: LowPassSettings;
+        bassboost?: number;
+        slowmode?: boolean;
+        nightcore?: boolean;
+        vaporwave?: boolean;
+        _8d?: boolean;
     }
 
-    type SearchSource = 
+    export interface EqualizerBand {
+        band: number;
+        gain: number;
+    }
+
+    export interface KaraokeSettings {
+        level?: number;
+        monoLevel?: number;
+        filterBand?: number;
+        filterWidth?: number;
+    }
+
+    export interface TimescaleSettings {
+        speed?: number;
+        pitch?: number;
+        rate?: number;
+    }
+
+    export interface TremoloSettings {
+        frequency?: number;
+        depth?: number;
+    }
+
+    export interface VibratoSettings {
+        frequency?: number;
+        depth?: number;
+    }
+
+    export interface RotationSettings {
+        rotationHz?: number;
+    }
+
+    export interface DistortionSettings {
+        distortion?: number;
+        sinOffset?: number;
+        sinScale?: number;
+        cosOffset?: number;
+        cosScale?: number;
+        tanOffset?: number;
+        tanScale?: number;
+        offset?: number;
+        scale?: number;
+    }
+
+    export interface ChannelMixSettings {
+        leftToLeft?: number;
+        leftToRight?: number;
+        rightToLeft?: number;
+        rightToRight?: number;
+    }
+
+    export interface LowPassSettings {
+        smoothing?: number;
+    }
+
+    // Voice Update Interfaces
+    export interface VoiceStateUpdate {
+        d: {
+            guild_id: string;
+            channel_id: string | null;
+            user_id: string;
+            session_id: string;
+            deaf: boolean;
+            mute: boolean;
+            self_deaf: boolean;
+            self_mute: boolean;
+            suppress: boolean;
+            request_to_speak_timestamp: string | null;
+        };
+        t: 'VOICE_STATE_UPDATE';
+    }
+
+    export interface VoiceServerUpdate {
+        d: {
+            token: string;
+            guild_id: string;
+            endpoint: string | null;
+        };
+        t: 'VOICE_SERVER_UPDATE';
+    }
+
+    // Utility Interfaces
+    export interface LyricsOptions {
+        query?: string;
+        useCurrentTrack?: boolean;
+        skipTrackSource?: boolean;
+    }
+
+    export interface LyricsResponse {
+        text?: string;
+        source?: string;
+        lines?: Array<{
+            line: string;
+            timestamp?: number;
+        }>;
+    }
+
+    export interface AutoplaySeed {
+        trackId: string;
+        artistIds: string;
+    }
+
+    export interface UpdatePlayerOptions {
+        guildId: string;
+        data: {
+            track?: { encoded: string | null };
+            position?: number;
+            volume?: number;
+            paused?: boolean;
+            filters?: any;
+            voice?: any;
+        };
+    }
+
+    export interface GetLyricsOptions {
+        track: {
+            info: TrackInfo;
+            encoded?: string;
+            identifier?: string;
+            guild_id?: string;
+        };
+        skipTrackSource?: boolean;
+    }
+
+    // Type Unions and Enums
+    export type SearchSource =
         | 'ytsearch'
-        | 'ytmsearch' 
+        | 'ytmsearch'
         | 'scsearch'
         | 'spsearch'
         | 'amsearch'
@@ -456,72 +605,254 @@ declare module "aqualink" {
         | 'twitch'
         | 'http';
 
-    type LoopMode = 'none' | 'track' | 'queue';
+    export type LoopMode = 0 | 1 | 2;
+    export type LoopModeName = 'none' | 'track' | 'queue';
 
-    type LoadType = 
+    export type LoadType =
         | 'track'
-        | 'playlist' 
+        | 'playlist'
         | 'search'
         | 'empty'
         | 'error';
 
-    type RestVersion = 'v3' | 'v4';
-
-    type SuggestionType = 
-        | 'track'
-        | 'artist'
-        | 'album'
-        | 'playlist'
-        | 'query';
+    export type RestVersion = 'v3' | 'v4';
 
-    type ExceptionSeverity = 
-        | 'common'
-        | 'suspicious'
-        | 'fault';
+    export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 
-    interface AquaEvents {
+    // Event Interfaces
+    export interface AquaEvents {
         'nodeConnect': (node: Node) => void;
-        'nodeDisconnect': (node: Node, code: number, reason: string) => void;
+        'nodeConnected': (node: Node) => void;
+        'nodeDisconnect': (node: Node, data: { code: number; reason: string }) => void;
         'nodeError': (node: Node, error: Error) => void;
-        'nodeReconnect': (node: Node) => void;
+        'nodeReconnect': (node: Node, data: any) => void;
+        'nodeCreate': (node: Node) => void;
+        'nodeDestroy': (node: Node) => void;
+        'nodeReady': (node: Node, data: any) => void;
+        'nodeFailover': (node: Node) => void;
+        'nodeFailoverComplete': (node: Node, successful: number, failed: number) => void;
         'playerCreate': (player: Player) => void;
         'playerDestroy': (player: Player) => void;
+        'playerUpdate': (player: Player, packet: any) => void;
+        'playerMigrated': (oldPlayer: Player, newPlayer: Player, targetNode: Node) => void;
+        'playerReconnected': (player: Player, data: any) => void;
         'trackStart': (player: Player, track: Track) => void;
-        'trackEnd': (player: Player, track: Track) => void;
-        'trackError': (player: Player, track: Track, error: Error) => void;
+        'trackEnd': (player: Player, track: Track, reason?: string) => void;
+        'trackError': (player: Player, track: Track, error: any) => void;
         'trackStuck': (player: Player, track: Track, thresholdMs: number) => void;
+        'trackChange': (player: Player, track: Track, payload: any) => 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;
+        'playerMove': (oldChannel: string, newChannel: string) => void;
+        'playersRebuilt': (node: Node, count: number) => void;
+        'reconnectionFailed': (player: Player, data: any) => void;
+        'socketClosed': (player: Player, payload: any) => void;
+        'lyricsLine': (player: Player, track: Track, payload: any) => void;
+        'lyricsFound': (player: Player, track: Track, payload: any) => void;
+        'lyricsNotFound': (player: Player, track: Track, payload: any) => void;
+        'autoplayFailed': (player: Player, error: Error) => void;
+        'debug': (source: string, message: string) => void;
+        'error': (node: Node | null, 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" {
+    // Event Emitter Type Extensions for Aqua
     interface Aqua {
         on<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+
         once<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+
         emit<K extends keyof AquaEvents>(event: K, ...args: Parameters<AquaEvents[K]>): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+
+        off<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
+        off(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeListener<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        addListener<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeAllListeners<K extends keyof AquaEvents>(event?: K): this;
+        removeAllListeners(event?: string | symbol): this;
+    }
+    export interface PlayerEvents {
+        'destroy': () => void;
+        'playerUpdate': (packet: any) => void;
+        'event': (payload: any) => void;
+        'trackStart': (track: Track) => void;
+        'trackEnd': (track: Track, reason?: string) => void;
+        'trackError': (track: Track, error: any) => void;
+        'trackStuck': (track: Track, thresholdMs: number) => void;
+        'trackChange': (track: Track, payload: any) => void;
+        'socketClosed': (payload: any) => void;
+        'lyricsLine': (track: Track, payload: any) => void;
+        'lyricsFound': (track: Track, payload: any) => void;
+        'lyricsNotFound': (track: Track, payload: any) => void;
     }
 
-    interface Player {
+      interface Player {
         on<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+
         once<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+
         emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+
+        off<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
+        off(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeListener<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        addListener<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeAllListeners<K extends keyof PlayerEvents>(event?: K): this;
+        removeAllListeners(event?: string | symbol): this;
+    }
+
+    // Missing Player Properties and Methods
+    interface Player {
+        // Additional properties found in implementation
+        self_deaf: boolean;
+        self_mute: boolean;
+        players: Set<Player>; // For Node class
+
+        // Internal properties
+        _updateBatcher: any;
+        _dataStore: Map<string, any>;
+
+        // Event handler methods (these are called internally)
+        trackStart(player: Player, track: Track): Promise<void>;
+        trackEnd(player: Player, track: Track, payload: any): Promise<void>;
+        trackError(player: Player, track: Track, payload: any): Promise<void>;
+        trackStuck(player: Player, track: Track, payload: any): Promise<void>;
+        trackChange(player: Player, track: Track, payload: any): Promise<void>;
+        socketClosed(player: Player, track: Track, payload: any): Promise<void>;
+        lyricsLine(player: Player, track: Track, payload: any): Promise<void>;
+        lyricsFound(player: Player, track: Track, payload: any): Promise<void>;
+        lyricsNotFound(player: Player, track: Track, payload: any): Promise<void>;
+    }
+
+    interface Node {
+        // Additional properties found in implementation
+        timeout: number;
+        maxPayload: number;
+        skipUTF8Validation: boolean;
+        _isConnecting: boolean;
+        _debugEnabled: boolean;
+        _headers: Record<string, string>;
+        _boundHandlers: Record<string, Function>;
+
+        // Methods missing from original definitions
+        _handleOpen(): Promise<void>;
+        _handleError(error: any): void;
+        _handleMessage(data: any, isBinary: boolean): void;
+        _handleClose(code: number, reason: any): void;
+        _handleReady(payload: any): Promise<void>;
+        _emitError(error: any): void;
+        _emitDebug(message: string | (() => string)): void;
+    }
+
+    interface Rest {
+        // Additional properties
+        timeout: number;
+        baseUrl: string;
+        defaultHeaders: Record<string, string>;
+        agent: any; // HTTP/HTTPS Agent
+
+        // Missing REST methods found in implementation
+        getPlayer(guildId: string): Promise<any>;
+        getPlayers(): Promise<any>;
+        decodeTrack(encodedTrack: string): Promise<any>;
+        decodeTracks(encodedTracks: string[]): Promise<any>;
+        getInfo(): Promise<NodeInfo>;
+        getVersion(): Promise<string>;
+        getRoutePlannerStatus(): Promise<any>;
+        freeRoutePlannerAddress(address: string): Promise<any>;
+        freeAllRoutePlannerAddresses(): Promise<any>;
+        destroy(): void;
+    }
+
+   interface Connection {
+        // Internal properties found in implementation
+        _player: Player;
+        _aqua: Aqua;
+        _nodes: Node;
+        _guildId: string;
+        _clientId: string;
+        _lastEndpoint: string | null;
+        _pendingUpdate: any;
+        _updateTimer: NodeJS.Timeout | null;
+        _hasDebugListeners: boolean;
+        _hasMoveListeners: boolean;
+
+        // Methods not in original definition
+        _extractRegion(endpoint: string): string | null;
+        _scheduleVoiceUpdate(isResume?: boolean): void;
+        _executeVoiceUpdate(): void;
+        _sendUpdate(payload: any): Promise<void>;
+        _handleDisconnect(): void;
+        _clearPendingUpdate(): void;
+    }
+
+  export type EventHandler<T = any> = (...args: T[]) => void | Promise<void>;
+
+    // Extended ResolveOptions for internal use
+    export interface ExtendedResolveOptions extends ResolveOptions {
+        node?: Node;
+    }
+     interface Plugin {
+        // Optional unload method should be properly typed
+        unload?(aqua: Aqua): void | Promise<void>;
+    }
+
+      export const LOOP_MODES: {
+        readonly NONE: 0;
+        readonly TRACK: 1;
+        readonly QUEUE: 2;
+    };
+
+      interface Player {
+        readonly EVENT_HANDLERS: Record<string, string>;
+    }
+      export interface TrackResolutionOptions {
+        toFront?: boolean;
+    }
+
+    // Additional Filter Preset Options
+    export interface FilterPresetOptions {
+        value?: number;
+        rate?: number;
+        pitch?: number;
+        rotationHz?: number;
+    }
+
+    // Error Extensions
+    export interface AquaError extends Error {
+        statusCode?: number;
+        statusMessage?: string;
+        headers?: Record<string, string>;
+        body?: any;
+    }
+
+    // Save/Load Player Data Interfaces
+    export interface SavedPlayerData {
+        g: string; // guildId
+        t: string; // textChannel
+        v: string; // voiceChannel
+        u: string | null; // uri
+        p: number; // position
+        ts: number; // timestamp
+        q: string[]; // queue uris
+        r: string | null; // requester
+        vol: number; // volume
+        pa: boolean; // paused
+        pl: boolean; // playing
+        nw: string | null; // nowPlayingMessage id
     }
 }