ryanlink 1.0.2 → 2.0.0

package/dist/index.d.cts

@@ -0,0 +1,1703 @@
+import { EventEmitter } from 'node:events';
+import { ReadableStream } from 'node:stream/web';
+
+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 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 NodeLinkExclusiveEvents: NodeLinkEventTypes[];
+
+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;
+}
+
+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;
+};
+interface BasePlayOptions {
+    position?: number;
+    endTime?: number;
+    paused?: boolean;
+    volume?: number;
+    filters?: Partial<AudioFilters>;
+    voice?: VoiceConnectionOptions;
+}
+interface PlayConfiguration extends BasePlayOptions {
+    track?: {
+        encoded?: Base64 | null;
+        identifier?: string;
+        userData?: anyObject;
+        requester?: unknown;
+        audioTrackId?: string;
+    };
+    nextTrack?: {
+        encoded?: Base64 | null;
+        userData?: anyObject;
+    };
+}
+interface PlayOptions extends PlayConfiguration {
+    noReplace?: boolean;
+    clientTrack?: (Track | UnresolvedTrack) & {
+        audioTrackId?: string;
+    };
+}
+
+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 TrackInfo {
+    identifier: string;
+    title: string;
+    author: string;
+    duration: number;
+    artworkUrl: string | null;
+    uri: string;
+    sourceName: AudioSourceNames;
+    isSeekable: boolean;
+    isStream: boolean;
+    isrc: string | null;
+}
+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 AudioTrack {
+    encoded?: Base64;
+    info: AudioTrackInfo;
+    pluginInfo: Partial<PluginInfo>;
+    userData?: anyObject;
+}
+interface TrackRequester {
+}
+interface Track {
+    encoded?: Base64;
+    info: TrackInfo;
+    pluginInfo: Partial<PluginInfo>;
+    requester?: TrackRequester;
+    userData?: anyObject;
+}
+interface UnresolvedTrackInfo extends Partial<TrackInfo> {
+    title: string;
+}
+interface UnresolvedQuery extends UnresolvedTrackInfo {
+    encoded?: Base64;
+}
+interface UnresolvedTrack {
+    resolve: (player: Player) => Promise<void>;
+    encoded?: Base64;
+    info: UnresolvedTrackInfo;
+    pluginInfo: Partial<PluginInfo>;
+    userData?: anyObject;
+    requester?: TrackRequester;
+}
+
+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 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 {
+    severity: Severity;
+    error?: Error;
+    message: string;
+    cause: string;
+    causeStackTrace: string;
+}
+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 WebSocketClosedEvent extends PlayerEvent {
+    type: 'WebSocketClosedEvent';
+    code: number;
+    byRemote: boolean;
+    reason: string;
+}
+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 SponsorBlockSegmentSkipped extends PlayerEvent {
+    type: 'SegmentSkipped';
+    segment: {
+        category: string;
+        start: number;
+        end: number;
+    };
+}
+interface SponsorBlockChapterStarted extends PlayerEvent {
+    type: 'ChapterStarted';
+    chapter: {
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    };
+}
+interface SponsorBlockChaptersLoaded extends PlayerEvent {
+    type: 'ChaptersLoaded';
+    chapters: {
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+}
+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 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 Session {
+    resuming: boolean;
+    timeout: number;
+}
+interface GuildShardPayload {
+    op: number;
+    d: {
+        guild_id: string;
+        channel_id: string | null;
+        self_mute: boolean;
+        self_deaf: boolean;
+    };
+}
+interface PlayerUpdateInfo {
+    guildId: string;
+    playerOptions: PlayConfiguration;
+    noReplace?: boolean;
+}
+interface AudioPlayerState {
+    guildId: string;
+    track?: AudioTrack;
+    volume: number;
+    paused: boolean;
+    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 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;
+    channel_id?: string;
+}
+interface VoicePacket {
+    t?: 'VOICE_SERVER_UPDATE' | 'VOICE_STATE_UPDATE';
+    d: VoiceState | VoiceServer;
+}
+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;
+}
+interface KaraokeFilter {
+    level?: number;
+    monoLevel?: number;
+    filterBand?: number;
+    filterWidth?: number;
+}
+interface TimescaleFilter {
+    speed?: number;
+    pitch?: number;
+    rate?: number;
+}
+interface TremoloFilter {
+    frequency?: number;
+    depth?: number;
+}
+interface VibratoFilter {
+    frequency?: number;
+    depth?: number;
+}
+interface RotationFilter {
+    rotationHz?: number;
+}
+interface DistortionFilter {
+    sinOffset?: number;
+    sinScale?: number;
+    cosOffset?: number;
+    cosScale?: number;
+    tanOffset?: number;
+    tanScale?: number;
+    offset?: number;
+    scale?: number;
+}
+interface ChannelMixFilter {
+    leftToLeft?: number;
+    leftToRight?: number;
+    rightToLeft?: number;
+    rightToRight?: number;
+}
+interface NodeLink_EchoFilter {
+    delay?: number;
+    feedback?: number;
+    mix?: 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;
+}
+interface NodeLink_PhaserFilter {
+    stages?: number;
+    rate?: number;
+    depth?: number;
+    feedback?: number;
+    mix?: number;
+    minFrequency?: number;
+    maxFrequency?: number;
+}
+interface NodeLink_SpatialFilter {
+    depth?: number;
+    rate?: number;
+}
+interface LowPassFilter {
+    smoothing?: number;
+}
+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 AudioFilters extends FilterData {
+    equalizer?: EQBand[];
+}
+
+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 PlayerCreatedEvent extends NodeLinkBaseEvent {
+    type: 'PlayerCreatedEvent';
+}
+interface PlayerDestroyedEvent extends NodeLinkBaseEvent {
+    type: 'PlayerDestroyedEvent';
+}
+interface PlayerConnectedEvent extends NodeLinkBaseEvent {
+    type: 'PlayerConnectedEvent';
+}
+interface PlayerReconnectingEvent extends NodeLinkBaseEvent {
+    type: 'PlayerReconnectingEvent';
+}
+interface VolumeChangedEvent extends NodeLinkBaseEvent {
+    type: 'VolumeChangedEvent';
+    volume: number;
+}
+interface FiltersChangedEvent extends NodeLinkBaseEvent {
+    type: 'FiltersChangedEvent';
+    filters: AudioFilters;
+}
+interface SeekEvent extends NodeLinkBaseEvent {
+    type: 'SeekEvent';
+    position: number;
+}
+interface PauseEvent extends NodeLinkBaseEvent {
+    type: 'PauseEvent';
+    paused: boolean;
+}
+interface ConnectionStatusEvent extends NodeLinkBaseEvent {
+    type: 'ConnectionStatusEvent';
+    connected: boolean;
+}
+interface MixStartedEvent extends NodeLinkBaseEvent {
+    type: 'MixStartedEvent';
+    mixId: string;
+    track: AudioTrack;
+    volume: number;
+}
+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;
+    };
+};
+
+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;
+    };
+}
+interface MemoryStats {
+    free: number;
+    used: number;
+    allocated: number;
+    reservable: number;
+}
+interface CPUStats {
+    cores: number;
+    systemLoad: number;
+    audioLoad: 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;
+    };
+}
+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;
+    };
+}
+interface NodeInfo {
+    version: VersionObject;
+    buildTime: number;
+    git: GitObject;
+    jvm: string;
+    playerEngine: string;
+    sourceManagers: string[];
+    filters: string[];
+    plugins: PluginObject[];
+    isNodelink?: boolean;
+}
+interface VersionObject {
+    semver: string;
+    major: number;
+    minor: number;
+    patch: number;
+    preRelease?: string;
+    build?: string;
+}
+interface GitObject {
+    branch: string;
+    commit: string;
+    commitTime: string;
+}
+interface PluginObject {
+    name: string;
+    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 {
+    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 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 | {
+            min?: number;
+            max?: number;
+        };
+        uri?: string;
+        identifier?: string;
+        sourceName?: string;
+        isStream?: boolean;
+        isSeekable?: boolean;
+    }): Array<{
+        track: Track | UnresolvedTrack;
+        index: number;
+    }>;
+    find(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;
+    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)[];
+}
+
+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;
+    voiceChannelId: string | null;
+    textChannelId: string | null;
+    playing: boolean;
+    paused: boolean;
+    repeatMode: RepeatMode;
+    ping: {
+        node: number;
+        ws: number;
+    };
+    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;
+}
+
+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>;
+    };
+    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>;
+}
+
+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;
+    };
+    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[]>;
+    };
+    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>;
+    };
+    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;
+}
+
+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 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;
+            };
+        };
+    };
+}
+
+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>;
+}
+
+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 version: string;
+
+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 };