ryanlink 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,1335 @@
+import { EventEmitter } from 'node:events';
+
+declare const DefaultRestOptions: {
+    readonly version: 4;
+    readonly userAgent: `${string}/${string} (${string})`;
+    readonly stackTrace: false;
+    readonly requestTimeout: 10000;
+};
+declare const DefaultNodeOptions: {
+    readonly statsInterval: 60000;
+    readonly highestLatency: 2000;
+    readonly reconnectDelay: 10000;
+    readonly reconnectLimit: 3;
+    readonly handshakeTimeout: 5000;
+};
+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 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;
+
+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 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 RESTOptions {
+    origin?: string;
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    password: string;
+    version?: number;
+    userAgent?: string;
+    sessionId?: string;
+    stackTrace?: boolean;
+    requestTimeout?: number;
+}
+
+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 PlayerUpdatePayload extends BaseMessagePayload {
+    op: OPType.PlayerUpdate;
+    guildId: string;
+    state: PlayerState;
+}
+interface PlayerState {
+    time: number;
+    position: number;
+    connected: boolean;
+    ping: number;
+}
+interface StatsPayload extends BaseMessagePayload, NodeStats {
+    op: OPType.Stats;
+}
+interface NodeStats {
+    players: number;
+    playingPlayers: number;
+    uptime: number;
+    memory: NodeMemory;
+    cpu: NodeCPU;
+    frameStats: FrameStats | null;
+}
+interface NodeMemory {
+    free: number;
+    used: number;
+    allocated: number;
+    reservable: number;
+}
+interface NodeCPU {
+    cores: number;
+    systemLoad: number;
+    lavalinkLoad: number;
+}
+interface FrameStats {
+    sent: number;
+    nulled: number;
+    deficit: number;
+}
+interface BaseEventPayload extends BaseMessagePayload {
+    op: OPType.Event;
+    type: EventType | string;
+    guildId: string;
+}
+interface TrackStartEventPayload extends BaseEventPayload {
+    type: EventType.TrackStart;
+    track: APITrack;
+}
+interface TrackEndEventPayload extends BaseEventPayload {
+    type: EventType.TrackEnd;
+    track: APITrack;
+    reason: TrackEndReason;
+}
+interface TrackExceptionEventPayload extends BaseEventPayload {
+    type: EventType.TrackException;
+    track: APITrack;
+    exception: Exception;
+}
+interface Exception {
+    message: string | null;
+    severity: Severity;
+    cause: string;
+    causeStackTrace: string;
+}
+interface TrackStuckEventPayload extends BaseEventPayload {
+    type: EventType.TrackStuck;
+    track: APITrack;
+    thresholdMs: number;
+}
+interface WebSocketClosedEventPayload extends BaseEventPayload {
+    type: EventType.WebSocketClosed;
+    code: number;
+    reason: string;
+    byRemote: boolean;
+}
+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;
+}
+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 PlaylistInfo {
+    name: string;
+    selectedTrack: number;
+}
+interface TrackLoadResult {
+    loadType: LoadType.Track;
+    data: APITrack;
+}
+interface APIPlaylist<PluginInfo extends JsonObject = CommonPluginInfo> {
+    info: PlaylistInfo;
+    pluginInfo: PluginInfo;
+    tracks: APITrack[];
+}
+interface PlaylistLoadResult {
+    loadType: LoadType.Playlist;
+    data: APIPlaylist;
+}
+interface SearchLoadResult {
+    loadType: LoadType.Search;
+    data: APITrack[];
+}
+interface EmptyLoadResult {
+    loadType: LoadType.Empty;
+    data: EmptyObject;
+}
+interface ErrorLoadResult {
+    loadType: LoadType.Error;
+    data: Exception;
+}
+type LoadResult = TrackLoadResult | PlaylistLoadResult | SearchLoadResult | EmptyLoadResult | ErrorLoadResult;
+interface APIPlayer {
+    guildId: string;
+    track: APITrack | null;
+    volume: number;
+    paused: boolean;
+    state: PlayerState;
+    voice: APIVoiceState;
+    filters: Filters;
+}
+interface APIVoiceState {
+    token: string;
+    endpoint: string;
+    sessionId: string;
+    channelId: string | null;
+}
+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 EqualizerBand {
+    band: number;
+    gain: number;
+}
+type EqualizerFilter = EqualizerBand[];
+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 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 PlayerUpdateTrackData<UserData extends JsonObject = CommonUserData> {
+    encoded?: string | null;
+    identifier?: string;
+    userData?: UserData;
+}
+interface SessionUpdateRequestBody {
+    resuming?: boolean;
+    timeout?: number;
+}
+type SessionUpdateResponseBody = Required<SessionUpdateRequestBody>;
+interface LavalinkInfo {
+    version: LavalinkVersion;
+    buildTime: number;
+    git: LavalinkGit;
+    jvm: string;
+    lavaplayer: string;
+    sourceManagers: string[];
+    filters: string[];
+    plugins: LavalinkPlugin[];
+}
+interface LavalinkVersion {
+    semver: string;
+    major: number;
+    minor: number;
+    patch: number;
+    preRelease: string | null;
+    build: string | null;
+}
+interface LavalinkGit {
+    branch: string;
+    commit: string;
+    commitTime: number;
+}
+interface LavalinkPlugin {
+    name: string;
+    version: string;
+}
+interface IPBlock {
+    type: IPBlockType;
+    size: string;
+}
+interface FailingAddress {
+    failingAddress: string;
+    failingTimestamp: number;
+    failingTime: string;
+}
+interface BaseRoutePlannerDetails {
+    ipBlock: IPBlock;
+    failingAddresses: FailingAddress[];
+}
+interface RotatingRoutePlannerDetails extends BaseRoutePlannerDetails {
+    rotateIndex: string;
+    ipIndex: string;
+    currentAddress: string;
+}
+interface NanoRoutePlannerDetails extends BaseRoutePlannerDetails {
+    currentAddressIndex: string;
+}
+interface RotatingNanoRoutePlannerDetails extends BaseRoutePlannerDetails {
+    currentAddressIndex: string;
+    blockIndex: string;
+}
+interface BalancingRoutePlannerDetails extends BaseRoutePlannerDetails {
+}
+interface RotatingRoutePlannerStatus {
+    class: RoutePlannerType.Rotating;
+    details: RotatingRoutePlannerDetails;
+}
+interface NanoRoutePlannerStatus {
+    class: RoutePlannerType.Nano;
+    details: NanoRoutePlannerDetails;
+}
+interface RotatingNanoRoutePlannerStatus {
+    class: RoutePlannerType.RotatingNano;
+    details: RotatingNanoRoutePlannerDetails;
+}
+interface BalancingRoutePlannerStatus {
+    class: RoutePlannerType.Balancing;
+    details: BalancingRoutePlannerDetails;
+}
+interface NullishRoutePlannerStatus {
+    class: null;
+    details: null;
+}
+type RoutePlannerStatus = RotatingRoutePlannerStatus | NanoRoutePlannerStatus | RotatingNanoRoutePlannerStatus | BalancingRoutePlannerStatus | NullishRoutePlannerStatus;
+
+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 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];
+}
+
+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 NodeMetrics {
+    total: number;
+    connected: number;
+    ready: number;
+    reconnecting: number;
+    players: number;
+    playingPlayers: 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;
+        }>;
+    };
+}
+
+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;
+}
+
+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;
+}
+
+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>;
+}
+
+declare class Playlist<PluginInfo extends JsonObject = CommonPluginInfo> {
+    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>;
+}
+
+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;
+}
+
+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) | {
+        title?: string;
+        author?: string;
+        duration?: number | {
+            min?: number;
+            max?: number;
+        };
+        uri?: string;
+        identifier?: string;
+        sourceName?: string;
+        isStream?: boolean;
+        isSeekable?: boolean;
+    }): Array<{
+        track: Track;
+        index: number;
+    }>;
+    findTrack(predicate: ((track: Track, 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;
+        index: number;
+    } | null;
+    getTracks(start: number, end?: number): Track[];
+    shiftPrevious(): Track | null;
+}
+
+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"> {
+    guildId: string;
+    voiceId: string;
+    node?: string;
+    context?: Context;
+}
+
+interface CommonDispatchPayloadInfo {
+    op: 0;
+    s: number;
+}
+interface BotReadyPayload extends CommonDispatchPayloadInfo {
+    t: "READY";
+    d: {
+        user: {
+            id: string;
+        };
+    };
+}
+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;
+        suppress: boolean;
+    };
+}
+interface VoiceServerUpdatePayload extends CommonDispatchPayloadInfo {
+    t: "VOICE_SERVER_UPDATE";
+    d: {
+        token: string;
+        guild_id: string;
+        endpoint: string | null;
+    };
+}
+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"> {
+}
+
+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;
+    };
+}
+interface LyricsConfig {
+    sources: {
+        lavalink: boolean;
+        lrclib: boolean;
+        musixmatch: boolean;
+        genius: boolean;
+    };
+    apiKeys?: {
+        musixmatch?: string;
+        genius?: string;
+    };
+}
+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;
+    };
+}
+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;
+}
+
+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 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;
+}
+
+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 CLIENT_NAME: string;
+declare const CLIENT_VERSION: string;
+declare const PACKAGE_INFO: Readonly<{
+    name: string;
+    version: string;
+    repository: string;
+    description: string | undefined;
+}>;
+
+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 };