ryanlink 1.0.2 → 2.0.0

package/dist/index.d.ts

@@ -1,441 +1,655 @@
 import { EventEmitter } from 'node:events';
+import { ReadableStream } from 'node:stream/web';
 
-declare const DefaultRestOptions: {
-    readonly version: 4;
-    readonly userAgent: `${string}/${string} (${string})`;
-    readonly stackTrace: false;
-    readonly requestTimeout: 10000;
+declare enum DebugEvents {
+    SetSponsorBlock = "SetSponsorBlock",
+    DeleteSponsorBlock = "DeleteSponsorBlock",
+    TrackEndReplaced = "TrackEndReplaced",
+    AutoplayExecution = "AutoplayExecution",
+    AutoplayNoSongsAdded = "AutoplayNoSongsAdded",
+    AutoplayThresholdSpamLimiter = "AutoplayThresholdSpamLimiter",
+    TriggerQueueEmptyInterval = "TriggerQueueEmptyInterval",
+    QueueEnded = "QueueEnded",
+    TrackStartNewSongsOnly = "TrackStartNewSongsOnly",
+    TrackStartNoTrack = "TrackStartNoTrack",
+    ResumingFetchingError = "ResumingFetchingError",
+    PlayerUpdateNoPlayer = "PlayerUpdateNoPlayer",
+    PlayerUpdateFilterFixApply = "PlayerUpdateFilterFixApply",
+    PlayerUpdateSuccess = "PlayerUpdateSuccess",
+    HeartBeatTriggered = "HeartBeatTriggered",
+    NoSocketOnDestroy = "NoSocketOnDestroy",
+    SocketCleanupError = "SocketCleanupError",
+    SocketTerminateHeartBeatTimeout = "SocketTerminateHeartBeatTimeout",
+    TryingConnectWhileConnected = "TryingConnectWhileConnected",
+    SearchNothingFound = "SearchNothingFound",
+    ValidatingBlacklistLinks = "ValidatingBlacklistLinks",
+    ValidatingWhitelistLinks = "ValidatingWhitelistLinks",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime",
+    PlayerDestroyingSomewhereElse = "PlayerDestroyingSomewhereElse",
+    PlayerCreateNodeNotFound = "PlayerCreateNodeNotFound",
+    PlayerPlayQueueEmptyTimeoutClear = "PlayerPlayQueueEmptyTimeoutClear",
+    PlayerPlayWithTrackReplace = "PlayerPlayWithTrackReplace",
+    PlayerPlayUnresolvedTrack = "PlayerPlayUnresolvedTrack",
+    PlayerPlayUnresolvedTrackFailed = "PlayerPlayUnresolvedTrackFailed",
+    PlayerVolumeAsFilter = "PlayerVolumeAsFilter",
+    BandcampSearchLokalEngine = "BandcampSearchLokalEngine",
+    PlayerChangeNode = "PlayerChangeNode",
+    BuildTrackError = "BuildTrackError",
+    TransformRequesterFunctionFailed = "TransformRequesterFunctionFailed",
+    GetClosestTrackFailed = "GetClosestTrackFailed",
+    PlayerDeleteInsteadOfDestroy = "PlayerDeleteInsteadOfDestroy",
+    FailedToConnectToNodes = "FailedToConnectToNodes",
+    NoAudioDebug = "NoAudioDebug",
+    PlayerAutoReconnect = "PlayerAutoReconnect",
+    PlayerDestroyFail = "PlayerDestroyFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail"
+}
+declare enum DestroyReasons {
+    QueueEmpty = "QueueEmpty",
+    NodeDestroy = "NodeDestroy",
+    NodeDeleted = "NodeDeleted",
+    NodeNoVoice = "NodeNoVoice",
+    NodeReconnectFail = "NodeReconnectFail",
+    Disconnected = "Disconnected",
+    PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
+    ChannelDeleted = "ChannelDeleted",
+    DisconnectAllNodes = "DisconnectAllNodes",
+    ReconnectAllNodes = "ReconnectAllNodes",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime"
+}
+declare enum DisconnectReasons {
+    Disconnected = "Disconnected",
+    DisconnectAllNodes = "DisconnectAllNodes"
+}
+declare const validSponsorBlocks: string[];
+declare const audioOutputsData: Record<AudioOutputs, ChannelMixFilter>;
+declare const EQList: {
+    BassboostEarrape: EQBand[];
+    BassboostHigh: EQBand[];
+    BassboostMedium: EQBand[];
+    BassboostLow: EQBand[];
+    BetterMusic: EQBand[];
+    Rock: EQBand[];
+    Classic: EQBand[];
+    Pop: EQBand[];
+    Electronic: EQBand[];
+    FullSound: EQBand[];
+    Gaming: EQBand[];
 };
-declare const DefaultNodeOptions: {
-    readonly statsInterval: 60000;
-    readonly highestLatency: 2000;
-    readonly reconnectDelay: 10000;
-    readonly reconnectLimit: 3;
-    readonly handshakeTimeout: 5000;
+declare const RecommendationsStrings: {
+    highCPULoad: (cpuLoad: number) => string;
+    highSystemLoad: (systemLoad: number) => string;
+    highMemoryUsage: (memoryUsagePercent: number) => string;
+    frameDeficit: (frameDeficit: number) => string;
+    highLatency: (ping: number) => string;
+    nodeRestart: string;
+    highPlayercount: (players: number) => string;
+    nodeOffline: string;
+    checkConnectivity: string;
 };
-declare const DefaultPlayerOptions: {
-    readonly autoInit: true;
-    readonly autoSync: true;
-    readonly queryPrefix: "ytsearch";
-    readonly relocateQueues: true;
-    readonly fetchRelatedTracks: () => Promise<never[]>;
-};
-declare const DefaultQueueOptions: {
-    readonly volume: 100;
-    readonly repeatMode: "none";
-    readonly autoplay: false;
-    readonly paused: false;
-};
-declare const DefaultFilterOptions: {
-    readonly volume: 1;
-    readonly equalizer: {
-        band: number;
-        gain: number;
-    }[];
-    readonly karaoke: {
-        level?: number | undefined;
-        monoLevel?: number | undefined;
-        filterBand?: number | undefined;
-        filterWidth?: number | undefined;
-    } | null;
-    readonly timescale: {
-        speed?: number | undefined;
-        pitch?: number | undefined;
-        rate?: number | undefined;
-    } | null;
-    readonly tremolo: {
-        frequency?: number | undefined;
-        depth?: number | undefined;
-    } | null;
-    readonly vibrato: {
-        frequency?: number | undefined;
-        depth?: number | undefined;
-    } | null;
-    readonly rotation: {
-        rotationHz?: number | undefined;
-    } | null;
-    readonly distortion: {
-        sinOffset?: number | undefined;
-        sinScale?: number | undefined;
-        cosOffset?: number | undefined;
-        cosScale?: number | undefined;
-        tanOffset?: number | undefined;
-        tanScale?: number | undefined;
-        offset?: number | undefined;
-        scale?: number | undefined;
-    } | null;
-    readonly channelMix: {
-        leftToLeft?: number | undefined;
-        leftToRight?: number | undefined;
-        rightToLeft?: number | undefined;
-        rightToRight?: number | undefined;
-    } | null;
-    readonly lowPass: {
-        smoothing?: number | undefined;
-    } | null;
-};
-declare const HttpStatusCodes: Readonly<{
-    readonly OK: 200;
-    readonly CREATED: 201;
-    readonly NO_CONTENT: 204;
-    readonly BAD_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly FORBIDDEN: 403;
-    readonly NOT_FOUND: 404;
-    readonly METHOD_NOT_ALLOWED: 405;
-    readonly TOO_MANY_REQUESTS: 429;
-    readonly INTERNAL_SERVER_ERROR: 500;
-    readonly BAD_GATEWAY: 502;
-    readonly SERVICE_UNAVAILABLE: 503;
-    readonly GATEWAY_TIMEOUT: 504;
-}>;
-declare const WebSocketCloseCodes: Readonly<{
-    readonly NORMAL: 1000;
-    readonly GOING_AWAY: 1001;
-    readonly PROTOCOL_ERROR: 1002;
-    readonly UNSUPPORTED_DATA: 1003;
-    readonly NO_STATUS_RECEIVED: 1005;
-    readonly ABNORMAL_CLOSURE: 1006;
-    readonly INVALID_FRAME_PAYLOAD_DATA: 1007;
-    readonly POLICY_VIOLATION: 1008;
-    readonly MESSAGE_TOO_BIG: 1009;
-    readonly INTERNAL_ERROR: 1011;
-}>;
-
-interface EQBand {
-    band: number;
-    gain: number;
-}
-declare const EQPresets: {
-    readonly BassboostEarrape: EQBand[];
-    readonly BassboostHigh: EQBand[];
-    readonly BassboostMedium: EQBand[];
-    readonly BassboostLow: EQBand[];
-    readonly HighQuality: EQBand[];
-    readonly BetterMusic: EQBand[];
-    readonly Rock: EQBand[];
-    readonly Classic: EQBand[];
-    readonly Pop: EQBand[];
-    readonly Electronic: EQBand[];
-    readonly FullSound: EQBand[];
-    readonly Gaming: EQBand[];
-    readonly Nightcore: EQBand[];
-    readonly Vaporwave: EQBand[];
-    readonly TrebleBass: EQBand[];
-    readonly Soft: EQBand[];
-    readonly TV: EQBand[];
-    readonly Radio: EQBand[];
-    readonly Normalization: EQBand[];
-};
-type EQPresetName = keyof typeof EQPresets;
-declare function getEQPreset(name: EQPresetName): readonly EQBand[];
-declare function getEQPresetNames(): EQPresetName[];
-declare function isValidEQPreset(name: string): name is EQPresetName;
+declare const NodeLinkExclusiveEvents: NodeLinkEventTypes[];
 
-declare const SnowflakeRegex: RegExp;
-declare const VoiceRegionIdRegex: RegExp;
-declare const UrlRegex: RegExp;
-declare const YoutubeRegex: RegExp;
-declare const SpotifyRegex: RegExp;
-declare const SoundCloudRegex: RegExp;
-declare const BandcampRegex: RegExp;
-declare const TwitchRegex: RegExp;
-declare const AppleMusicRegex: RegExp;
-declare const DeezerRegex: RegExp;
-declare const AudioFileRegex: RegExp;
-declare const TidalRegex: RegExp;
-declare const YandexMusicRegex: RegExp;
-declare const AmazonMusicRegex: RegExp;
-declare const JioSaavnRegex: RegExp;
-declare const PandoraRegex: RegExp;
-declare const QobuzRegex: RegExp;
-declare const AudiomackRegex: RegExp;
-declare const MixcloudRegex: RegExp;
-declare const AnghamiRegex: RegExp;
-declare const AudiusRegex: RegExp;
-declare const GaanaRegex: RegExp;
-declare const InstagramRegex: RegExp;
-declare const ShazamRegex: RegExp;
+interface StoredQueue {
+    current: Track | null;
+    previous: Track[];
+    tracks: (Track | UnresolvedTrack)[];
+}
+interface QueueStoreManager {
+    get: (guildId: string) => Awaitable<StoredQueue | string | undefined>;
+    set: (guildId: string, value: StoredQueue | string) => Awaitable<void | boolean>;
+    delete: (guildId: string) => Awaitable<void | boolean>;
+    stringify: (value: StoredQueue | string) => Awaitable<StoredQueue | string>;
+    parse: (value: StoredQueue | string) => Awaitable<Partial<StoredQueue>>;
+}
+interface ManagerQueueOptions {
+    maxPreviousTracks?: number;
+    queueStore?: QueueStoreManager;
+    queueChangesWatcher?: QueueChangesWatcher;
+}
+interface QueueChangesWatcher {
+    tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number | number[], oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+}
 
-declare const Routes: {
-    readonly websocket: () => "/websocket";
-    readonly trackLoading: () => "/loadtracks";
-    readonly trackDecoding: (multiple?: boolean) => "/decodetrack" | "/decodetracks";
-    readonly player: (sessionId: string, guildId?: string) => string;
-    readonly session: (sessionId: string) => string;
-    readonly info: () => "/info";
-    readonly stats: () => "/stats";
-    readonly routePlanner: (free?: "address" | "all") => string;
-    readonly version: () => "/version";
+type DestroyReasonsType = keyof typeof DestroyReasons | string;
+type DisconnectReasonsType = keyof typeof DisconnectReasons | string;
+interface PlayerJson {
+    guildId: string;
+    options: PlayerOptions;
+    voiceChannelId: string;
+    textChannelId?: string;
+    position: number;
+    lastPosition: number;
+    lastPositionChange: number | null;
+    volume: number;
+    internalVolume: number;
+    repeatMode: RepeatMode;
+    paused: boolean;
+    playing: boolean;
+    createdTimeStamp?: number;
+    filters: FilterData;
+    ping: {
+        ws: number;
+        node: number;
+    };
+    equalizer: EQBand[];
+    nodeId?: string;
+    nodeSessionId?: string;
+    queue?: StoredQueue;
+}
+type RepeatMode = 'queue' | 'track' | 'off';
+interface PlayerOptions {
+    guildId: string;
+    voiceChannelId: string;
+    textChannelId?: string;
+    volume?: number;
+    vcRegion?: string;
+    selfDeaf?: boolean;
+    selfMute?: boolean;
+    node?: RyanlinkNode | string;
+    instaFixFilter?: boolean;
+    autoPauseOnMute?: boolean;
+    applyVolumeAsFilter?: boolean;
+    customData?: anyObject;
+}
+type anyObject = {
+    [key: string | number]: string | number | null | anyObject;
 };
-type RouteReturnType<T extends keyof typeof Routes> = ReturnType<(typeof Routes)[T]>;
-
-declare const LookupSymbol: unique symbol;
-declare const UpdateSymbol: unique symbol;
-declare const OnPingUpdateSymbol: unique symbol;
-declare const OnVoiceCloseSymbol: unique symbol;
-declare const OnStateUpdateSymbol: unique symbol;
-declare const OnEventUpdateSymbol: unique symbol;
-
-declare const noop: () => void;
-declare const formatDuration: (ms: number) => string;
-declare const parseDuration: (duration: string) => number;
-declare const clamp: (value: number, min: number, max: number) => number;
-declare const sleep: (ms: number) => Promise<void>;
-declare const retry: <T>(fn: () => Promise<T>, maxAttempts?: number, baseDelay?: number) => Promise<T>;
-declare const shuffle: <T>(array: T[]) => T[];
-declare const randomElement: <T>(array: T[]) => T | undefined;
-declare const chunk: <T>(array: T[], size: number) => T[][];
-declare const unique: <T>(array: T[], key?: (item: T) => unknown) => T[];
-
-declare class REST {
-    #private;
-    readonly userAgent: string;
-    constructor(options: RESTOptions);
-    get origin(): string;
-    get sessionId(): string | null;
-    set sessionId(value: string | null);
-    loadTracks(identifier: string): Promise<LoadResult>;
-    decodeTrack(encoded: string): Promise<APITrack>;
-    decodeTracks(encoded: string[]): Promise<APITrack[]>;
-    fetchPlayers(): Promise<APIPlayer[]>;
-    fetchPlayer(guildId: string): Promise<APIPlayer>;
-    updatePlayer(guildId: string, data: PlayerUpdateRequestBody, params?: PlayerUpdateQueryParams): Promise<APIPlayer>;
-    destroyPlayer(guildId: string): Promise<void>;
-    updateSession(data: SessionUpdateRequestBody): Promise<SessionUpdateResponseBody>;
-    fetchInfo(): Promise<LavalinkInfo>;
-    fetchStats(): Promise<NodeStats>;
-    fetchVersion(): Promise<string>;
-    fetchRoutePlannerStatus(): Promise<RoutePlannerStatus>;
-    freeRoutePlannerAddress(address: string): Promise<void>;
-    freeAllRoutePlannerAddresses(): Promise<void>;
-    setSponsorBlock(guildId: string, segments: string[]): Promise<void>;
-    getSponsorBlock(guildId: string): Promise<string[]>;
-    deleteSponsorBlock(guildId: string): Promise<void>;
+interface BasePlayOptions {
+    position?: number;
+    endTime?: number;
+    paused?: boolean;
+    volume?: number;
+    filters?: Partial<AudioFilters>;
+    voice?: VoiceConnectionOptions;
 }
-
-interface RESTOptions {
-    origin?: string;
-    host?: string;
-    port?: number;
-    secure?: boolean;
-    password: string;
-    version?: number;
-    userAgent?: string;
-    sessionId?: string;
-    stackTrace?: boolean;
-    requestTimeout?: number;
+interface PlayConfiguration extends BasePlayOptions {
+    track?: {
+        encoded?: Base64 | null;
+        identifier?: string;
+        userData?: anyObject;
+        requester?: unknown;
+        audioTrackId?: string;
+    };
+    nextTrack?: {
+        encoded?: Base64 | null;
+        userData?: anyObject;
+    };
 }
-
-declare const enum Severity {
-    Common = "common",
-    Suspicious = "suspicious",
-    Fault = "fault"
-}
-declare const enum OPType {
-    Ready = "ready",
-    PlayerUpdate = "playerUpdate",
-    Stats = "stats",
-    Event = "event"
-}
-declare const enum EventType {
-    TrackStart = "TrackStartEvent",
-    TrackEnd = "TrackEndEvent",
-    TrackException = "TrackExceptionEvent",
-    TrackStuck = "TrackStuckEvent",
-    WebSocketClosed = "WebSocketClosedEvent"
-}
-declare const enum TrackEndReason {
-    Finished = "finished",
-    LoadFailed = "loadFailed",
-    Stopped = "stopped",
-    Replaced = "replaced",
-    Cleanup = "cleanup"
-}
-interface BaseMessagePayload {
-    op: OPType | string;
-}
-interface ReadyPayload extends BaseMessagePayload {
-    op: OPType.Ready;
-    resumed: boolean;
-    sessionId: string;
+interface PlayOptions extends PlayConfiguration {
+    noReplace?: boolean;
+    clientTrack?: (Track | UnresolvedTrack) & {
+        audioTrackId?: string;
+    };
 }
-interface PlayerUpdatePayload extends BaseMessagePayload {
-    op: OPType.PlayerUpdate;
-    guildId: string;
-    state: PlayerState;
+
+type CoreSourceNames = 'youtube' | 'youtubemusic' | 'soundcloud' | 'bandcamp' | 'twitch' | 'jiosaavn';
+type AudioSourceNames = 'deezer' | 'spotify' | 'applemusic' | 'yandexmusic' | 'flowery-tts' | 'vkmusic' | 'tidal' | 'qobuz' | 'pandora' | CoreSourceNames;
+interface AudioTrackInfo {
+    identifier: string;
+    title: string;
+    author: string;
+    length: number;
+    artworkUrl: string | null;
+    uri: string;
+    sourceName: AudioSourceNames;
+    isSeekable: boolean;
+    isStream: boolean;
+    isrc: string | null;
 }
-interface PlayerState {
-    time: number;
-    position: number;
-    connected: boolean;
-    ping: number;
+interface TrackInfo {
+    identifier: string;
+    title: string;
+    author: string;
+    duration: number;
+    artworkUrl: string | null;
+    uri: string;
+    sourceName: AudioSourceNames;
+    isSeekable: boolean;
+    isStream: boolean;
+    isrc: string | null;
 }
-interface StatsPayload extends BaseMessagePayload, NodeStats {
-    op: OPType.Stats;
+interface PluginInfo {
+    type?: 'album' | 'playlist' | 'artist' | 'recommendations' | string;
+    albumName?: string;
+    albumUrl?: string;
+    albumArtUrl?: string;
+    artistUrl?: string;
+    artistArtworkUrl?: string;
+    previewUrl?: string;
+    isPreview?: boolean;
+    totalTracks?: number;
+    identifier?: string;
+    artworkUrl?: string;
+    author?: string;
+    url?: string;
+    uri?: string;
+    clientData?: {
+        previousTrack?: boolean;
+        [key: string]: any;
+    };
 }
-interface NodeStats {
-    players: number;
-    playingPlayers: number;
-    uptime: number;
-    memory: NodeMemory;
-    cpu: NodeCPU;
-    frameStats: FrameStats | null;
+interface AudioTrack {
+    encoded?: Base64;
+    info: AudioTrackInfo;
+    pluginInfo: Partial<PluginInfo>;
+    userData?: anyObject;
 }
-interface NodeMemory {
-    free: number;
-    used: number;
-    allocated: number;
-    reservable: number;
+interface TrackRequester {
 }
-interface NodeCPU {
-    cores: number;
-    systemLoad: number;
-    lavalinkLoad: number;
+interface Track {
+    encoded?: Base64;
+    info: TrackInfo;
+    pluginInfo: Partial<PluginInfo>;
+    requester?: TrackRequester;
+    userData?: anyObject;
 }
-interface FrameStats {
-    sent: number;
-    nulled: number;
-    deficit: number;
+interface UnresolvedTrackInfo extends Partial<TrackInfo> {
+    title: string;
 }
-interface BaseEventPayload extends BaseMessagePayload {
-    op: OPType.Event;
-    type: EventType | string;
-    guildId: string;
+interface UnresolvedQuery extends UnresolvedTrackInfo {
+    encoded?: Base64;
 }
-interface TrackStartEventPayload extends BaseEventPayload {
-    type: EventType.TrackStart;
-    track: APITrack;
+interface UnresolvedTrack {
+    resolve: (player: Player) => Promise<void>;
+    encoded?: Base64;
+    info: UnresolvedTrackInfo;
+    pluginInfo: Partial<PluginInfo>;
+    userData?: anyObject;
+    requester?: TrackRequester;
 }
-interface TrackEndEventPayload extends BaseEventPayload {
-    type: EventType.TrackEnd;
-    track: APITrack;
-    reason: TrackEndReason;
+
+declare const AudioTrackSymbol: unique symbol;
+declare const UnresolvedAudioTrackSymbol: unique symbol;
+declare const AudioQueueSymbol: unique symbol;
+declare const AudioNodeSymbol: unique symbol;
+declare function parseConnectionUrl(connectionUrl: string): {
+    authorization: string;
+    nodeType: NodeTypes;
+    id: string;
+    host: string;
+    port: number;
+};
+declare class RyanlinkUtils {
+    RyanlinkManager: RyanlinkManager | undefined;
+    constructor(RyanlinkManager?: RyanlinkManager);
+    buildPluginInfo(data: any, clientData?: any): any;
+    buildTrack(data: AudioTrack | Track, requester: unknown): Track;
+    buildUnresolvedTrack(query: UnresolvedQuery | UnresolvedTrack, requester: unknown): UnresolvedTrack;
+    isNode(data: RyanlinkNode): boolean;
+    getTransformedRequester(requester: unknown): unknown;
+    isNodeOptions(data: NodeConfiguration): boolean;
+    isNotBrokenTrack(data: Track | UnresolvedTrack, minDuration?: number): data is Track;
+    isTrack(data: Track | UnresolvedTrack): data is Track;
+    isUnresolvedTrack(data: UnresolvedTrack | Track): data is UnresolvedTrack;
+    isUnresolvedTrackQuery(data: UnresolvedQuery): boolean;
+    getClosestTrack(data: UnresolvedTrack, player: Player): Promise<Track | undefined>;
+    validateQueryString(node: RyanlinkNode, queryString: string, sourceString?: SearchPlatform): void;
+    findSourceOfQuery(queryString: string): SearchPlatform;
+    extractSourceOfQuery<T extends {
+        query: string;
+        source?: string;
+    }>(searchQuery: T): T;
+    typedLowerCase<T extends unknown>(input: T): T;
+    transformQuery(query: SearchQuery): {
+        query: string;
+        extraQueryUrlParams: any;
+        source: SearchPlatform;
+    };
+    transformAudioSearchQuery(query: AudioSearchQuery): {
+        query: never;
+        types: any[];
+        extraQueryUrlParams: any;
+        source: SearchPlatform;
+    } | {
+        query: string;
+        types: string[];
+        source: "ytsearch" | "ytmsearch" | "scsearch" | "bcsearch" | "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "dzrec" | "ymsearch" | "ymrec" | "vksearch" | "vkrec" | "tdsearch" | "tdrec" | "qbsearch" | "qbisrc" | "qbrec" | "pdsearch" | "pdisrc" | "pdrec" | "ftts" | "speak" | "phsearch" | "pornhub" | "porn" | "tts" | "jssearch" | "jsrec" | "admsearch" | "admrec" | "shsearch" | "igsearch" | "blsearch" | "lfsearch" | "amzsearch" | "amzrec" | "gnsearch" | "gnrec" | "local" | "http" | "https" | "link" | "uri" | "youtube" | "yt" | "youtube music" | "youtubemusic" | "ytm" | "musicyoutube" | "music youtube" | "soundcloud" | "sc" | "am" | "apple music" | "applemusic" | "apple" | "musicapple" | "music apple" | "sp" | "spsuggestion" | "spotify" | "spotify.com" | "spotifycom" | "dz" | "deezer" | "yandex" | "yandex music" | "yandexmusic" | "vk" | "vk music" | "vkmusic" | "tidal" | "tidal music" | "qobuz" | "pandora" | "pd" | "pandora music" | "pandoramusic" | "flowerytts" | "flowery" | "flowery.tts" | "bandcamp" | "bc" | "js" | "jiosaavn" | "td" | "audiomack" | "adm" | "shazam" | "sh" | "instagram" | "ig" | "bilibili" | "bl" | "lastfm" | "last.fm" | "lf" | "amazon music" | "amazonmusic" | "amz" | "gaana" | "gn";
+    };
+    validateSourceString(node: RyanlinkNode, sourceString: SearchPlatform): void;
+}
+interface MiniMap<K, V> extends Map<K, V> {
+    constructor: MiniMapConstructor;
+}
+declare class MiniMap<K, V> extends Map<K, V> {
+    constructor(data?: [K, V][]);
+    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>;
+    toJSON(): [K, V][];
+    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[];
+}
+declare function queueTrackEnd(player: Player, dontShiftQueue?: boolean): Promise<Track>;
+declare function safeStringify(obj: any, padding?: number): string;
+
+type Opaque<T, K> = T & {
+    __opaque__: K;
+};
+type IntegerNumber = Opaque<number, 'Int'>;
+type FloatNumber = Opaque<number, 'Float'>;
+type SourceSearchPlatformBase = 'spsearch' | 'sprec' | 'amsearch' | 'dzsearch' | 'dzisrc' | 'dzrec' | 'ymsearch' | 'ymrec' | 'vksearch' | 'vkrec' | 'tdsearch' | 'tdrec' | 'qbsearch' | 'qbisrc' | 'qbrec' | 'pdsearch' | 'pdisrc' | 'pdrec';
+type SourceSearchPlatform = SourceSearchPlatformBase | 'ftts';
+type JioSaavnSearchPlatform = 'jssearch' | 'jsrec';
+type DuncteSearchPlatform = 'speak' | 'phsearch' | 'pornhub' | 'porn' | 'tts';
+type ExtendedSearchPlatform = 'admsearch' | 'admrec' | 'shsearch' | 'igsearch' | 'blsearch' | 'lfsearch' | 'amzsearch' | 'amzrec' | 'gnsearch' | 'gnrec';
+type AudioClientSearchPlatform = 'bcsearch';
+type AudioClientSearchPlatformResolve = 'bandcamp' | 'bc';
+type RyanlinkSearchPlatform = 'ytsearch' | 'ytmsearch' | 'scsearch' | 'bcsearch' | SourceSearchPlatform | DuncteSearchPlatform | JioSaavnSearchPlatform | ExtendedSearchPlatform | AudioClientSearchPlatform;
+type ClientCustomSearchPlatformUtils = 'local' | 'http' | 'https' | 'link' | 'uri';
+type ClientSearchPlatform = ClientCustomSearchPlatformUtils | 'youtube' | 'yt' | 'youtube music' | 'youtubemusic' | 'ytm' | 'musicyoutube' | 'music youtube' | 'soundcloud' | 'sc' | 'am' | 'apple music' | 'applemusic' | 'apple' | 'musicapple' | 'music apple' | 'sp' | 'spsuggestion' | 'spotify' | 'spotify.com' | 'spotifycom' | 'dz' | 'deezer' | 'yandex' | 'yandex music' | 'yandexmusic' | 'vk' | 'vk music' | 'vkmusic' | 'tidal' | 'tidal music' | 'qobuz' | 'pandora' | 'pd' | 'pandora music' | 'pandoramusic' | 'flowerytts' | 'flowery' | 'flowery.tts' | AudioClientSearchPlatformResolve | AudioClientSearchPlatform | 'js' | 'jiosaavn' | 'td' | 'tidal' | 'tdrec' | 'audiomack' | 'adm' | 'admsearch' | 'shazam' | 'sh' | 'shsearch' | 'instagram' | 'ig' | 'igsearch' | 'bilibili' | 'bl' | 'blsearch' | 'lastfm' | 'last.fm' | 'lf' | 'lfsearch' | 'amazon music' | 'amazonmusic' | 'amz' | 'amzsearch' | 'gaana' | 'gn' | 'gnsearch' | 'td' | 'tidal' | 'tdrec';
+type SearchPlatform = RyanlinkSearchPlatform | ClientSearchPlatform;
+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' | 'jiosaavn' | 'appleMusic' | 'tidal' | 'PandoraTrackRegex' | 'PandoraAlbumRegex' | 'PandoraArtistRegex' | 'PandoraPlaylistRegex' | 'AllPandoraRegex' | 'TwitchTv' | 'vimeo';
+interface PlaylistInfo {
+    name: string;
+    title: string;
+    author?: string;
+    thumbnail?: string;
+    uri?: string;
+    selectedTrack: Track | null;
+    duration: number;
 }
-interface TrackExceptionEventPayload extends BaseEventPayload {
-    type: EventType.TrackException;
-    track: APITrack;
-    exception: Exception;
+interface SearchResult {
+    loadType: LoadTypes;
+    exception: Exception | null;
+    pluginInfo: PluginInfo;
+    playlist: PlaylistInfo | null;
+    tracks: Track[];
 }
+interface UnresolvedSearchResult {
+    loadType: LoadTypes;
+    exception: Exception | null;
+    pluginInfo: PluginInfo;
+    playlist: PlaylistInfo | null;
+    tracks: UnresolvedTrack[];
+}
+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;
+}
+type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents | LyricsEvent;
+type Severity = 'COMMON' | 'SUSPICIOUS' | 'FAULT';
 interface Exception {
-    message: string | null;
     severity: Severity;
+    error?: Error;
+    message: string;
     cause: string;
     causeStackTrace: string;
 }
-interface TrackStuckEventPayload extends BaseEventPayload {
-    type: EventType.TrackStuck;
-    track: APITrack;
+interface PlayerEvent {
+    op: 'event';
+    type: PlayerEventType;
+    guildId: string;
+}
+interface TrackStartEvent extends PlayerEvent {
+    type: 'TrackStartEvent';
+    track: AudioTrack;
+}
+interface TrackEndEvent extends PlayerEvent {
+    type: 'TrackEndEvent';
+    track: AudioTrack;
+    reason: TrackEndReason;
+}
+interface TrackExceptionEvent extends PlayerEvent {
+    type: 'TrackExceptionEvent';
+    exception?: Exception;
+    track: AudioTrack;
+    error: string;
+}
+interface TrackStuckEvent extends PlayerEvent {
+    type: 'TrackStuckEvent';
     thresholdMs: number;
+    track: AudioTrack;
 }
-interface WebSocketClosedEventPayload extends BaseEventPayload {
-    type: EventType.WebSocketClosed;
+interface WebSocketClosedEvent extends PlayerEvent {
+    type: 'WebSocketClosedEvent';
     code: number;
-    reason: string;
     byRemote: boolean;
+    reason: string;
 }
-type EventPayload = TrackStartEventPayload | TrackEndEventPayload | TrackExceptionEventPayload | TrackStuckEventPayload | WebSocketClosedEventPayload;
-type MessagePayload = ReadyPayload | PlayerUpdatePayload | StatsPayload | EventPayload;
-
-declare const enum LoadType {
-    Track = "track",
-    Playlist = "playlist",
-    Search = "search",
-    Empty = "empty",
-    Error = "error"
-}
-declare const enum RoutePlannerType {
-    Rotating = "RotatingIpRoutePlanner",
-    Nano = "NanoIpRoutePlanner",
-    RotatingNano = "RotatingNanoIpRoutePlanner",
-    Balancing = "BalancingIpRoutePlanner"
-}
-declare const enum IPBlockType {
-    V4 = "Inet4Address",
-    V6 = "Inet6Address"
-}
-interface APITrack<UserData extends JsonObject = CommonUserData, PluginInfo extends JsonObject = CommonPluginInfo> {
-    encoded: string;
-    info: TrackInfo;
-    pluginInfo: PluginInfo;
-    userData: UserData;
+type SponsorBlockSegmentEvents = SponsorBlockSegmentSkipped | SponsorBlockSegmentsLoaded | SponsorBlockChapterStarted | SponsorBlockChaptersLoaded;
+type SponsorBlockSegmentEventType = 'SegmentSkipped' | 'SegmentsLoaded' | 'ChaptersLoaded' | 'ChapterStarted';
+interface SponsorBlockSegmentsLoaded extends PlayerEvent {
+    type: 'SegmentsLoaded';
+    segments: {
+        category: string;
+        start: number;
+        end: number;
+    }[];
 }
-interface TrackInfo {
-    identifier: string;
-    isSeekable: boolean;
-    author: string;
-    length: number;
-    isStream: boolean;
-    position: number;
-    title: string;
-    uri: string | null;
-    artworkUrl: string | null;
-    isrc: string | null;
-    sourceName: string;
+interface SponsorBlockSegmentSkipped extends PlayerEvent {
+    type: 'SegmentSkipped';
+    segment: {
+        category: string;
+        start: number;
+        end: number;
+    };
 }
-interface PlaylistInfo {
-    name: string;
-    selectedTrack: number;
+interface SponsorBlockChapterStarted extends PlayerEvent {
+    type: 'ChapterStarted';
+    chapter: {
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    };
 }
-interface TrackLoadResult {
-    loadType: LoadType.Track;
-    data: APITrack;
+interface SponsorBlockChaptersLoaded extends PlayerEvent {
+    type: 'ChaptersLoaded';
+    chapters: {
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    }[];
 }
-interface APIPlaylist<PluginInfo extends JsonObject = CommonPluginInfo> {
-    info: PlaylistInfo;
-    pluginInfo: PluginInfo;
-    tracks: APITrack[];
+type LyricsEvent = LyricsFoundEvent | LyricsNotFoundEvent | LyricsLineEvent;
+type LyricsEventType = 'LyricsFoundEvent' | 'LyricsNotFoundEvent' | 'LyricsLineEvent';
+interface LyricsFoundEvent extends PlayerEvent {
+    type: 'LyricsFoundEvent';
+    guildId: string;
+    lyrics: LyricsResult;
+}
+interface LyricsNotFoundEvent extends PlayerEvent {
+    type: 'LyricsNotFoundEvent';
+    guildId: string;
 }
-interface PlaylistLoadResult {
-    loadType: LoadType.Playlist;
-    data: APIPlaylist;
+interface LyricsLineEvent extends PlayerEvent {
+    type: 'LyricsLineEvent';
+    guildId: string;
+    lineIndex: number;
+    line: LyricsLine;
+    skipped: boolean;
+}
+type LoadTypes = 'track' | 'playlist' | 'search' | 'error' | 'empty';
+type State = 'CONNECTED' | 'CONNECTING' | 'DISCONNECTED' | 'DISCONNECTING' | 'DESTROYING';
+type PlayerEventType = 'TrackStartEvent' | 'TrackEndEvent' | 'TrackExceptionEvent' | 'TrackStuckEvent' | 'WebSocketClosedEvent' | SponsorBlockSegmentEventType | LyricsEventType;
+type TrackEndReason = 'finished' | 'loadFailed' | 'stopped' | 'replaced' | 'cleanup';
+interface InvalidRestRequest {
+    timestamp: number;
+    status: number;
+    error: string;
+    message?: string;
+    trace?: unknown;
+    path: string;
+}
+interface VoiceConnectionState {
+    token: string;
+    endpoint: string;
+    sessionId: string;
+    channelId?: string;
+    connected?: boolean;
+    ping?: number;
+}
+type VoiceConnectionOptions = Omit<VoiceConnectionState, 'connected' | 'ping'>;
+interface FailingAddress {
+    failingAddress: string;
+    failingTimestamp: number;
+    failingTime: string;
+}
+type RoutePlannerTypes = 'RotatingIpRoutePlanner' | 'NanoIpRoutePlanner' | 'RotatingNanoIpRoutePlanner' | 'BalancingIpRoutePlanner';
+interface RoutePlanner {
+    class?: RoutePlannerTypes;
+    details?: {
+        ipBlock: {
+            type: 'Inet4Address' | 'Inet6Address';
+            size: string;
+        };
+        failingAddresses: FailingAddress[];
+        rotateIndex?: string;
+        ipIndex?: string;
+        currentAddress?: string;
+        currentAddressIndex?: string;
+        blockIndex?: string;
+    };
 }
-interface SearchLoadResult {
-    loadType: LoadType.Search;
-    data: APITrack[];
+interface Session {
+    resuming: boolean;
+    timeout: number;
 }
-interface EmptyLoadResult {
-    loadType: LoadType.Empty;
-    data: EmptyObject;
+interface GuildShardPayload {
+    op: number;
+    d: {
+        guild_id: string;
+        channel_id: string | null;
+        self_mute: boolean;
+        self_deaf: boolean;
+    };
 }
-interface ErrorLoadResult {
-    loadType: LoadType.Error;
-    data: Exception;
+interface PlayerUpdateInfo {
+    guildId: string;
+    playerOptions: PlayConfiguration;
+    noReplace?: boolean;
 }
-type LoadResult = TrackLoadResult | PlaylistLoadResult | SearchLoadResult | EmptyLoadResult | ErrorLoadResult;
-interface APIPlayer {
+interface AudioPlayerState {
     guildId: string;
-    track: APITrack | null;
+    track?: AudioTrack;
     volume: number;
     paused: boolean;
-    state: PlayerState;
-    voice: APIVoiceState;
-    filters: Filters;
+    voice: VoiceConnectionState;
+    filters: Partial<AudioFilters>;
+    state: {
+        time: number;
+        position: number;
+        connected: boolean;
+        ping: number;
+    };
+}
+interface ChannelDeletePacket {
+    t: 'CHANNEL_DELETE';
+    d: {
+        guild_id: string;
+        id: string;
+    };
 }
-interface APIVoiceState {
+interface VoiceState {
+    op: 'voiceUpdate';
+    guildId: string;
+    event: VoiceServer;
+    sessionId?: string;
+    guild_id: string;
+    user_id: string;
+    session_id: string;
+    channel_id: string;
+    mute: boolean;
+    deaf: boolean;
+    self_deaf: boolean;
+    self_mute: boolean;
+    self_video: boolean;
+    self_stream: boolean;
+    request_to_speak_timestamp: boolean;
+    suppress: boolean;
+}
+type Base64 = string;
+interface VoiceServer {
     token: string;
+    guild_id: string;
     endpoint: string;
-    sessionId: string;
-    channelId: string | null;
+    channel_id?: string;
 }
-interface Filters<PluginFilters extends JsonObject = CommonPluginFilters> {
-    volume?: number;
-    equalizer?: EqualizerFilter;
-    karaoke?: KaraokeFilter;
-    timescale?: TimescaleFilter;
-    tremolo?: TremoloFilter;
-    vibrato?: VibratoFilter;
-    rotation?: RotationFilter;
-    distortion?: DistortionFilter;
-    channelMix?: ChannelMixFilter;
-    lowPass?: LowPassFilter;
-    pluginFilters?: PluginFilters;
+interface VoicePacket {
+    t?: 'VOICE_SERVER_UPDATE' | 'VOICE_STATE_UPDATE';
+    d: VoiceState | VoiceServer;
 }
-interface EqualizerBand {
-    band: number;
-    gain: number;
+interface NodeMessage extends NodeStats {
+    type: PlayerEventType;
+    op: 'stats' | 'playerUpdate' | 'event';
+    guildId: string;
+}
+type AudioSearchType = 'track' | 'album' | 'artist' | 'playlist' | 'text' | 'tracks' | 'albums' | 'artists' | 'playlists' | 'texts';
+interface AudioSearchFilteredResponse {
+    info: PlaylistInfo;
+    pluginInfo: PluginInfo;
+    tracks: Track[];
+}
+interface AudioSearchResponse {
+    tracks: Track[];
+    albums: AudioSearchFilteredResponse[];
+    artists: AudioSearchFilteredResponse[];
+    playlists: AudioSearchFilteredResponse[];
+    texts: {
+        text: string;
+        pluginInfo: PluginInfo;
+    }[];
+    pluginInfo: PluginInfo;
+}
+type SearchQuery = {
+    query: string;
+    extraQueryUrlParams?: URLSearchParams;
+    source?: SearchPlatform;
+} | string;
+type AudioSearchQuery = {
+    query: string;
+    source: SourceSearchPlatformBase;
+    types?: AudioSearchType[];
+};
+type Awaitable<T> = Promise<T> | T;
+
+type AudioOutputs = 'mono' | 'stereo' | 'left' | 'right';
+interface PlayerFilters {
+    custom: boolean;
+    nightcore: boolean;
+    vaporwave: boolean;
+    rotation: boolean;
+    karaoke: boolean;
+    tremolo: boolean;
+    vibrato: boolean;
+    lowPass: boolean;
+    audioOutput: AudioOutputs;
+    nodeLinkEcho: boolean;
+    nodeLinkChorus: boolean;
+    nodeLinkCompressor: boolean;
+    nodeLinkHighPass: boolean;
+    nodeLinkPhaser: boolean;
+    nodeLinkSpatial: boolean;
+    volume: boolean;
+    coreFilterPlugin: {
+        echo: boolean;
+        reverb: boolean;
+    };
+    dspxPlugin: {
+        lowPass: boolean;
+        highPass: boolean;
+        normalization: boolean;
+        echo: boolean;
+    };
+}
+interface EQBand {
+    band: IntegerNumber | number;
+    gain: FloatNumber | number;
 }
-type EqualizerFilter = EqualizerBand[];
 interface KaraokeFilter {
     level?: number;
     monoLevel?: number;
@@ -474,445 +688,589 @@ interface ChannelMixFilter {
     rightToLeft?: number;
     rightToRight?: number;
 }
-interface LowPassFilter {
-    smoothing?: number;
-}
-interface PlayerUpdateQueryParams {
-    noReplace?: boolean;
-}
-interface PlayerUpdateRequestBody {
-    track?: PlayerUpdateTrackData;
-    position?: number;
-    endTime?: number | null;
-    volume?: number;
-    paused?: boolean;
-    filters?: Filters;
-    voice?: NonNullableProp<APIVoiceState, "channelId">;
+interface NodeLink_EchoFilter {
+    delay?: number;
+    feedback?: number;
+    mix?: number;
 }
-interface PlayerUpdateTrackData<UserData extends JsonObject = CommonUserData> {
-    encoded?: string | null;
-    identifier?: string;
-    userData?: UserData;
-}
-interface SessionUpdateRequestBody {
-    resuming?: boolean;
-    timeout?: number;
+interface NodeLink_ChorusFilter {
+    rate?: number;
+    depth?: number;
+    delay?: number;
+    mix?: number;
+    feedback?: number;
+}
+interface NodeLink_CompressorFilter {
+    threshold?: number;
+    ratio?: number;
+    attack?: number;
+    release?: number;
+    gain?: number;
+}
+interface NodeLink_HighPassFilter {
+    smoothing?: number;
 }
-type SessionUpdateResponseBody = Required<SessionUpdateRequestBody>;
-interface LavalinkInfo {
-    version: LavalinkVersion;
-    buildTime: number;
-    git: LavalinkGit;
-    jvm: string;
-    lavaplayer: string;
-    sourceManagers: string[];
-    filters: string[];
-    plugins: LavalinkPlugin[];
+interface NodeLink_PhaserFilter {
+    stages?: number;
+    rate?: number;
+    depth?: number;
+    feedback?: number;
+    mix?: number;
+    minFrequency?: number;
+    maxFrequency?: number;
 }
-interface LavalinkVersion {
-    semver: string;
-    major: number;
-    minor: number;
-    patch: number;
-    preRelease: string | null;
-    build: string | null;
+interface NodeLink_SpatialFilter {
+    depth?: number;
+    rate?: number;
 }
-interface LavalinkGit {
-    branch: string;
-    commit: string;
-    commitTime: number;
+interface LowPassFilter {
+    smoothing?: number;
 }
-interface LavalinkPlugin {
-    name: string;
-    version: string;
+interface FilterData {
+    volume?: number;
+    karaoke?: KaraokeFilter;
+    timescale?: TimescaleFilter;
+    tremolo?: TremoloFilter;
+    vibrato?: VibratoFilter;
+    rotation?: RotationFilter;
+    distortion?: DistortionFilter;
+    channelMix?: ChannelMixFilter;
+    lowPass?: LowPassFilter;
+    echo?: NodeLink_EchoFilter;
+    chorus?: NodeLink_ChorusFilter;
+    compressor?: NodeLink_CompressorFilter;
+    highPass?: NodeLink_HighPassFilter;
+    phaser?: NodeLink_PhaserFilter;
+    spatial?: NodeLink_SpatialFilter;
+    pluginFilters?: {
+        'filter-engine'?: {
+            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;
+        };
+    };
 }
-interface IPBlock {
-    type: IPBlockType;
-    size: string;
+interface AudioFilters extends FilterData {
+    equalizer?: EQBand[];
 }
-interface FailingAddress {
-    failingAddress: string;
-    failingTimestamp: number;
-    failingTime: string;
+
+type NodeLinkEventTypes = 'PlayerCreatedEvent' | 'PlayerDestroyedEvent' | 'PlayerConnectedEvent' | 'PlayerReconnectingEvent' | 'VolumeChangedEvent' | 'FiltersChangedEvent' | 'SeekEvent' | 'PauseEvent' | 'ConnectionStatusEvent' | 'MixStartedEvent' | 'MixEndedEvent' | 'LyricsFoundEvent' | 'LyricsLineEvent' | 'LyricsNotFoundEvent';
+interface NodeLinkBaseEvent {
+    op: 'event';
+    type: NodeLinkEventTypes;
+    guildId: string;
 }
-interface BaseRoutePlannerDetails {
-    ipBlock: IPBlock;
-    failingAddresses: FailingAddress[];
+interface PlayerCreatedEvent extends NodeLinkBaseEvent {
+    type: 'PlayerCreatedEvent';
 }
-interface RotatingRoutePlannerDetails extends BaseRoutePlannerDetails {
-    rotateIndex: string;
-    ipIndex: string;
-    currentAddress: string;
+interface PlayerDestroyedEvent extends NodeLinkBaseEvent {
+    type: 'PlayerDestroyedEvent';
 }
-interface NanoRoutePlannerDetails extends BaseRoutePlannerDetails {
-    currentAddressIndex: string;
+interface PlayerConnectedEvent extends NodeLinkBaseEvent {
+    type: 'PlayerConnectedEvent';
 }
-interface RotatingNanoRoutePlannerDetails extends BaseRoutePlannerDetails {
-    currentAddressIndex: string;
-    blockIndex: string;
+interface PlayerReconnectingEvent extends NodeLinkBaseEvent {
+    type: 'PlayerReconnectingEvent';
 }
-interface BalancingRoutePlannerDetails extends BaseRoutePlannerDetails {
+interface VolumeChangedEvent extends NodeLinkBaseEvent {
+    type: 'VolumeChangedEvent';
+    volume: number;
 }
-interface RotatingRoutePlannerStatus {
-    class: RoutePlannerType.Rotating;
-    details: RotatingRoutePlannerDetails;
+interface FiltersChangedEvent extends NodeLinkBaseEvent {
+    type: 'FiltersChangedEvent';
+    filters: AudioFilters;
 }
-interface NanoRoutePlannerStatus {
-    class: RoutePlannerType.Nano;
-    details: NanoRoutePlannerDetails;
+interface SeekEvent extends NodeLinkBaseEvent {
+    type: 'SeekEvent';
+    position: number;
 }
-interface RotatingNanoRoutePlannerStatus {
-    class: RoutePlannerType.RotatingNano;
-    details: RotatingNanoRoutePlannerDetails;
+interface PauseEvent extends NodeLinkBaseEvent {
+    type: 'PauseEvent';
+    paused: boolean;
 }
-interface BalancingRoutePlannerStatus {
-    class: RoutePlannerType.Balancing;
-    details: BalancingRoutePlannerDetails;
+interface ConnectionStatusEvent extends NodeLinkBaseEvent {
+    type: 'ConnectionStatusEvent';
+    connected: boolean;
 }
-interface NullishRoutePlannerStatus {
-    class: null;
-    details: null;
+interface MixStartedEvent extends NodeLinkBaseEvent {
+    type: 'MixStartedEvent';
+    mixId: string;
+    track: AudioTrack;
+    volume: number;
 }
-type RoutePlannerStatus = RotatingRoutePlannerStatus | NanoRoutePlannerStatus | RotatingNanoRoutePlannerStatus | BalancingRoutePlannerStatus | NullishRoutePlannerStatus;
+interface MixEndedEvent extends NodeLinkBaseEvent {
+    type: 'MixEndedEvent';
+    mixId: string;
+    reason: 'FINISHED' | 'REMOVED' | 'ERROR' | 'MAIN_ENDED' | string;
+}
+type NodeLinkEventPayload<T extends NodeLinkEventTypes> = T extends 'PlayerCreatedEvent' ? PlayerCreatedEvent : T extends 'PlayerDestroyedEvent' ? PlayerDestroyedEvent : T extends 'PlayerConnectedEvent' ? PlayerConnectedEvent : T extends 'PlayerReconnectingEvent' ? PlayerReconnectingEvent : T extends 'VolumeChangedEvent' ? VolumeChangedEvent : T extends 'FiltersChangedEvent' ? FiltersChangedEvent : T extends 'SeekEvent' ? SeekEvent : T extends 'PauseEvent' ? PauseEvent : T extends 'ConnectionStatusEvent' ? ConnectionStatusEvent : T extends 'MixStartedEvent' ? MixStartedEvent : T extends 'MixEndedEvent' ? MixEndedEvent : never;
+type HealthStatusThreshold = {
+    excellent: number;
+    good: number;
+    fair: number;
+    poor: number;
+};
+type HealthStatusThresholdOptions = {
+    cpu: Partial<HealthStatusThreshold>;
+    memory: Partial<HealthStatusThreshold>;
+    ping: Partial<HealthStatusThreshold>;
+};
+type NodeMetricSummary = {
+    cpuLoad: number;
+    systemLoad: number;
+    memoryUsage: number;
+    players: number;
+    playingPlayers: number;
+    uptime: number;
+    ping: number;
+    frameDeficit: number;
+};
+type HealthStatusObject = {
+    status: HealthStatusKeys;
+    performance: HealthPerformanceKeys;
+    isOverloaded: boolean;
+    needsRestart: boolean;
+    penaltyScore: number;
+    estimatedRemainingCapacity: number;
+    recommendations: string[];
+    metrics: {
+        cpuLoad: number;
+        memoryUsage: number;
+        players: number;
+        playingPlayers: number;
+        uptime: number;
+        ping: number;
+        frameDeficit: number;
+    };
+};
+type HealthPerformanceKeys = 'excellent' | 'good' | 'fair' | 'poor';
+type HealthStatusKeys = 'healthy' | 'degraded' | 'critical' | 'offline';
+type AddMixerLayerResponse = {
+    id: string;
+    track: AudioTrack;
+    volume: number;
+};
+type ListMixerLayersResponse = {
+    mixes: {
+        id: string;
+        track: AudioTrack;
+        volume: number;
+        position: number;
+        startTime: number;
+    }[];
+};
+type ConnectionMetricsResponse = {
+    status: string;
+    metrics: {
+        speed: {
+            bps: number;
+            kbps: number;
+            mbps: number;
+        };
+        downloadedBytes: number;
+        durationSeconds: number;
+        timestamp: number;
+    };
+};
+type NodeLinkLyricsSynced = {
+    loadType: string;
+    data: {
+        synced: true;
+        lang: string;
+        source: string;
+        lines: [
+            {
+                text: string;
+                time: number;
+                duration: number;
+            },
+            {
+                text: string;
+                time: number;
+                duration: number;
+            },
+            {
+                text: string;
+                time: number;
+                duration: number;
+            }
+        ];
+    };
+};
+type NodeLinkLyricsPlain = {
+    loadType: string;
+    data: {
+        synced: false;
+        lang: string;
+        source: string;
+        lines: [
+            {
+                text: string;
+                time: null;
+                duration: null;
+            },
+            {
+                text: string;
+                time: null;
+                duration: null;
+            },
+            {
+                text: string;
+                time: null;
+                duration: null;
+            }
+        ];
+    };
+};
+type NodeLinkLyrics = NodeLinkLyricsSynced | NodeLinkLyricsPlain;
+type NodeLinkNoLyrics = {
+    loadType: string;
+    data: {};
+};
+type NodeLinkChapter = {
+    title: string;
+    startTime: number;
+    thumbnails: [
+        {
+            url: string;
+            width: number;
+            height: number;
+        }
+    ];
+    duration: number;
+    endTime: number;
+};
+type DirectStreamResponse = {
+    url: string;
+    protocol: string;
+    format: string;
+    hlsUrl: string | null;
+    formats: {
+        itag: number;
+        mimeType: string;
+        qualityLabel: string;
+        bitrate: number;
+    }[];
+};
+type YoutubeOAuthResponse = {
+    access_token: string;
+    expires_in: number;
+    scope: string;
+    token_type: string;
+};
+type MeaningResponse = {
+    loadType: 'meaning';
+    data: {
+        title: string;
+        description: string;
+        paragraphs: string[];
+        url: string;
+        provider: string;
+        type: string;
+    };
+};
 
-interface NodeEventMap {
-    connect: [reconnects: number, name: string];
-    ready: [resumed: boolean, sessionId: string, name: string];
-    dispatch: [payload: MessagePayload, name: string];
-    error: [error: Error, name: string];
-    close: [code: number, reason: string, name: string];
-    disconnect: [code: number, reason: string, byLocal: boolean, name: string];
-}
-type NodeState = "connecting" | "connected" | "ready" | "reconnecting" | "disconnected";
-interface NodeOptions extends RESTOptions {
-    name: string;
-    clientId: string;
-    statsInterval?: number;
-    highestLatency?: number;
-    reconnectDelay?: number;
-    reconnectLimit?: number;
-    handshakeTimeout?: number;
-}
-interface SponsorBlockSegment {
-    category: string;
-    start: number;
-    end: number;
+type ModifyRequest = (options: RequestInit & {
+    path: string;
+    extraQueryUrlParams?: URLSearchParams;
+}) => void;
+type SponsorBlockSegment = 'sponsor' | 'selfpromo' | 'interaction' | 'intro' | 'outro' | 'preview' | 'music_offtopic' | 'filler';
+interface NodeConfiguration {
+    nodeType?: NodeTypes;
+    host: string;
+    port: number;
+    authorization: string;
+    secure?: boolean;
+    sessionId?: string;
+    id?: string;
+    regions?: string[];
+    retryAmount?: number;
+    retryDelay?: number;
+    retryTimespan?: number;
+    requestSignalTimeoutMS?: number;
+    closeOnError?: boolean;
+    heartBeatInterval?: number;
+    enablePingOnStatsCheck?: boolean;
+    autoChecks?: {
+        pluginValidations?: boolean;
+        sourcesValidations?: boolean;
+    };
 }
-
-type CreateNodeOptions = Omit<NodeOptions, "clientId">;
-
-interface NodeManagerEvents {
-    create: [node: LavalinkNode];
-    destroy: [node: LavalinkNode];
-    connect: [node: LavalinkNode];
-    ready: [node: LavalinkNode, resumed: boolean, sessionId: string];
-    disconnect: [node: LavalinkNode, reason: {
-        code: number;
-        reason: string;
-    }];
-    reconnecting: [node: LavalinkNode];
-    error: [node: LavalinkNode, error: Error];
-    raw: [node: LavalinkNode, payload: unknown];
-    nodeInfo: [node: LavalinkNode, info: unknown];
+interface MemoryStats {
+    free: number;
+    used: number;
+    allocated: number;
+    reservable: number;
 }
-
-declare enum CloseCodes {
-    Normal = 1000,
-    GoingAway = 1001,
-    ProtocolError = 1002,
-    UnsupportedData = 1003,
-    NoStatusReceived = 1005,
-    AbnormalClosure = 1006,
-    InvalidFramePayloadData = 1007,
-    PolicyViolation = 1008,
-    MessageTooBig = 1009,
-    InternalError = 1011
-}
-declare class LavalinkNode extends EventEmitter<NodeEventMap> {
-    #private;
-    readonly name: string;
-    readonly rest: REST;
-    constructor(options: NodeOptions);
-    get clientId(): string;
-    get sessionId(): string | null;
-    get ping(): number | null;
-    get stats(): StatsPayload | null;
-    get state(): NodeState;
-    get connecting(): boolean;
-    get connected(): boolean;
-    get ready(): boolean;
-    get reconnecting(): boolean;
-    get disconnected(): boolean;
-    get reconnectLimit(): number;
-    get reconnectAttempts(): number;
-    connect(): Promise<boolean>;
-    disconnect(code?: number, reason?: string): Promise<void>;
-    setSponsorBlock(player: {
-        guildId: string;
-    }, segments: string[]): Promise<void>;
-    getSponsorBlock(player: {
-        guildId: string;
-    }): Promise<string[]>;
-    deleteSponsorBlock(player: {
-        guildId: string;
-    }): Promise<void>;
-    toString(): string;
+interface CPUStats {
+    cores: number;
+    systemLoad: number;
+    audioLoad: number;
 }
-
-interface NodeMetrics {
-    total: number;
-    connected: number;
-    ready: number;
-    reconnecting: number;
+interface FrameStats {
+    sent?: number;
+    nulled?: number;
+    deficit?: number;
+}
+interface BaseNodeStats {
     players: number;
     playingPlayers: number;
+    uptime: number;
+    memory: MemoryStats;
+    cpu: CPUStats;
+    frameStats: FrameStats;
+}
+interface NodeLinkConnectionMetrics {
+    status: string;
+    metrics: {
+        speed: {
+            bps: number;
+            kbps: number;
+            mbps: number;
+        };
+        downloadedBytes: number;
+        durationSeconds: number;
+        timestamp: number;
+    };
 }
-declare class NodeManager extends EventEmitter<NodeManagerEvents> {
-    #private;
-    readonly info: Map<string, LavalinkInfo>;
-    constructor(player: Player);
-    get(name: string): LavalinkNode | undefined;
-    has(name: string): boolean;
-    get all(): LavalinkNode[];
-    get size(): number;
-    create(options: NodeOptions): LavalinkNode;
-    delete(name: string): Promise<boolean>;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    relevant(): LavalinkNode[];
-    get metrics(): NodeMetrics;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<LavalinkNode>;
-    entries(): IterableIterator<[string, LavalinkNode]>;
-    fetchInfo(name: string): Promise<LavalinkInfo>;
-    supports(type: "filter" | "source" | "plugin", value: string, nodeName?: string): boolean;
-}
-
-declare class VoiceRegion {
-    #private;
-    readonly id: string;
-    readonly player: Player;
-    constructor(player: Player, regionId: string);
-    inSync(): boolean;
-    forgetNode(name: string): boolean;
-    getAveragePing(name: string): number | null;
-    getAllPings(): Array<[string, number | null]>;
-    getRelevantNode(): LavalinkNode;
-    [OnPingUpdateSymbol](name: string, state: PlayerState): void;
-    clear(): void;
-    get nodeCount(): number;
-    toString(): string;
-    toJSON(): {
-        id: string;
-        inSync: boolean;
-        nodeCount: number;
-        pings: Array<{
-            node: string;
-            averagePing: number | null;
-            samples: number;
-        }>;
+interface NodeStats extends BaseNodeStats {
+    frameStats: FrameStats;
+    detailedStats?: {
+        api: {
+            requests: Record<string, number>;
+            errors: unknown;
+        };
+        sources: Record<string, number>;
+        playback: {
+            events: Record<string, number>;
+        };
+        [key: string]: unknown;
     };
 }
-
-declare class VoiceState {
-    #private;
-    readonly guildId: string;
-    readonly player: Player;
-    constructor(player: Player, node: string, guildId: string);
-    get node(): LavalinkNode;
-    get ping(): number;
-    get regionId(): string | null;
-    get channelId(): string;
-    get selfDeaf(): boolean;
-    get selfMute(): boolean;
-    get serverDeaf(): boolean;
-    get serverMute(): boolean;
-    get suppressed(): boolean;
-    get destroyed(): boolean;
-    get connected(): boolean;
-    get reconnecting(): boolean;
-    get disconnected(): boolean;
-    get changingNode(): boolean;
-    get sessionId(): string | null;
-    get token(): string | null;
-    get endpoint(): string | null;
-    get nodeSessionId(): string | null;
-    destroy(reason?: string): Promise<void>;
-    connect(channelId?: string): Promise<void>;
-    disconnect(): Promise<void>;
-    changeNode(name: string): Promise<void>;
-    toString(): string;
+interface NodeInfo {
+    version: VersionObject;
+    buildTime: number;
+    git: GitObject;
+    jvm: string;
+    playerEngine: string;
+    sourceManagers: string[];
+    filters: string[];
+    plugins: PluginObject[];
+    isNodelink?: boolean;
 }
-
-declare class VoiceManager implements Partial<Map<string, VoiceState>> {
-    #private;
-    readonly regions: Map<string, VoiceRegion>;
-    readonly player: Player;
-    constructor(player: Player);
-    get size(): number;
-    get(guildId: string): VoiceState | undefined;
-    has(guildId: string): boolean;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<VoiceState>;
-    entries(): IterableIterator<[string, VoiceState]>;
-    destroy(guildId: string, reason?: string): Promise<void>;
-    connect(guildId: string, voiceId: string, options?: ConnectOptions): Promise<VoiceState>;
-    disconnect(guildId: string): Promise<void>;
-    handleDispatch(payload: DiscordDispatchPayload): void;
-    [LookupSymbol](guildId: string): BotVoiceState | undefined;
-    [UpdateSymbol](guildId: string, partial: Partial<BotVoiceState>): void;
-    [OnVoiceCloseSymbol](guildId: string, code: number, reason: string, byRemote: boolean): void;
+interface VersionObject {
+    semver: string;
+    major: number;
+    minor: number;
+    patch: number;
+    preRelease?: string;
+    build?: string;
 }
-
-declare class Track<UserData extends JsonObject = CommonUserData, PluginInfo extends JsonObject = CommonPluginInfo> {
-    id: string;
-    title: string;
-    author: string;
-    isLive: boolean;
-    isSeekable: boolean;
-    duration: number;
-    formattedDuration: string;
-    uri: string | null;
-    isrc: string | null;
-    url: string | null;
-    artworkUrl: string | null;
-    userData: UserData;
-    pluginInfo: PluginInfo;
-    encoded: string;
-    sourceName: string;
-    get identifier(): string;
-    get stream(): boolean;
-    get seekable(): boolean;
-    get durationFormatted(): string;
-    get source(): string;
-    get thumbnail(): string | null;
-    get info(): {
-        identifier: string;
-        position: number;
-        title: string;
-        author: string;
-        length: number;
-        isStream: boolean;
-        isSeekable: boolean;
-        uri: string | null;
-        isrc: string | null;
-        artworkUrl: string | null;
-        sourceName: string;
-    };
-    constructor(data: APITrack<UserData, PluginInfo>);
-    toString(): string;
-    toJSON(): Record<string, unknown>;
-    clone(): Track<UserData, PluginInfo>;
+interface GitObject {
+    branch: string;
+    commit: string;
+    commitTime: string;
 }
-
-declare class Playlist<PluginInfo extends JsonObject = CommonPluginInfo> {
+interface PluginObject {
     name: string;
-    selectedTrack: number;
-    tracks: Track[];
-    pluginInfo: PluginInfo;
-    duration: number;
-    formattedDuration: string;
-    constructor(data: APIPlaylist<PluginInfo>);
-    get selected(): Track | null;
-    getSelectedTrack(): Track | undefined;
-    get length(): number;
-    get trackCount(): number;
-    get durationFormatted(): string;
-    toString(): string;
-    toJSON(): Record<string, unknown>;
+    version: string;
 }
+interface LyricsResult {
+    sourceName: string;
+    provider: string;
+    text: string | null;
+    lines: LyricsLine[];
+    plugin: PluginInfo;
+}
+interface LyricsLine {
+    timestamp: number;
+    duration: number | null;
+    line: string;
+    plugin: PluginInfo;
+}
+type RyanlinkNodeIdentifier = string;
+interface NodeManagerEvents {
+    create: (node: RyanlinkNode) => void;
+    destroy: (node: RyanlinkNode, destroyReason?: DestroyReasonsType) => void;
+    connect: (node: RyanlinkNode) => void;
+    reconnecting: (node: RyanlinkNode) => void;
+    reconnectinprogress: (node: RyanlinkNode) => void;
+    disconnect: (node: RyanlinkNode, reason: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    error: (node: RyanlinkNode, error: Error, payload?: unknown) => void;
+    raw: (node: RyanlinkNode, payload: unknown) => void;
+    resumed: (node: RyanlinkNode, payload: {
+        resumed: true;
+        sessionId: string;
+        op: 'ready';
+    }, players: AudioPlayerState[] | InvalidRestRequest) => void;
+    nodeLinkEvent: (...args: {
+        [K in NodeLinkEventTypes]: [node: RyanlinkNode, event: K, player: Player, track: Track | null, payload: NodeLinkEventPayload<K>];
+    }[NodeLinkEventTypes]) => void;
+}
+declare enum ReconnectionState {
+    IDLE = "IDLE",
+    RECONNECTING = "RECONNECTING",
+    PENDING = "PENDING",
+    DESTROYING = "DESTROYING"
+}
+type NodeTypes = 'Core' | 'NodeLink';
 
 declare class FilterManager {
-    #private;
-    constructor(player: Player, guildId: string);
-    get data(): FilterData;
-    get<K extends FilterKey>(key: K): FilterData[K] | undefined;
-    set<K extends FilterKey>(key: K, value: FilterData[K]): Promise<void>;
-    setVolume(volume: number): Promise<void>;
-    get volume(): number;
-    setEqualizer(bands: EqualizerBand[]): Promise<void>;
-    get equalizer(): EqualizerBand[];
-    setKaraoke(karaoke: KaraokeFilter): Promise<void>;
-    get karaoke(): KaraokeFilter | undefined;
-    setTimescale(timescale: TimescaleFilter): Promise<void>;
-    get timescale(): TimescaleFilter | undefined;
-    setTremolo(tremolo: TremoloFilter): Promise<void>;
-    get tremolo(): TremoloFilter | undefined;
-    setVibrato(vibrato: VibratoFilter): Promise<void>;
-    get vibrato(): VibratoFilter | undefined;
-    setRotation(rotation: RotationFilter): Promise<void>;
-    get rotation(): RotationFilter | undefined;
-    clearEqualizer(): Promise<void>;
-    clearKaraoke(): Promise<void>;
-    clearTimescale(): Promise<void>;
-    clearTremolo(): Promise<void>;
-    clearVibrato(): Promise<void>;
-    clearRotation(): Promise<void>;
-    clearAll(): Promise<void>;
-    has(key: FilterKey): boolean;
-    delete(key: FilterKey): Promise<boolean>;
-    clear(type?: "native" | "plugin"): Promise<void>;
-    apply(filters: Partial<FilterData>): Promise<void>;
-    setEQPreset(preset: EQPresetName): Promise<void>;
-    getEQPresetNames(): EQPresetName[];
-    isValidEQPreset(name: string): name is EQPresetName;
+    static EQList: {
+        BassboostEarrape: EQBand[];
+        BassboostHigh: EQBand[];
+        BassboostMedium: EQBand[];
+        BassboostLow: EQBand[];
+        BetterMusic: EQBand[];
+        Rock: EQBand[];
+        Classic: EQBand[];
+        Pop: EQBand[];
+        Electronic: EQBand[];
+        FullSound: EQBand[];
+        Gaming: EQBand[];
+    };
+    equalizerBands: EQBand[];
+    filterUpdatedState: boolean;
+    filters: PlayerFilters;
+    data: FilterData;
+    player: Player;
+    constructor(player: Player);
+    applyPlayerFilters(): Promise<void>;
+    private privateNot0;
+    private getAudioFilters;
+    checkFiltersState(oldFilterTimescale?: Partial<TimescaleFilter>): boolean;
+    resetFilters(): Promise<FilterManager>;
+    setVolume(volume: number): Promise<this>;
+    setAudioOutput(type: AudioOutputs): Promise<FilterManager>;
+    setSpeed(speed?: number): Promise<FilterManager>;
+    setPitch(pitch?: number): Promise<FilterManager>;
+    setRate(rate?: number): Promise<FilterManager>;
+    toggleRotation(rotationHz?: number): Promise<FilterManager>;
+    toggleVibrato(frequency?: number, depth?: number): Promise<FilterManager>;
+    toggleTremolo(frequency?: number, depth?: number): Promise<FilterManager>;
+    toggleLowPass(smoothing?: number): Promise<FilterManager>;
+    dspxPlugin: {
+        toggleLowPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<FilterManager>;
+        toggleHighPass: (boostFactor?: number, cutoffFrequency?: number) => Promise<FilterManager>;
+        toggleNormalization: (maxAmplitude?: number, adaptive?: boolean) => Promise<FilterManager>;
+        toggleEcho: (decay?: number, echoLength?: number) => Promise<FilterManager>;
+    };
+    coreFilterPlugin: {
+        toggleEcho: (delay?: number, decay?: number) => Promise<FilterManager>;
+        toggleReverb: (delays?: number[], gains?: number[]) => Promise<FilterManager>;
+    };
+    toggleNightcore(speed?: number, pitch?: number, rate?: number): Promise<FilterManager>;
+    toggleVaporwave(speed?: number, pitch?: number, rate?: number): Promise<FilterManager>;
+    toggleKaraoke(level?: number, monoLevel?: number, filterBand?: number, filterWidth?: number): Promise<FilterManager>;
+    isCustomFilterActive(): boolean;
+    setEQPreset(preset: keyof typeof EQList): Promise<this>;
+    setEQ(bands: EQBand | EQBand[]): Promise<this>;
+    clearEQ(): Promise<this>;
 }
 
-declare class Queue<Context extends Record<string, unknown> = QueueContext> {
-    #private;
-    context: Context;
-    readonly voice: VoiceState;
-    readonly filters: FilterManager;
-    readonly player: Player;
-    constructor(player: Player, guildId: string, context?: Context);
-    get node(): LavalinkNode | undefined;
-    get rest(): REST | undefined;
-    get guildId(): string;
-    get volume(): number;
-    get paused(): boolean;
-    get stopped(): boolean;
-    get empty(): boolean;
-    get playing(): boolean;
-    get autoplay(): boolean;
-    get finished(): boolean;
-    get destroyed(): boolean;
-    get repeatMode(): RepeatMode;
-    get hasNext(): boolean;
-    get hasPrevious(): boolean;
-    get track(): Track | null;
-    get previousTrack(): Track | null;
-    get tracks(): Track[];
-    get previousTracks(): Track[];
-    get length(): number;
-    get totalLength(): number;
-    get duration(): number;
-    get formattedDuration(): string;
-    get currentTime(): number;
-    get formattedCurrentTime(): string;
-    sync(target?: "local" | "remote"): Promise<void>;
-    search(query: string, prefix?: string): Promise<SearchResult>;
-    add(source: Track | Track[] | Playlist, userData?: JsonObject): this;
-    addRelated(refTrack?: Track): Promise<Track[]>;
-    remove(index: number): Track | undefined;
-    remove(indices: number[]): Track[];
-    clear(type?: "current" | "previous"): void;
-    jump(index: number): Promise<Track>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    seek(ms: number): Promise<number>;
-    next(): Promise<Track | null>;
-    previous(): Promise<Track | null>;
-    shuffle(includePrevious?: boolean): this;
-    setVolume(volume: number): Promise<number>;
-    setAutoplay(autoplay?: boolean): boolean;
-    setRepeatMode(repeatMode?: RepeatMode): RepeatMode;
-    stop(): Promise<void>;
-    destroy(reason?: string): Promise<void>;
-    move(from: number, to: number): Track | null;
-    splice(index: number, amount: number, tracks?: Track | Track[]): Track[];
-    sortBy(sortBy: "duration" | "title" | "author" | ((a: Track, b: Track) => number), order?: "asc" | "desc"): this;
-    toSortedBy(sortBy: "duration" | "title" | "author" | ((a: Track, b: Track) => number), order?: "asc" | "desc"): Track[];
-    filterTracks(predicate: ((track: Track, index: number) => boolean) | {
+declare class QueueSaver {
+    private _;
+    options: {
+        maxPreviousTracks: number;
+    };
+    constructor(options: ManagerQueueOptions);
+    get(guildId: string): Promise<Partial<StoredQueue>>;
+    delete(guildId: string): Promise<boolean | void>;
+    set(guildId: string, valueToStringify: StoredQueue): Promise<boolean | void>;
+    sync(guildId: string): Promise<Partial<StoredQueue>>;
+}
+declare class DefaultQueueStore implements QueueStoreManager {
+    private data;
+    constructor();
+    get(guildId: string): StoredQueue | undefined;
+    set(guildId: string, valueToStringify: any): boolean;
+    delete(guildId: string): boolean;
+    stringify(value: StoredQueue | string): StoredQueue | string;
+    parse(value: StoredQueue | string): Partial<StoredQueue>;
+}
+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;
+    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: ManagerQueueOptions);
+    utils: {
+        save: () => Promise<boolean | void>;
+        sync: (override?: boolean, dontSyncCurrent?: boolean) => Promise<void>;
+        destroy: () => Promise<boolean | void>;
+        toJSON: () => StoredQueue;
+        totalDuration: () => number;
+        filterTracks: (predicate: ((track: Track | UnresolvedTrack, index: number) => boolean) | {
+            title?: string;
+            author?: string;
+            duration?: number | {
+                min?: number;
+                max?: number;
+            };
+            uri?: string;
+            identifier?: string;
+            sourceName?: string;
+            isStream?: boolean;
+            isSeekable?: boolean;
+        }) => Array<{
+            track: Track | UnresolvedTrack;
+            index: number;
+        }>;
+        findTrack: (predicate: ((track: Track | UnresolvedTrack, index: number) => boolean) | {
+            title?: string;
+            author?: string;
+            duration?: number | {
+                min?: number;
+                max?: number;
+            };
+            uri?: string;
+            identifier?: string;
+            sourceName?: string;
+            isStream?: boolean;
+            isSeekable?: boolean;
+        }) => {
+            track: Track | UnresolvedTrack;
+            index: number;
+        } | null;
+    };
+    shuffle(): Promise<number>;
+    add(TrackOrTracks: Track | UnresolvedTrack | (Track | UnresolvedTrack)[], index?: number): any;
+    splice(index: number, amount: number, TrackOrTracks?: Track | UnresolvedTrack | (Track | UnresolvedTrack)[]): any;
+    remove<T extends Track | UnresolvedTrack | number | Track[] | UnresolvedTrack[] | number[] | (number | Track | UnresolvedTrack)[]>(removeQueryTrack: T): Promise<{
+        removed: (Track | UnresolvedTrack)[];
+    } | null>;
+    shiftPrevious(): Promise<Track>;
+    filter(predicate: ((track: Track | UnresolvedTrack, index: number) => boolean) | {
         title?: string;
         author?: string;
         duration?: number | {
@@ -925,10 +1283,10 @@ declare class Queue<Context extends Record<string, unknown> = QueueContext> {
         isStream?: boolean;
         isSeekable?: boolean;
     }): Array<{
-        track: Track;
+        track: Track | UnresolvedTrack;
         index: number;
     }>;
-    findTrack(predicate: ((track: Track, index: number) => boolean) | {
+    find(predicate: ((track: Track | UnresolvedTrack, index: number) => boolean) | {
         title?: string;
         author?: string;
         duration?: number | {
@@ -941,395 +1299,405 @@ declare class Queue<Context extends Record<string, unknown> = QueueContext> {
         isStream?: boolean;
         isSeekable?: boolean;
     }): {
-        track: Track;
+        track: Track | UnresolvedTrack;
         index: number;
     } | null;
-    getTracks(start: number, end?: number): Track[];
-    shiftPrevious(): Track | null;
+    sortBy(sortBy: 'duration' | 'title' | 'author' | ((a: Track | UnresolvedTrack, b: Track | UnresolvedTrack) => number), order?: 'asc' | 'desc'): Promise<this>;
+    toSortedBy(sortBy: 'duration' | 'title' | 'author' | ((a: Track | UnresolvedTrack, b: Track | UnresolvedTrack) => number), order?: 'asc' | 'desc'): (Track | UnresolvedTrack)[];
+    getTracks(start: number, end?: number): (Track | UnresolvedTrack)[];
 }
 
-declare class QueueManager<Context extends Record<string, unknown> = QueueContext> extends EventEmitter {
-    #private;
-    constructor(player: Player);
-    get(guildId: string): Queue<Context> | undefined;
-    has(guildId: string): boolean;
-    get all(): Queue<Context>[];
-    get size(): number;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<Queue<Context>>;
-    entries(): IterableIterator<[string, Queue<Context>]>;
-    create(options: CreateQueueOptions<Context>): Promise<Queue<Context>>;
-    destroy(guildId: string, reason?: string): Promise<void>;
-    relocate(guildId: string, nodeName: string): Promise<void>;
-    syncAll(): Promise<void>;
-    [LookupSymbol](guildId: string): APIPlayer | undefined;
-    [OnStateUpdateSymbol](guildId: string, state: PlayerState): void;
-    [OnEventUpdateSymbol](guildId: string, event: EventPayload): void;
-}
-
-type ConstrainEventMap<T> = {
-    [K in keyof T]: T[K] extends unknown[] ? T[K] : never;
-};
-declare class Player<Context extends Record<string, unknown> = QueueContext, Plugins extends PlayerPlugin[] = []> extends EventEmitter<ConstrainEventMap<PlayerEventMap & MergeUnionType<PluginEventMap<Plugins[number]>>>> {
-    #private;
-    readonly options: PlayerInstanceOptions;
-    readonly plugins: PluginRecord<Plugins>;
-    readonly nodes: NodeManager;
-    readonly voices: VoiceManager;
-    readonly queues: QueueManager<Context>;
-    constructor(options: PlayerOptions<Plugins>);
-    get ready(): boolean;
-    get clientId(): string | null;
-    init(clientId: string): Promise<void>;
-    getQueue(guildId: string): Queue<Context> | undefined;
-    createQueue(options: CreateQueueOptions<Context>): Promise<Queue<Context>>;
-    destroyQueue(guildId: string, reason?: string): Promise<void>;
-    search(query: string, options?: SearchOptions): Promise<SearchResult>;
-    play(source: string | Parameters<Queue["add"]>[0], options: PlayOptions<Context>): Promise<Queue<Context>>;
-    jump(guildId: string, index: number): Promise<Track>;
-    pause(guildId: string): Promise<boolean>;
-    previous(guildId: string): Promise<Track | null>;
-    resume(guildId: string): Promise<boolean>;
-    seek(guildId: string, ms: number): Promise<number>;
-    setAutoplay(guildId: string, autoplay?: boolean): boolean;
-    setRepeatMode(guildId: string, repeatMode: RepeatMode): RepeatMode;
-    setVolume(guildId: string, volume: number): Promise<number>;
-    shuffle(guildId: string, includePrevious?: boolean): Queue<Context>;
-    next(guildId: string): Promise<Track | null>;
-    stop(guildId: string): Promise<void>;
-}
-
-declare abstract class PlayerPlugin<EventMap extends Record<string, unknown[]> = Record<string, unknown[]>> {
-    protected _: EventMap;
-    abstract readonly name: string;
-    abstract init(player: Player): void;
-}
-
-type EmptyObject = Record<never, never>;
-type JsonLike = string | number | null | boolean | JsonArray | JsonObject;
-type JsonArray = JsonLike[];
-type JsonObject = {
-    [x: string]: JsonLike;
-};
-type RequiredProp<T, P extends keyof T> = Omit<T, P> & Required<Pick<T, P>>;
-type NonNullableProp<T, P extends keyof T> = {
-    [K in keyof T]: K extends P ? NonNullable<T[K]> : T[K];
-};
-type MergeUnionType<U> = (U extends unknown ? (i: U) => void : never) extends (i: infer I) => void ? I : never;
-type PluginEventMap<Plugin> = Plugin extends PlayerPlugin<infer EventMap> ? EventMap : Record<string, unknown>;
-interface QueueContext extends Record<string, unknown> {
-}
-interface CommonUserData extends Record<string, JsonLike> {
-}
-interface CommonPluginInfo extends Record<string, JsonLike> {
-}
-interface CommonPluginFilters extends Record<string, JsonLike> {
-}
-
-type FilterData = Filters;
-type FilterKey = keyof Filters;
-
-type RepeatMode = "none" | "track" | "queue";
-
-interface CreateQueueOptions<Context extends Record<string, unknown> = QueueContext> extends Pick<PlayerUpdateRequestBody, "filters" | "volume"> {
+interface AutoplayConfig {
+    enabled?: boolean;
+    defaultSource?: 'ytsearch' | 'ytmsearch' | 'scsearch' | 'spsearch' | 'amsearch';
+    limit?: number;
+    minDuration?: number;
+    maxDuration?: number;
+    excludeKeywords?: string[];
+}
+declare class Player {
+    filterManager: FilterManager;
+    RyanlinkManager: RyanlinkManager;
+    options: PlayerOptions;
+    node: RyanlinkNode | NodeLinkNode;
+    queue: Queue;
     guildId: string;
-    voiceId: string;
-    node?: string;
-    context?: Context;
-}
-
-interface CommonDispatchPayloadInfo {
-    op: 0;
-    s: number;
-}
-interface BotReadyPayload extends CommonDispatchPayloadInfo {
-    t: "READY";
-    d: {
-        user: {
-            id: string;
-        };
+    voiceChannelId: string | null;
+    textChannelId: string | null;
+    playing: boolean;
+    paused: boolean;
+    repeatMode: RepeatMode;
+    ping: {
+        node: number;
+        ws: number;
     };
-}
-interface VoiceStateUpdatePayload extends CommonDispatchPayloadInfo {
-    t: "VOICE_STATE_UPDATE";
-    d: {
-        guild_id?: string;
-        channel_id: string | null;
-        user_id: string;
-        session_id: string;
-        deaf: boolean;
-        mute: boolean;
-        self_deaf: boolean;
-        self_mute: boolean;
+    volume: number;
+    internalVolume: number;
+    get position(): number;
+    lastPositionChange: number | null;
+    lastPosition: number;
+    lastSavedPosition: number;
+    createdTimeStamp: number;
+    connected: boolean | undefined;
+    voice: VoiceConnectionOptions;
+    voiceState: {
+        selfDeaf: boolean;
+        selfMute: boolean;
+        serverDeaf: boolean;
+        serverMute: boolean;
         suppress: boolean;
     };
+    private readonly data;
+    private dispatchDebug;
+    constructor(options: PlayerOptions, RyanlinkManager: RyanlinkManager, dontEmitPlayerCreateEvent?: boolean);
+    set(key: string, value: unknown): this;
+    get<T>(key: string): T;
+    setData(key: string, value: unknown): this;
+    getData<T>(key: string): T;
+    deleteData(key: string): this;
+    clearData(): this;
+    getAllData(): Record<string, unknown>;
+    play(options?: Partial<PlayOptions>): any;
+    oldJSON: PlayerJson;
+    syncState(): void;
+    setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
+    audioSearch(query: AudioSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<AudioSearchResponse | SearchResult>;
+    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    deleteSponsorBlock(): Promise<void>;
+    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<SearchResult | UnresolvedSearchResult>;
+    private _bandCampSearch;
+    pause(): Promise<this>;
+    resume(): Promise<this>;
+    seek(position: number): Promise<this>;
+    setRepeatMode(repeatMode: RepeatMode): Promise<this>;
+    skip(skipTo?: number, throwError?: boolean): Promise<this>;
+    stopPlaying(clearQueue?: boolean, executeAutoplay?: boolean): Promise<this>;
+    connect(): Promise<this>;
+    changeVoiceState(data: {
+        voiceChannelId?: string;
+        selfDeaf?: boolean;
+        selfMute?: boolean;
+    }): Promise<this>;
+    disconnect(force?: boolean): Promise<this>;
+    destroy(reason?: DestroyReasons | string, disconnect?: boolean): Promise<this>;
+    getCurrentLyrics(skipTrackSource?: boolean): Promise<LyricsResult>;
+    getLyrics(track: Track, skipTrackSource?: boolean): Promise<LyricsResult>;
+    subscribeLyrics(skipTrackSource?: boolean): Promise<unknown>;
+    unsubscribeLyrics(): Promise<void>;
+    changeNode(newNode: RyanlinkNode | string, checkSources?: boolean): Promise<string>;
+    moveNode(node?: string): Promise<string | this>;
+    toJSON(): PlayerJson;
+}
+declare class Autoplay {
+    private static adding;
+    static defaultAutoplay(player: Player, lastTrack: Track): Promise<void>;
+    private static buildPlayedData;
+    private static fetchRelatedTracks;
+    private static filterTracks;
+    private static getSpotifyRecommendations;
+    private static getYouTubeSimilar;
+    private static getArtistSearch;
 }
-interface VoiceServerUpdatePayload extends CommonDispatchPayloadInfo {
-    t: "VOICE_SERVER_UPDATE";
-    d: {
-        token: string;
-        guild_id: string;
-        endpoint: string | null;
+
+declare class NodeLinkNode extends RyanlinkNode {
+    nodeType: "NodeLink";
+    constructor(options: NodeConfiguration, manager: NodeManager);
+    setNextTrackGapLess(player: Player, track?: Track | UnresolvedTrack): Promise<boolean>;
+    removeNextTrackGapLess(player: Player): Promise<boolean>;
+    getMeaning(track?: Track | UnresolvedTrack): Promise<MeaningResponse>;
+    addMixerLayer(player: Player, trackToAdd: Track, volume: number): Promise<AddMixerLayerResponse>;
+    listMixerLayers(player: Player): Promise<ListMixerLayersResponse>;
+    updateMixerLayerVolume(player: Player, mixId: string, volume: number): Promise<boolean>;
+    removeMixerLayer(player: Player, mixId: string): Promise<boolean>;
+    specificFilters: {
+        echo: (player: Player, options: NodeLink_EchoFilter, disableFilter?: boolean) => Promise<boolean>;
+        chorus: (player: Player, options: NodeLink_ChorusFilter, disableFilter?: boolean) => Promise<boolean>;
+        compressor: (player: Player, options: NodeLink_CompressorFilter, disableFilter?: boolean) => Promise<boolean>;
+        highPass: (player: Player, options: NodeLink_HighPassFilter, disableFilter?: boolean) => Promise<boolean>;
+        phaser: (player: Player, options: NodeLink_PhaserFilter, disableFilter?: boolean) => Promise<boolean>;
+        spatial: (player: Player, options: NodeLink_SpatialFilter, disableFilter?: boolean) => Promise<boolean>;
+        resetNodeLinkFilters: (player: Player) => Promise<boolean>;
     };
-}
-type DiscordDispatchPayload = BotReadyPayload | VoiceStateUpdatePayload | VoiceServerUpdatePayload;
-interface BotVoiceState extends Required<NonNullableProp<Omit<VoiceStateUpdatePayload["d"], "guild_id" | "user_id">, "channel_id">>, NonNullableProp<Omit<VoiceServerUpdatePayload["d"], "guild_id">, "endpoint"> {
-    connected: boolean;
-    node_session_id: string;
-    reconnecting: boolean;
-    region_id: string;
-}
-interface ConnectOptions extends Pick<CreateQueueOptions, "context" | "filters" | "node" | "volume"> {
+    nodeLinkLyrics(player: Player, track?: Track | UnresolvedTrack, language?: string): Promise<NodeLinkLyrics | NodeLinkNoLyrics>;
+    getChapters(player: Player, track?: Track | UnresolvedTrack): Promise<NodeLinkChapter[]>;
+    getConnectionMetrics(): Promise<ConnectionMetricsResponse>;
+    getDirectStream(track: Track | UnresolvedTrack): Promise<DirectStreamResponse>;
+    loadDirectStream(track: Track | UnresolvedTrack, volume: number, position: number, filters: object | string): Promise<ReadableStream>;
+    changeAudioTrackLanguage(player: Player, language_audioTrackId: string): Promise<any>;
+    updateYoutubeConfig(refreshToken?: string, visitorData?: string): Promise<any>;
+    getYoutubeConfig(validate?: boolean): Promise<{
+        refreshToken: string;
+        visitorData: string | null;
+        isConfigured: boolean;
+        isValid: boolean | null;
+    }>;
+    getYoutubeOAUTH(refreshToken: string): Promise<YoutubeOAuthResponse>;
+    updateYoutubeOAUTH(refreshToken: string): Promise<YoutubeOAuthResponse>;
 }
 
-interface LyricsPluginEvents {
-    lyricsFound: [player: Player, track: Track, lyrics: LyricsResult];
-    lyricsNotFound: [player: Player, track: Track];
-}
-interface LyricsLine {
-    timestamp: number;
-    duration: number | null;
-    line: string;
-}
-interface LyricsResult {
-    sourceName: string;
-    provider: string;
-    text: string | null;
-    lines: LyricsLine[];
-    track: {
-        title: string;
-        artist: string;
-        album?: string;
-        duration: number;
+declare class RyanlinkNode {
+    private heartBeatPingTimestamp;
+    private heartBeatPongTimestamp;
+    private heartBeatInterval?;
+    private pingTimeout?;
+    nodeType: NodeTypes;
+    isAlive: boolean;
+    static _NodeLinkClass: unknown;
+    options: NodeConfiguration;
+    calls: number;
+    stats: NodeStats;
+    sessionId?: string | null;
+    resuming: {
+        enabled: boolean;
+        timeout: number | null;
     };
-}
-interface LyricsConfig {
-    sources: {
-        lavalink: boolean;
-        lrclib: boolean;
-        musixmatch: boolean;
-        genius: boolean;
+    info: NodeInfo | null;
+    reconnectionState: ReconnectionState;
+    private NodeManager;
+    private reconnectTimeout?;
+    private reconnectAttempts;
+    private socket;
+    private version;
+    private get _LManager();
+    get heartBeatPing(): number;
+    get _checkForPlugins(): boolean;
+    get _checkForSources(): boolean;
+    private dispatchDebug;
+    get connected(): boolean;
+    get connectionStatus(): string;
+    constructor(options: NodeConfiguration, manager: NodeManager);
+    rawRequest(endpoint: string, modify?: ModifyRequest): Promise<{
+        response: Response;
+        options: RequestInit & {
+            path: string;
+            extraQueryUrlParams?: URLSearchParams;
+        };
+    }>;
+    request(endpoint: string, modify: ModifyRequest | undefined, parseAsText: true): Promise<string>;
+    request(endpoint: string, modify?: ModifyRequest, parseAsText?: false): Promise<any>;
+    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<SearchResult>;
+    audioSearch(query: AudioSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<AudioSearchResponse | SearchResult>;
+    updatePlayer(data: PlayerUpdateInfo): Promise<AudioPlayerState>;
+    destroyPlayer(guildId: any): Promise<void>;
+    connect(sessionId?: string): void;
+    private heartBeat;
+    get id(): string;
+    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean, movePlayers?: boolean): void;
+    disconnect(disconnectReason?: DisconnectReasonsType): void;
+    fetchAllPlayers(): Promise<AudioPlayerState[] | InvalidRestRequest | null>;
+    fetchPlayer(guildId: string): Promise<AudioPlayerState | InvalidRestRequest | null>;
+    updateSession(resuming?: boolean, timeout?: number): Promise<Session | InvalidRestRequest | null>;
+    decode: {
+        singleTrack: (encoded: Base64, requester: unknown) => Promise<Track>;
+        multipleTracks: (encodeds: Base64[], requester: unknown) => Promise<Track[]>;
     };
-    apiKeys?: {
-        musixmatch?: string;
-        genius?: string;
+    lyrics: {
+        get: (track: Track, skipTrackSource?: boolean) => Promise<LyricsResult | null>;
+        getCurrent: (guildId: string, skipTrackSource?: boolean) => Promise<LyricsResult | null>;
+        subscribe: (guildId: string, skipTrackSource?: boolean) => Promise<unknown>;
+        unsubscribe: (guildId: string) => Promise<void>;
     };
-}
-declare class LyricsPlugin extends PlayerPlugin<LyricsPluginEvents & Record<string, unknown[]>> {
-    #private;
-    readonly name: "lyrics";
-    init(player: Player): void;
-    getLyrics(track: Track, config?: LyricsConfig): Promise<LyricsResult | null>;
-    getCurrentLine(lyrics: LyricsResult, position: number): LyricsLine | null;
-    formatLyrics(lyrics: LyricsResult, maxLength?: number): string;
-}
-
-type ExcludeLast<T extends unknown[]> = T extends [...infer Items, unknown] ? Items : never;
-interface PlayerEventMap {
-    init: [];
-    nodeConnect: [node: LavalinkNode, ...ExcludeLast<NodeEventMap["connect"]>];
-    nodeReady: [node: LavalinkNode, ...ExcludeLast<NodeEventMap["ready"]>];
-    nodeDispatch: [node: LavalinkNode, ...ExcludeLast<NodeEventMap["dispatch"]>];
-    nodeError: [node: LavalinkNode, ...ExcludeLast<NodeEventMap["error"]>];
-    nodeClose: [node: LavalinkNode, ...ExcludeLast<NodeEventMap["close"]>];
-    nodeDisconnect: [node: LavalinkNode, ...ExcludeLast<NodeEventMap["disconnect"]>];
-    voiceConnect: [voice: VoiceState];
-    voiceClose: [voice: VoiceState, code: number, reason: string, byRemote: boolean];
-    voiceChange: [voice: VoiceState, previousNode: LavalinkNode, wasPlaying: boolean];
-    voiceDestroy: [voice: VoiceState, reason: string];
-    queueCreate: [queue: Queue];
-    queueUpdate: [queue: Queue, state: PlayerState];
-    queueFinish: [queue: Queue];
-    queueDestroy: [queue: Queue, reason: string];
-    trackStart: [queue: Queue, track: Track];
-    trackAdd: [player: Player, guildId: string, tracks: Track[]];
-    trackStuck: [queue: Queue, track: Track, thresholdMs: number];
-    trackError: [queue: Queue, track: Track, exception: Exception];
-    trackFinish: [queue: Queue, track: Track, reason: TrackEndReason];
-    debug: [name: string, info: unknown];
-    segmentsLoaded: [queue: Queue, track: Track, payload: unknown];
-    segmentSkipped: [queue: Queue, track: Track, payload: unknown];
-    fairPlayApplied: [player: Player, guildId: string, count: number];
-    lyricsFound: [player: Player, track: Track, result: LyricsResult];
-    lyricsNotFound: [player: Player, track: Track];
-    queueSaved: [guildId: string];
-    queueLoaded: [guildId: string, count: number];
-}
-type PluginRecord<Plugins extends PlayerPlugin[]> = {
-    [Name in Plugins[number]["name"]]: Extract<Plugins[number], {
-        name: Name;
-    }>;
-};
-interface PlayerOptions<Plugins extends PlayerPlugin[] = PlayerPlugin[]> {
-    nodes: CreateNodeOptions[];
-    plugins?: Plugins;
-    autoInit?: boolean;
-    autoSync?: boolean;
-    queryPrefix?: string;
-    relocateQueues?: boolean;
-    forwardVoiceUpdate: (guildId: string, payload: VoiceUpdatePayload) => Promise<void>;
-    fetchRelatedTracks?: (queue: Queue, track: Track) => Promise<Track[]>;
-}
-type PlayerInstanceOptions = Omit<RequiredProp<PlayerOptions, keyof typeof DefaultPlayerOptions>, "nodes" | "plugins">;
-interface VoiceUpdatePayload {
-    op: 4;
-    d: {
-        guild_id: string;
-        channel_id: string | null;
-        self_deaf: boolean;
-        self_mute: boolean;
+    fetchStats(): Promise<BaseNodeStats>;
+    fetchConnectionMetrics(): Promise<NodeLinkConnectionMetrics>;
+    fetchVersion(): Promise<string>;
+    fetchInfo(): Promise<NodeInfo>;
+    nodeMetricSummary(): NodeMetricSummary;
+    getHealthStatus(thresholds?: HealthStatusThresholdOptions): HealthStatusObject;
+    routePlannerApi: {
+        getStatus: () => Promise<RoutePlanner>;
+        unmarkFailedAddress: (address: string) => Promise<unknown>;
+        unmarkAllFailedAddresses: () => Promise<unknown>;
     };
+    private validate;
+    isNodeLink(): this is NodeLinkNode;
+    isRyanlinkNode(): this is RyanlinkNode;
+    private syncPlayerData;
+    private get restAddress();
+    get isNodeReconnecting(): boolean;
+    private reconnect;
+    get reconnectionAttemptCount(): number;
+    private executeReconnect;
+    private resetReconnectionAttempts;
+    private resetAckTimeouts;
+    private open;
+    private close;
+    private error;
+    private message;
+    private handleEvent;
+    private nodeLinkEventHandler;
+    private getTrackOfPayload;
+    private trackStart;
+    private trackEnd;
+    private trackStuck;
+    private trackError;
+    private socketClosed;
+    private SponsorBlockSegmentLoaded;
+    private SponsorBlockSegmentSkipped;
+    private SponsorBlockChaptersLoaded;
+    private SponsorBlockChapterStarted;
+    getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
+    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
+    deleteSponsorBlock(player: Player): Promise<void>;
+    private queueEnd;
+    private LyricsLine;
+    private LyricsFound;
+    private LyricsNotFound;
 }
-interface SearchOptions {
-    node?: string;
-    prefix?: string;
-}
-interface PlayOptions<Context extends Record<string, unknown> = QueueContext, UserData extends JsonObject = CommonUserData> extends SearchOptions, CreateQueueOptions<Context> {
-    userData?: UserData;
-}
-interface TrackSearchResult {
-    type: "track";
-    data: Track;
-}
-interface PlaylistSearchResult {
-    type: "playlist";
-    data: Playlist;
-}
-interface QuerySearchResult {
-    type: "query";
-    data: Track[];
-}
-interface EmptySearchResult {
-    type: "empty";
-    data: [];
-}
-interface ErrorSearchResult {
-    type: "error";
-    data: Exception;
-}
-type SearchResult = TrackSearchResult | PlaylistSearchResult | QuerySearchResult | EmptySearchResult | ErrorSearchResult;
 
-declare const isNumber: <T extends number>(input: unknown, check?: "integer" | "natural" | "whole" | "safe-int" | "positive") => input is T;
-declare const isString: <T extends string>(input: unknown, check?: "url" | "non-empty" | RegExp) => input is T;
-declare const isRecord: <T extends Record<string, unknown>>(input: unknown, check?: "non-empty") => input is T;
-declare const isArray: <T extends unknown[]>(input: unknown, check?: "non-empty" | Parameters<T["every"]>[0]) => input is T;
-declare const isBoolean: (input: unknown) => input is boolean;
-declare const isFunction: (input: unknown) => input is (...args: unknown[]) => unknown;
-declare const isNullish: (input: unknown) => input is null | undefined;
-declare const isSnowflake: (input: unknown) => input is string;
-declare const isUrl: (input: unknown) => input is string;
-declare const isError: (error: unknown) => error is Error;
-declare function assert(condition: unknown, message: string): asserts condition;
-declare function validateNodeOptions(options: CreateNodeOptions): void;
-declare function validatePlayerOptions(options: PlayerOptions): void;
-
-interface AutoplayConfig {
-    enabled: boolean;
-    minPlayTime: number;
-    sources: {
-        spotify: boolean;
-        youtube: boolean;
-        youtubemusic: boolean;
-        soundcloud: boolean;
-    };
-    limit: number;
-    minDuration: number;
-    maxDuration: number;
-    excludeKeywords: string[];
-}
-declare class AutoplayPlugin extends PlayerPlugin {
-    #private;
-    readonly name: "autoplay";
-    init(player: Player): void;
+declare class NodeManager extends EventEmitter {
+    emit<Event extends keyof NodeManagerEvents>(event: Event, ...args: Parameters<NodeManagerEvents[Event]>): boolean;
+    on<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
+    once<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
+    off<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
+    removeListener<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
+    RyanlinkManager: RyanlinkManager;
+    nodes: MiniMap<string, RyanlinkNode | NodeLinkNode>;
+    constructor(RyanlinkManager: RyanlinkManager);
+    disconnectAll(deleteAllNodes?: boolean, destroyPlayers?: boolean): Promise<number>;
+    connectAll(): Promise<number>;
+    reconnectAll(): Promise<number>;
+    createNode<T extends RyanlinkNode | NodeLinkNode>(options: NodeConfiguration): T;
+    leastUsedNodes(sortType?: 'memory' | 'cpuLavalink' | 'cpuSystem' | 'calls' | 'playingPlayers' | 'players'): RyanlinkNode[];
+    deleteNode(node: RyanlinkNodeIdentifier | RyanlinkNode | NodeLinkNode, movePlayers?: boolean): void;
+    getNode(node: RyanlinkNodeIdentifier | RyanlinkNode | NodeLinkNode): RyanlinkNode | NodeLinkNode | undefined;
 }
 
-interface SponsorBlockPluginEvents {
-    segmentsLoaded: [queue: Queue, track: Track, segments: SponsorBlockSegment[]];
-    segmentSkipped: [queue: Queue, track: Track, segment: SponsorBlockSegment];
-}
-declare class SponsorBlockPlugin extends PlayerPlugin<SponsorBlockPluginEvents & Record<string, unknown[]>> {
-    #private;
-    readonly name: "sponsorblock";
-    init(player: Player): void;
-    setSegments(queue: Queue, segments?: string[]): Promise<void>;
-    getSegments(queue: Queue): Promise<string[]>;
-    deleteSegments(queue: Queue): Promise<void>;
+interface ManagerEvents<CustomPlayerT extends Player = Player> {
+    trackStart: (player: CustomPlayerT, track: Track | null, payload: TrackStartEvent) => void;
+    trackEnd: (player: CustomPlayerT, track: Track | null, payload: TrackEndEvent) => void;
+    trackStuck: (player: CustomPlayerT, track: Track | null, payload: TrackStuckEvent) => void;
+    trackError: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: TrackExceptionEvent) => void;
+    queueEnd: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: TrackEndEvent | TrackStuckEvent | TrackExceptionEvent) => void;
+    playerCreate: (player: CustomPlayerT) => void;
+    playerMove: (player: CustomPlayerT, oldVoiceChannelId: string, newVoiceChannelId: string) => void;
+    playerDisconnect: (player: CustomPlayerT, voiceChannelId: string) => void;
+    playerReconnect: (player: CustomPlayerT, voiceChannelId: string) => void;
+    playerSocketClosed: (player: CustomPlayerT, payload: WebSocketClosedEvent) => void;
+    playerDestroy: (player: CustomPlayerT, destroyReason?: DestroyReasonsType) => void;
+    playerUpdate: (oldPlayerJson: PlayerJson, newPlayer: CustomPlayerT) => void;
+    playerClientUpdate: (oldPlayerJson: PlayerJson, newPlayer: CustomPlayerT) => void;
+    playerMuteChange: (player: CustomPlayerT, selfMuted: boolean, serverMuted: boolean) => void;
+    playerDeafChange: (player: CustomPlayerT, selfDeafed: boolean, serverDeafed: boolean) => void;
+    playerSuppressChange: (player: CustomPlayerT, suppress: boolean) => void;
+    playerQueueEmptyStart: (player: CustomPlayerT, timeoutMs: number) => void;
+    playerQueueEmptyEnd: (player: CustomPlayerT) => void;
+    playerQueueEmptyCancel: (player: CustomPlayerT) => void;
+    playerVoiceJoin: (player: CustomPlayerT, userId: string) => void;
+    playerVoiceLeave: (player: CustomPlayerT, userId: string) => void;
+    SegmentsLoaded: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: SponsorBlockSegmentsLoaded) => void;
+    SegmentSkipped: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: SponsorBlockSegmentSkipped) => void;
+    ChapterStarted: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: SponsorBlockChapterStarted) => void;
+    ChaptersLoaded: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: SponsorBlockChaptersLoaded) => void;
+    debug: (eventKey: DebugEvents, eventData: {
+        message: string;
+        state: 'log' | 'warn' | 'error';
+        error?: Error | string;
+        functionLayer: string;
+    }) => void;
+    LyricsLine: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: LyricsLineEvent) => void;
+    LyricsFound: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: LyricsFoundEvent) => void;
+    LyricsNotFound: (player: CustomPlayerT, track: Track | UnresolvedTrack | null, payload: LyricsNotFoundEvent) => void;
+    playerResumed: (player: CustomPlayerT, track: Track | UnresolvedTrack | null) => void;
+    playerPaused: (player: CustomPlayerT, track: Track | UnresolvedTrack | null) => void;
+}
+interface BotClientOptions {
+    id: string;
+    username?: string;
+    [x: string | number | symbol]: unknown;
+}
+interface ManagerPlayerOptions<CustomPlayerT extends Player = Player> {
+    volumeDecrementer?: number;
+    clientBasedPositionUpdateInterval?: number;
+    defaultSearchPlatform?: SearchPlatform;
+    allowCustomSources?: boolean;
+    applyVolumeAsFilter?: boolean;
+    requesterTransformer?: (requester: unknown) => unknown;
+    onDisconnect?: {
+        autoReconnect?: boolean;
+        autoReconnectOnlyWithTracks?: boolean;
+        destroyPlayer?: boolean;
+    };
+    minAutoPlayMs?: number;
+    maxErrorsPerTime?: {
+        threshold: number;
+        maxAmount: number;
+    };
+    onEmptyQueue?: {
+        autoPlayFunction?: (player: CustomPlayerT, lastPlayedTrack: Track) => Promise<void>;
+        destroyAfterMs?: number;
+    };
+    autoplayConfig?: AutoplayConfig;
+    useUnresolvedData?: boolean;
+    enforceSponsorBlockRequestForEventEnablement?: boolean;
+}
+type PlayerConstructor<T extends Player = Player> = new (options: PlayerOptions, RyanlinkManager: RyanlinkManager, dontEmitPlayerCreateEvent?: boolean) => T;
+interface RyanConfiguration<CustomPlayerT extends Player = Player> {
+    nodes: NodeConfiguration[];
+    sendToShard: (guildId: string, payload: GuildShardPayload) => void;
+    client?: BotClientOptions;
+    queueOptions?: ManagerQueueOptions;
+    playerOptions?: ManagerPlayerOptions<CustomPlayerT>;
+    playerClass?: PlayerConstructor<CustomPlayerT>;
+    autoSkip?: boolean;
+    autoMove?: boolean;
+    autoSkipOnResolveError?: boolean;
+    emitNewSongsOnly?: boolean;
+    linksWhitelist?: (RegExp | string)[];
+    linksBlacklist?: (RegExp | string)[];
+    linksAllowed?: boolean;
+    advancedOptions?: {
+        maxFilterFixDuration?: number;
+        enableDebugEvents?: boolean;
+        debugOptions?: {
+            logCustomSearches?: boolean;
+            noAudio?: boolean;
+            playerDestroy?: {
+                debugLog?: boolean;
+                dontThrowError?: boolean;
+            };
+        };
+    };
 }
 
-interface FairPlayPluginEvents {
-    fairPlayApplied: [player: Player, guildId: string, trackCount: number];
-}
-interface FairPlayConfig {
-    enabled: boolean;
-    minTracks: number;
-    maxConsecutive: number;
-}
-declare class FairPlayPlugin extends PlayerPlugin<FairPlayPluginEvents & Record<string, unknown[]>> {
-    #private;
-    readonly name: "fairplay";
-    config: FairPlayConfig;
-    init(player: Player): void;
-    applyFairPlay(guildId: string): void;
+declare class RyanlinkManager<CustomPlayerT extends Player = Player> extends EventEmitter {
+    emit<Event extends keyof ManagerEvents<CustomPlayerT>>(event: Event, ...args: Parameters<ManagerEvents<CustomPlayerT>[Event]>): boolean;
+    on<Event extends keyof ManagerEvents<CustomPlayerT>>(event: Event, listener: ManagerEvents<CustomPlayerT>[Event]): this;
+    once<Event extends keyof ManagerEvents<CustomPlayerT>>(event: Event, listener: ManagerEvents<CustomPlayerT>[Event]): this;
+    off<Event extends keyof ManagerEvents<CustomPlayerT>>(event: Event, listener: ManagerEvents<CustomPlayerT>[Event]): this;
+    removeListener<Event extends keyof ManagerEvents<CustomPlayerT>>(event: Event, listener: ManagerEvents<CustomPlayerT>[Event]): this;
+    options: RyanConfiguration<CustomPlayerT>;
+    nodeManager: NodeManager;
+    utils: RyanlinkUtils;
+    initiated: boolean;
+    readonly players: MiniMap<string, CustomPlayerT>;
+    private applyOptions;
+    private validateOptions;
+    private dispatchDebug;
+    private static readonly _noAudioDebugPrefix;
+    private _debugNoAudio;
+    constructor(options: RyanConfiguration<CustomPlayerT>);
+    getPlayer(guildId: string): CustomPlayerT | undefined;
+    createPlayer(options: PlayerOptions): CustomPlayerT;
+    destroyPlayer(guildId: string, destroyReason?: string): Promise<void | CustomPlayerT>;
+    deletePlayer(guildId: string): boolean | void;
+    get useable(): boolean;
+    init(clientData: BotClientOptions): Promise<this>;
+    provideVoiceUpdate(data: VoicePacket | VoiceServer | VoiceState | ChannelDeletePacket): Promise<void>;
 }
 
-interface QueuePersistencePluginEvents {
-    queueSaved: [guildId: string];
-    queueLoaded: [guildId: string, trackCount: number];
-}
-interface StoredQueue {
-    guildId: string;
-    tracks: Array<{
-        encoded: string;
-        info: unknown;
-        pluginInfo?: unknown;
-        userData?: unknown;
-    }>;
-    previousTracks: Array<{
-        encoded: string;
-        info: unknown;
-        pluginInfo?: unknown;
-        userData?: unknown;
-    }>;
-    currentTrack?: {
-        encoded: string;
-        info: unknown;
-        position: number;
-    };
-    volume: number;
-    repeatMode: RepeatMode;
-    autoplay: boolean;
-    paused: boolean;
-    timestamp: number;
-}
-interface QueueStore {
-    get(guildId: string): Promise<StoredQueue | null> | StoredQueue | null;
-    set(guildId: string, data: StoredQueue): Promise<void> | void;
-    delete(guildId: string): Promise<void> | void;
-}
-declare class MemoryQueueStore implements QueueStore {
-    #private;
-    get(guildId: string): StoredQueue | null;
-    set(guildId: string, data: StoredQueue): void;
-    delete(guildId: string): void;
-}
-declare class QueuePersistencePlugin extends PlayerPlugin<QueuePersistencePluginEvents & Record<string, unknown[]>> {
-    #private;
-    readonly name: "queue-persistence";
-    constructor(store?: QueueStore, autoSave?: boolean);
-    init(player: Player): void;
-    saveQueue(guildId: string): Promise<void>;
-    loadQueue(guildId: string): Promise<StoredQueue | null>;
-    deleteQueue(guildId: string): Promise<void>;
-    getAllQueues(): Promise<StoredQueue[]>;
-}
+declare const SourceMappings: Record<SearchPlatform, RyanlinkSearchPlatform | ClientCustomSearchPlatformUtils>;
+declare const BuiltinSources: {
+    DuncteBot_Plugin: string;
+    LavaSrc: string;
+    GoogleCloudTTS: string;
+    LavaSearch: string;
+    JioSaavn_Engine: string;
+    Filter_Engine: string;
+    TimedLyrics_Engine: string;
+};
+declare const LinkMatchers: Record<SourcesRegex, RegExp>;
 
-declare const CLIENT_NAME: string;
-declare const CLIENT_VERSION: string;
-declare const PACKAGE_INFO: Readonly<{
-    name: string;
-    version: string;
-    repository: string;
-    description: string | undefined;
-}>;
+declare const version: string;
 
-export { AmazonMusicRegex, AnghamiRegex, AppleMusicRegex, AudioFileRegex, AudiomackRegex, AudiusRegex, type AutoplayConfig, AutoplayPlugin, BandcampRegex, CloseCodes, DeezerRegex, DefaultFilterOptions, DefaultNodeOptions, DefaultPlayerOptions, DefaultQueueOptions, DefaultRestOptions, type EQBand, type EQPresetName, EQPresets, type FairPlayConfig, FairPlayPlugin, type FairPlayPluginEvents, FilterManager, GaanaRegex, HttpStatusCodes, InstagramRegex, JioSaavnRegex, LavalinkNode, LookupSymbol, type LyricsConfig, type LyricsLine, LyricsPlugin, type LyricsPluginEvents, type LyricsResult, MemoryQueueStore, MixcloudRegex, LavalinkNode as Node, NodeManager, type NodeMetrics, OnEventUpdateSymbol, OnPingUpdateSymbol, OnStateUpdateSymbol, OnVoiceCloseSymbol, PACKAGE_INFO, PandoraRegex, Player, PlayerPlugin, Playlist, QobuzRegex, Queue, QueueManager, QueuePersistencePlugin, type QueuePersistencePluginEvents, type QueueStore, REST, type RouteReturnType, Routes, ShazamRegex, SnowflakeRegex, SoundCloudRegex, SponsorBlockPlugin, type SponsorBlockPluginEvents, SpotifyRegex, type StoredQueue, TidalRegex, Track, TwitchRegex, UpdateSymbol, UrlRegex, VoiceManager, VoiceRegion, VoiceRegionIdRegex, VoiceState, WebSocketCloseCodes, YandexMusicRegex, YoutubeRegex, assert, chunk, clamp, formatDuration, getEQPreset, getEQPresetNames, isArray, isBoolean, isError, isFunction, isNullish, isNumber, isRecord, isSnowflake, isString, isUrl, isValidEQPreset, CLIENT_NAME as name, noop, parseDuration, randomElement, retry, shuffle, sleep, unique, validateNodeOptions, validatePlayerOptions, CLIENT_VERSION as version };
+export { type AudioClientSearchPlatform, type AudioClientSearchPlatformResolve, type AudioFilters, AudioNodeSymbol, type AudioOutputs, type AudioPlayerState, AudioQueueSymbol, type AudioSearchFilteredResponse, type AudioSearchQuery, type AudioSearchResponse, type AudioSearchType, type AudioSourceNames, type AudioTrack, type AudioTrackInfo, AudioTrackSymbol, Autoplay, type AutoplayConfig, type Awaitable, type Base64, type BaseNodeStats, type BasePlayOptions, BuiltinSources, type CPUStats, type ChannelDeletePacket, type ChannelMixFilter, type ClientCustomSearchPlatformUtils, type ClientSearchPlatform, type CoreSourceNames, DebugEvents, DefaultQueueStore, DestroyReasons, type DestroyReasonsType, DisconnectReasons, type DisconnectReasonsType, type DistortionFilter, type DuncteSearchPlatform, type EQBand, EQList, type Exception, type ExtendedSearchPlatform, type FailingAddress, type FilterData, FilterManager, type FloatNumber, type FrameStats, type GitObject, type GuildShardPayload, type IntegerNumber, type InvalidRestRequest, type JioSaavnSearchPlatform, type KaraokeFilter, LinkMatchers, type LoadTypes, type LowPassFilter, type LyricsEvent, type LyricsEventType, type LyricsFoundEvent, type LyricsLine, type LyricsLineEvent, type LyricsNotFoundEvent, type LyricsResult, type ManagerQueueOptions, type MemoryStats, MiniMap, type MiniMapConstructor, type ModifyRequest, type NodeConfiguration, type NodeInfo, type NodeLinkConnectionMetrics, NodeLinkExclusiveEvents, NodeLinkNode, type NodeLink_ChorusFilter, type NodeLink_CompressorFilter, type NodeLink_EchoFilter, type NodeLink_HighPassFilter, type NodeLink_PhaserFilter, type NodeLink_SpatialFilter, NodeManager, type NodeManagerEvents, type NodeMessage, type NodeStats, type NodeTypes, type Opaque, type PlayConfiguration, type PlayOptions, Player, type PlayerEvent, type PlayerEventType, type PlayerEvents, type PlayerFilters, type PlayerJson, type PlayerOptions, type PlayerUpdateInfo, type PlaylistInfo, type PluginInfo, type PluginObject, Queue, type QueueChangesWatcher, QueueSaver, type QueueStoreManager, RecommendationsStrings, ReconnectionState, type RepeatMode, type RotationFilter, type RoutePlanner, type RoutePlannerTypes, RyanlinkManager, RyanlinkNode, type RyanlinkNodeIdentifier, type RyanlinkSearchPlatform, RyanlinkUtils, type SearchPlatform, type SearchQuery, type SearchResult, type Session, type Severity, SourceMappings, type SourceSearchPlatform, type SourceSearchPlatformBase, type SourcesRegex, type SponsorBlockChapterStarted, type SponsorBlockChaptersLoaded, type SponsorBlockSegment, type SponsorBlockSegmentEventType, type SponsorBlockSegmentEvents, type SponsorBlockSegmentSkipped, type SponsorBlockSegmentsLoaded, type State, type StoredQueue, type TimescaleFilter, type Track, type TrackEndEvent, type TrackEndReason, type TrackExceptionEvent, type TrackInfo, type TrackRequester, type TrackStartEvent, type TrackStuckEvent, type TremoloFilter, UnresolvedAudioTrackSymbol, type UnresolvedQuery, type UnresolvedSearchResult, type UnresolvedTrack, type UnresolvedTrackInfo, type VersionObject, type VibratoFilter, type VoiceConnectionOptions, type VoiceConnectionState, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent, type anyObject, audioOutputsData, parseConnectionUrl, queueTrackEnd, safeStringify, validSponsorBlocks, version };