magmastream 2.9.3-dev.3 → 2.9.3-dev.31

package/dist/structures/Types.d.ts

@@ -0,0 +1,1315 @@
+import type { User as DJSUser, ClientUser as DJSClientUser, Message as DJSMessage, Guild as DJSGuild } from "discord.js";
+import type { User as OceanicUser, Message as OceanicMessage, Guild as OceanicGuild } from "oceanic.js";
+import type { User as DenoUser, Message as DenoMessage, Guild as DenoGuild } from "@discordeno/bot";
+import type { User as ErisUser, Message as ErisMessage, Guild as ErisGuild } from "eris";
+import type { User as SeyfertUser, ClientUser as SeyfertClientUser, Message as SeyfertMessage, Guild as SeyfertGuild } from "seyfert";
+import { JsonQueue } from "../statestorage/JsonQueue";
+import { MemoryQueue } from "../statestorage/MemoryQueue";
+import { RedisQueue } from "../statestorage/RedisQueue";
+import { AutoPlayPlatform, LoadTypes, ManagerEventTypes, PlayerStateEventTypes, SearchPlatform, SeverityTypes, StateStorageType, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, UseNodeOptions } from "./Enums";
+import { Node } from "./Node";
+import { Player } from "./Player";
+import { Plugin } from "./Plugin";
+/**
+ * Manager Options
+ */
+export interface ManagerOptions {
+    /** The state storage options.
+     *
+     * @default { type: StateStorageType.Collection, deleteDestroyedPlayers: true }
+     */
+    stateStorage?: StateStorageOptions;
+    /** Enable priority mode over least player count or load balancing?
+     * @default false
+     */
+    enablePriorityMode?: boolean;
+    /** Automatically play the next track when the current one ends.
+     * @default true
+     */
+    playNextOnEnd?: boolean;
+    /** An array of search platforms to use for autoplay. First to last matters
+     * Use enum `AutoPlayPlatform`.
+     * @default [AutoPlayPlatform.YouTube]
+     */
+    autoPlaySearchPlatforms?: AutoPlayPlatform[];
+    /** The client ID to use. */
+    clientId?: string;
+    /** Value to use for the `Client-Name` header.
+     *  @default "Magmastream"
+     *
+     * For NodeLink, leave it empty.
+     */
+    clientName?: string;
+    /** The array of shard IDs connected to this manager instance.
+     * @default 0
+     */
+    clusterId?: number;
+    /** List of plugins to load. */
+    enabledPlugins?: Plugin[];
+    /** The default search platform to use.
+     * Use enum `SearchPlatform`.
+     * @default SearchPlatform.YouTube
+     */
+    defaultSearchPlatform?: SearchPlatform;
+    /** The last.fm API key.
+     * If you need to create one go here: https://www.last.fm/api/account/create.
+     * If you already have one, get it from here: https://www.last.fm/api/accounts. */
+    lastFmApiKey?: string;
+    /** The maximum number of previous tracks to store.
+     * @default 20
+     */
+    maxPreviousTracks?: number;
+    /** The array of nodes to connect to. */
+    nodes?: NodeOptions[];
+    /** Whether the YouTube video titles should be replaced if the Author does not exactly match.
+     * @default false
+     */
+    normalizeYouTubeTitles?: boolean;
+    /** An array of track properties to keep. `track` will always be present. */
+    trackPartial?: TrackPartial[];
+    /** Use the least amount of players or least load?
+     * Use enum `UseNodeOptions`.
+     * @default UseNodeOptions.LeastPlayers
+     */
+    useNode?: UseNodeOptions.LeastLoad | UseNodeOptions.LeastPlayers;
+    /** Whether the manager should listen to SIGINT and SIGTERM events.
+     * @default true
+     */
+    listenToSIGEvents?: boolean;
+    /**
+     * Function to send data to the websocket.
+     * @param id The ID of the node to send the data to.
+     * @param payload The payload to send.
+     */
+    send?: (packet: DiscordPacket) => unknown;
+    /**
+     * Optional user cache getter.
+     * When resolving a user from a partial ID, this function will be called first.
+     * Should return the full user object if cached, or undefined if not.
+     * @param id The ID of the user to get.
+     * @returns The user object if cached, or undefined if not.
+     */
+    getUser?: (id: string) => AnyUser | undefined;
+    /**
+     * Optional guild cache getter.
+     * When resolving a guild from a partial ID, this function will be called first.
+     * Should return the full guild object if cached, or undefined if not.
+     * @param id The ID of the guild to get.
+     * @returns The guild object if cached, or undefined if not.
+     */
+    getGuild?: (id: string) => AnyGuild | undefined;
+}
+/**
+ * State Storage Options
+ */
+export interface StateStorageOptions {
+    type: StateStorageType;
+    redisConfig?: RedisConfig;
+    jsonConfig?: JsonConfig;
+    deleteDestroyedPlayers?: boolean;
+}
+/**
+ * Node Options
+ */
+export interface NodeOptions {
+    /** The host for the node. */
+    host: string;
+    /** The port for the node.
+     * @default 2333
+     */
+    port?: number;
+    /** The password for the node.
+     * @default "youshallnotpass"
+     */
+    password?: string;
+    /** Whether the host uses SSL.
+     * @default false
+     */
+    useSSL?: boolean;
+    /** The identifier for the node.
+     * @default host
+     */
+    identifier?: string;
+    /** The maxRetryAttempts for the node.
+     * @default 30
+     */
+    maxRetryAttempts?: number;
+    /** The retryDelayMs for the node.
+     * @default 60000
+     */
+    retryDelayMs?: number;
+    /** Whether to resume the previous session.
+     * @default false
+     */
+    enableSessionResumeOption?: boolean;
+    /** The time in seconds the lavalink server will wait before it removes the player.
+     * @default 60
+     */
+    sessionTimeoutSeconds?: number;
+    /** The timeout used for api calls.
+     * @default 10000
+     */
+    apiRequestTimeoutMs?: number;
+    /** Priority of the node.
+     * @default 0
+     */
+    nodePriority?: number;
+    /** Whether the node is a NodeLink.
+     * @default false
+     */
+    isNodeLink?: boolean;
+    /** Whether the node is a backup node.
+     * @default false
+     */
+    isBackup?: boolean;
+}
+/**
+ * Portable User
+ */
+export interface PortableUser {
+    id: string;
+    username?: string;
+}
+/**
+ * Any user
+ */
+export type AnyUser = PortableUser | DJSUser | DJSClientUser | OceanicUser | DenoUser | ErisUser | SeyfertUser | SeyfertClientUser;
+/**
+ * Portable Message
+ */
+export interface PortableMessage {
+    id: string;
+}
+/**
+ * Any message
+ */
+export type AnyMessage = PortableMessage | DJSMessage | OceanicMessage | DenoMessage | ErisMessage | SeyfertMessage;
+/**
+ * Any guild
+ */
+export type AnyGuild = DJSGuild | OceanicGuild | DenoGuild | ErisGuild | SeyfertGuild<"cached">;
+/**
+ * Discord Packet
+ */
+export interface DiscordPacket {
+    /**
+     * The opcode for the payload
+     */
+    op: number;
+    /**
+     * Event data
+     */
+    d: any;
+    /**
+     * Sequence number, used for resuming sessions and heartbeats
+     */
+    s?: number;
+    /**
+     * The event name for this payload
+     */
+    t?: string;
+}
+/**
+ * Player Update Voice State
+ */
+export interface PlayerUpdateVoiceState {
+    /**
+     * The session id of the voice connection
+     */
+    sessionId: string;
+    /**
+     * Event data
+     */
+    event: VoiceServerUpdate;
+}
+/**
+ * Voice Server Update
+ */
+export interface VoiceServerUpdate {
+    /**
+     * The token for the session
+     */
+    token: string;
+    /**
+     * Guild if of the voice connection
+     */
+    guild_id: string;
+    /**
+     * The endpoint lavalink will connect to
+     */
+    endpoint: string;
+}
+/**
+ * Redis Configuration
+ */
+export interface RedisConfig {
+    host: string;
+    port: string;
+    password?: string;
+    db?: number;
+    prefix?: string;
+}
+/**
+ * JSON Configuration
+ */
+export interface JsonConfig {
+    path: string;
+}
+/**
+ * Player State Update Event
+ */
+export type PlayerStateUpdateEvent = {
+    changeType: PlayerStateEventTypes.TrackChange;
+    details: TrackChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.PauseChange;
+    details: PauseChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.QueueChange;
+    details: QueueChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.ConnectionChange;
+    details: ConnectionChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.AutoPlayChange;
+    details: AutoplayChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.ChannelChange;
+    details: ChannelChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.VolumeChange;
+    details: VolumeChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.RepeatChange;
+    details: RepeatChangeEvent;
+} | {
+    changeType: PlayerStateEventTypes.FilterChange;
+    details: FilterChangeEvent;
+};
+/**
+ * Autoplay Change Event
+ */
+interface AutoplayChangeEvent {
+    type: "autoplay";
+    action: "toggle";
+    previousAutoplay: boolean | null;
+    currentAutoplay: boolean | null;
+}
+/**
+ * Connection Change Event
+ */
+interface ConnectionChangeEvent {
+    type: "connection";
+    action: "connect" | "disconnect";
+    previousConnection: boolean | null;
+    currentConnection: boolean | null;
+}
+interface FilterChangeEvent {
+    type: "filter";
+    action: "change";
+}
+/**
+ * Repeat Change Event
+ */
+interface RepeatChangeEvent {
+    type: "repeat";
+    action: "dynamic" | "track" | "queue" | "none";
+    previousRepeat: "dynamic" | "track" | "queue" | null;
+    currentRepeat: "dynamic" | "track" | "queue" | null;
+}
+/**
+ * Pause Change Event
+ */
+interface PauseChangeEvent {
+    type: "pause";
+    action: "pause" | "resume" | "toggle";
+    previousPause: boolean | null;
+    currentPause: boolean | null;
+}
+/**
+ * Queue Change Event
+ */
+interface QueueChangeEvent {
+    type: "queue";
+    action: "add" | "remove" | "clear" | "shuffle" | "roundRobin" | "userBlock" | "autoPlayAdd";
+    previousQueueLength: number | null;
+    currentQueueLength: number | null;
+    tracks?: Track[];
+}
+/**
+ * Track Change Event
+ */
+interface TrackChangeEvent {
+    type: "track";
+    action: "start" | "end" | "previous" | "timeUpdate" | "autoPlay";
+    track: Track;
+    previousTime?: number | null;
+    currentTime?: number | null;
+}
+/**
+ * Volume Change Event
+ */
+interface VolumeChangeEvent {
+    type: "volume";
+    action: "adjust";
+    previousVolume: number | null;
+    currentVolume: number | null;
+}
+/**
+ * Channel Change Event
+ */
+interface ChannelChangeEvent {
+    type: "channel";
+    action: "text" | "voice";
+    previousChannel: string | null;
+    currentChannel: string | null;
+}
+/**
+ * Track
+ */
+export interface Track {
+    /** The base64 encoded track. */
+    readonly track: string;
+    /** The artwork url of the track. */
+    readonly artworkUrl: string | null;
+    /** The track source name. */
+    readonly sourceName: TrackSourceName;
+    /** The title of the track. */
+    title: string;
+    /** The identifier of the track. */
+    readonly identifier: string;
+    /** The author of the track. */
+    author: string;
+    /** The duration of the track. */
+    readonly duration: number;
+    /** The ISRC of the track. */
+    readonly isrc: string;
+    /** If the track is seekable. */
+    readonly isSeekable: boolean;
+    /** If the track is a stream.. */
+    readonly isStream: boolean;
+    /** The uri of the track. */
+    readonly uri: string;
+    /** The thumbnail of the track or null if it's a unsupported source. */
+    readonly thumbnail: string | null;
+    /** The user that requested the track. */
+    requester: AnyUser;
+    /** Displays the track thumbnail with optional size or null if it's a unsupported source. */
+    displayThumbnail(size?: Sizes): string | null;
+    /** Additional track info provided by plugins. */
+    pluginInfo: TrackPluginInfo;
+    /** Add your own data to the track. */
+    customData: Record<string, unknown>;
+    /** If the track got added by autoplay. */
+    readonly isAutoplay: boolean;
+}
+/**
+ * Track Plugin Info
+ */
+export interface TrackPluginInfo {
+    albumName?: string;
+    albumUrl?: string;
+    artistArtworkUrl?: string;
+    artistUrl?: string;
+    isPreview?: string;
+    previewUrl?: string;
+}
+/**
+ * Search Query
+ */
+export interface SearchQuery {
+    /** The source to search from. */
+    source?: SearchPlatform;
+    /** The query to search for. */
+    query: string;
+}
+/**
+ * Lavalink Response
+ */
+export interface LavalinkResponse {
+    loadType: LoadTypes;
+    data: TrackData[] | PlaylistRawData;
+}
+/**
+ * Track Data
+ */
+export interface TrackData {
+    /** The track information. */
+    encoded: string;
+    /** The detailed information of the track. */
+    info: TrackDataInfo;
+    /** Additional track info provided by plugins. */
+    pluginInfo: Record<string, string>;
+}
+/**
+ * Playlist Raw Data
+ */
+export interface PlaylistRawData {
+    info: {
+        /** The playlist name. */
+        name: string;
+    };
+    /** Addition info provided by plugins. */
+    pluginInfo: object;
+    /** The tracks of the playlist */
+    tracks: TrackData[];
+}
+/**
+ * Track Data Info
+ */
+export interface TrackDataInfo {
+    identifier: string;
+    isSeekable: boolean;
+    author: string;
+    length: number;
+    isrc?: string;
+    isStream: boolean;
+    title: string;
+    uri?: string;
+    artworkUrl?: string;
+    sourceName?: TrackSourceName;
+}
+/**
+ * LavaPlayer
+ */
+export interface LavaPlayer {
+    guildId: string;
+    track: TrackData;
+    volume: number;
+    paused: boolean;
+    state: {
+        time: number;
+        position: number;
+        connected: boolean;
+        ping: number;
+    };
+    voice: LavalinkVoiceStateResponse;
+    filters: Record<string, unknown>;
+}
+/**
+ * Error or Empty Search Result
+ */
+export interface ErrorOrEmptySearchResult {
+    /** The load type of the result. */
+    loadType: LoadTypes.Empty | LoadTypes.Error;
+}
+/**
+ * Track Search Result
+ */
+export interface TrackSearchResult {
+    /** The load type is always 'track' */
+    loadType: LoadTypes.Track;
+    /** The track obtained */
+    tracks: [Track];
+}
+/**
+ * Search Result
+ */
+export interface SearchSearchResult {
+    /** The load type is always 'search' */
+    loadType: LoadTypes.Search;
+    /** The tracks of the search result */
+    tracks: Track[];
+}
+/**
+ * Playlist Search Result
+ */
+export interface PlaylistSearchResult {
+    /** The playlist load type */
+    loadType: LoadTypes.Playlist;
+    /** The tracks of the playlist */
+    tracks: Track[];
+    /** The playlist info */
+    playlist: PlaylistData;
+}
+/**
+ * Album Search Result
+ */
+export interface AlbumSearchResult {
+    loadType: LoadTypes.Album;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+/**
+ * Artist Search Result
+ */
+export interface ArtistSearchResult {
+    loadType: LoadTypes.Artist;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+/**
+ * Station Search Result
+ */
+export interface StationSearchResult {
+    loadType: LoadTypes.Station;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+/**
+ * Podcast Search Result
+ */
+export interface PodcastSearchResult {
+    loadType: LoadTypes.Podcast;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+/**
+ * Show Search Result
+ */
+export interface ShowSearchResult {
+    loadType: LoadTypes.Show;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+/**
+ * Short Search Result
+ */
+export interface ShortSearchResult {
+    loadType: LoadTypes.Short;
+    tracks: [Track];
+}
+/**
+ * Playlist Data
+ */
+export interface PlaylistData {
+    /** The playlist name. */
+    name: string;
+    /** Requester of playlist. */
+    requester: AnyUser;
+    /** More playlist information. */
+    playlistInfo: PlaylistInfoData[];
+    /** The length of the playlist. */
+    duration: number;
+    /** The songs of the playlist. */
+    tracks: Track[];
+}
+/**
+ * Playlist Info Data
+ */
+export interface PlaylistInfoData {
+    /** Url to playlist. */
+    url: string;
+    /** Type is always playlist in that case. */
+    type: string;
+    /** ArtworkUrl of playlist */
+    artworkUrl: string;
+    /** Number of total tracks in playlist */
+    totalTracks: number;
+    /** Author of playlist */
+    author: string;
+}
+/**
+ * Manager Events
+ */
+export interface ManagerEvents {
+    [ManagerEventTypes.ChapterStarted]: [player: Player, track: Track, payload: SponsorBlockChapterStarted];
+    [ManagerEventTypes.ChaptersLoaded]: [player: Player, track: Track, payload: SponsorBlockChaptersLoaded];
+    [ManagerEventTypes.Debug]: [info: string];
+    [ManagerEventTypes.LyricsFound]: [player: Player, track: Track, payload: LyricsFoundEvent];
+    [ManagerEventTypes.LyricsLine]: [player: Player, track: Track, payload: LyricsLineEvent];
+    [ManagerEventTypes.LyricsNotFound]: [player: Player, track: Track, payload: LyricsNotFoundEvent];
+    [ManagerEventTypes.NodeConnect]: [node: Node];
+    [ManagerEventTypes.NodeCreate]: [node: Node];
+    [ManagerEventTypes.NodeDestroy]: [node: Node];
+    [ManagerEventTypes.NodeDisconnect]: [node: Node, reason: {
+        code?: number;
+        reason?: string;
+    }];
+    [ManagerEventTypes.NodeError]: [node: Node, error: Error];
+    [ManagerEventTypes.NodeRaw]: [payload: unknown];
+    [ManagerEventTypes.NodeReconnect]: [node: Node];
+    [ManagerEventTypes.PlayerCreate]: [player: Player];
+    [ManagerEventTypes.PlayerDestroy]: [player: Player];
+    [ManagerEventTypes.PlayerDisconnect]: [player: Player, oldChannel: string];
+    [ManagerEventTypes.PlayerMove]: [player: Player, oldChannel: string, newChannel: string];
+    [ManagerEventTypes.PlayerRestored]: [player: Player, node: Node];
+    [ManagerEventTypes.PlayerStateUpdate]: [oldPlayer: Player, newPlayer: Player, changeType: PlayerStateUpdateEvent];
+    [ManagerEventTypes.QueueEnd]: [player: Player, track: Track, payload: TrackEndEvent];
+    [ManagerEventTypes.RestoreComplete]: [node: Node];
+    [ManagerEventTypes.SegmentSkipped]: [player: Player, track: Track, payload: SponsorBlockSegmentSkipped];
+    [ManagerEventTypes.SegmentsLoaded]: [player: Player, track: Track, payload: SponsorBlockSegmentsLoaded];
+    [ManagerEventTypes.SocketClosed]: [player: Player, payload: WebSocketClosedEvent];
+    [ManagerEventTypes.TrackEnd]: [player: Player, track: Track, payload: TrackEndEvent];
+    [ManagerEventTypes.TrackError]: [player: Player, track: Track, payload: TrackExceptionEvent];
+    [ManagerEventTypes.TrackStart]: [player: Player, track: Track, payload: TrackStartEvent];
+    [ManagerEventTypes.TrackStuck]: [player: Player, track: Track, payload: TrackStuckEvent];
+    [ManagerEventTypes.VoiceReceiverDisconnect]: [player: Player];
+    [ManagerEventTypes.VoiceReceiverConnect]: [player: Player];
+    [ManagerEventTypes.VoiceReceiverError]: [player: Player, error: Error];
+    [ManagerEventTypes.VoiceReceiverStartSpeaking]: [player: Player, data: unknown];
+    [ManagerEventTypes.VoiceReceiverEndSpeaking]: [player: Player, data: unknown];
+}
+/**
+ * Voice Packet
+ */
+export interface VoicePacket {
+    t?: "VOICE_SERVER_UPDATE" | "VOICE_STATE_UPDATE";
+    d: VoiceState | VoiceServer;
+}
+/**
+ * Voice Server
+ */
+export interface VoiceServer {
+    token: string;
+    guild_id: string;
+    endpoint: string;
+}
+export interface Extendable {
+    Player: typeof Player;
+    Queue: typeof MemoryQueue | typeof RedisQueue | typeof JsonQueue;
+    Node: typeof Node;
+}
+/**
+ * Voice State
+ */
+export interface VoiceState {
+    op: "voiceUpdate";
+    guildId: string;
+    event: VoiceServer;
+    sessionId?: string;
+    channelId?: string;
+}
+/**
+ * Voice State
+ */
+export interface VoiceState {
+    guild_id: string;
+    user_id: string;
+    session_id: string;
+    channel_id: string;
+}
+/**
+ * NodeStats interface
+ */
+export interface NodeStats {
+    /** The amount of players on the node. */
+    players: number;
+    /** The amount of playing players on the node. */
+    playingPlayers: number;
+    /** The uptime for the node. */
+    uptime: number;
+    /** The memory stats for the node. */
+    memory: MemoryStats;
+    /** The cpu stats for the node. */
+    cpu: CPUStats;
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
+}
+/**
+ * Node Message
+ */
+export interface NodeMessage extends NodeStats {
+    type: PlayerEventType;
+    op: "stats" | "playerUpdate" | "event";
+    guildId: string;
+}
+/**
+ * PlayerEvent interface
+ */
+export interface PlayerEvent {
+    op: "event";
+    type: PlayerEventType;
+    guildId: string;
+}
+/**
+ * Exception interface
+ */
+export interface Exception {
+    message: string;
+    severity: SeverityTypes;
+    cause: string;
+}
+/**
+ * TrackStartEvent interface
+ */
+export interface TrackStartEvent extends PlayerEvent {
+    type: "TrackStartEvent";
+    track: TrackData;
+}
+/**
+ * TrackEndEvent interface
+ */
+export interface TrackEndEvent extends PlayerEvent {
+    type: "TrackEndEvent";
+    track: TrackData;
+    reason: TrackEndReasonTypes;
+}
+/**
+ * TrackExceptionEvent interface
+ */
+export interface TrackExceptionEvent extends PlayerEvent {
+    exception?: Exception;
+    guildId: string;
+    type: "TrackExceptionEvent";
+}
+/**
+ * TrackStuckEvent interface
+ */
+export interface TrackStuckEvent extends PlayerEvent {
+    type: "TrackStuckEvent";
+    thresholdMs: number;
+}
+/**
+ * WebSocketClosedEvent interface
+ */
+export interface WebSocketClosedEvent extends PlayerEvent {
+    type: "WebSocketClosedEvent";
+    code: number;
+    reason: string;
+    byRemote: boolean;
+}
+/**
+ * SponsorBlockSegmentsLoaded interface
+ */
+export interface SponsorBlockSegmentsLoaded extends PlayerEvent {
+    type: "SegmentsLoaded";
+    segments: {
+        category: string;
+        start: number;
+        end: number;
+    }[];
+}
+/**
+ * SponsorBlockSegmentSkipped interface
+ */
+export interface SponsorBlockSegmentSkipped extends PlayerEvent {
+    type: "SegmentSkipped";
+    segment: {
+        category: string;
+        start: number;
+        end: number;
+    };
+}
+/**
+ * SponsorBlockChapterStarted interface
+ */
+export interface SponsorBlockChapterStarted extends PlayerEvent {
+    type: "ChapterStarted";
+    /** The chapter which started */
+    chapter: {
+        /** The name of the chapter */
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    };
+}
+/**
+ * SponsorBlockChaptersLoaded interface
+ */
+export interface SponsorBlockChaptersLoaded extends PlayerEvent {
+    type: "ChaptersLoaded";
+    /** All chapters loaded */
+    chapters: {
+        /** The name of the chapter */
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+}
+/**
+ * NodeStats interface
+ */
+export interface NodeStats {
+    /** The amount of players on the node. */
+    players: number;
+    /** The amount of playing players on the node. */
+    playingPlayers: number;
+    /** The uptime for the node. */
+    uptime: number;
+    /** The memory stats for the node. */
+    memory: MemoryStats;
+    /** The cpu stats for the node. */
+    cpu: CPUStats;
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
+}
+/**
+ * MemoryStats interface
+ */
+export interface MemoryStats {
+    /** The free memory of the allocated amount. */
+    free: number;
+    /** The used memory of the allocated amount. */
+    used: number;
+    /** The total allocated memory. */
+    allocated: number;
+    /** The reservable memory. */
+    reservable: number;
+}
+/**
+ * CPUStats interface
+ */
+export interface CPUStats {
+    /** The core amount the host machine has. */
+    cores: number;
+    /** The system load. */
+    systemLoad: number;
+    /** The lavalink load. */
+    lavalinkLoad: number;
+}
+/**
+ * FrameStats interface
+ */
+export interface FrameStats {
+    /** The amount of sent frames. */
+    sent?: number;
+    /** The amount of nulled frames. */
+    nulled?: number;
+    /** The amount of deficit frames. */
+    deficit?: number;
+}
+/**
+ * LavalinkInfo interface
+ */
+export interface LavalinkInfo {
+    version: {
+        semver: string;
+        major: number;
+        minor: number;
+        patch: number;
+        preRelease: string;
+    };
+    buildTime: number;
+    git: {
+        branch: string;
+        commit: string;
+        commitTime: number;
+    };
+    jvm: string;
+    lavaplayer: string;
+    sourceManagers: string[];
+    filters: string[];
+    plugins: {
+        name: string;
+        version: string;
+    }[];
+}
+/**
+ * LyricsLine interface
+ */
+export interface LyricsLine {
+    timestamp: number;
+    duration: number;
+    line: string;
+    plugin: object;
+}
+/**
+ * Lyrics interface
+ */
+export interface Lyrics {
+    source: string;
+    provider: string;
+    text?: string;
+    lines: LyricsLine[];
+    plugin: object[];
+}
+/**
+ * LyricsFoundEvent interface
+ */
+export interface LyricsFoundEvent extends PlayerEvent {
+    type: "LyricsFoundEvent";
+    guildId: string;
+    lyrics: Lyrics;
+}
+/**
+ * LyricsNotFoundEvent interface
+ */
+export interface LyricsNotFoundEvent extends PlayerEvent {
+    type: "LyricsNotFoundEvent";
+    guildId: string;
+}
+/**
+ * LyricsLineEvent interface
+ */
+export interface LyricsLineEvent extends PlayerEvent {
+    type: "LyricsLineEvent";
+    guildId: string;
+    lineIndex: number;
+    line: LyricsLine;
+    skipped: boolean;
+}
+/**
+ * NodeLink Get Lyrics Multiple interface
+ */
+export interface NodeLinkGetLyricsMultiple {
+    loadType: "lyricsMultiple";
+    data: NodeLinkGetLyricsData[];
+}
+/**
+ * NodeLink Get Lyrics Empty interface
+ */
+export interface NodeLinkGetLyricsEmpty {
+    loadType: "empty";
+    data: Record<never, never>;
+}
+/**
+ * NodeLink Get Lyrics Data interface
+ */
+interface NodeLinkGetLyricsData {
+    name: string;
+    synced: boolean;
+    data: {
+        startTime?: number;
+        endTime?: number;
+        text: string;
+    }[];
+    rtl: boolean;
+}
+/**
+ * NodeLink Get Lyrics Single interface
+ */
+export interface NodeLinkGetLyricsSingle {
+    loadType: "lyricsSingle";
+    data: NodeLinkGetLyricsData;
+}
+/**
+ * NodeLink Get Lyrics Error interface
+ */
+export interface NodeLinkGetLyricsError {
+    loadType: "error";
+    data: {
+        message: string;
+        severity: Severity;
+        cause: string;
+        trace?: string;
+    };
+}
+/**
+ * Start Speaking Event Voice Receiver Data interface
+ */
+export interface StartSpeakingEventVoiceReceiverData {
+    /**
+     * The user ID of the user who started speaking.
+     */
+    userId: string;
+    /**
+     * The guild ID of the guild where the user started speaking.
+     */
+    guildId: string;
+}
+/**
+ * End Speaking Event Voice Receiver Data interface
+ */
+export interface EndSpeakingEventVoiceReceiverData {
+    /**
+     * The user ID of the user who stopped speaking.
+     */
+    userId: string;
+    /**
+     * The guild ID of the guild where the user stopped speaking.
+     */
+    guildId: string;
+    /**
+     * The audio data received from the user in base64.
+     */
+    data: string;
+    /**
+     * The type of the audio data. Can be either opus or pcm. Older versions may include ogg/opus.
+     */
+    type: "opus" | "pcm";
+}
+/**
+ * Base Voice Receiver Event interface
+ */
+interface BaseVoiceReceiverEvent {
+    op: "speak";
+}
+/**
+ * Start Speaking Event Voice Receiver interface
+ */
+export interface StartSpeakingEventVoiceReceiver extends BaseVoiceReceiverEvent {
+    type: "startSpeakingEvent";
+    data: StartSpeakingEventVoiceReceiverData;
+}
+/**
+ * End Speaking Event Voice Receiver interface
+ */
+export interface EndSpeakingEventVoiceReceiver extends BaseVoiceReceiverEvent {
+    type: "endSpeakingEvent";
+    data: EndSpeakingEventVoiceReceiverData;
+}
+/**
+ * PlayerOptions interface
+ */
+export interface PlayerOptions {
+    /** The guild ID the Player belongs to. */
+    guildId: string;
+    /** The text channel the Player belongs to. */
+    textChannelId: string;
+    /** The voice channel the Player belongs to. */
+    voiceChannelId?: string;
+    /** The node identifier the Player uses. */
+    nodeIdentifier?: string;
+    /** The initial volume the Player will use. */
+    volume?: number;
+    /** If the player should mute itself. */
+    selfMute?: boolean;
+    /** If the player should deaf itself. */
+    selfDeafen?: boolean;
+    /** Whether to apply the volume as a filter. */
+    applyVolumeAsFilter?: boolean;
+    /** Whether to pause the player when the voice connection is disconnected. */
+    pauseOnDisconnect?: boolean;
+}
+/**
+ * PlayOptions interface
+ */
+export interface PlayOptions {
+    /** The position to start the track. */
+    readonly startTime?: number;
+    /** The position to end the track. */
+    readonly endTime?: number;
+    /** Whether to not replace the track if a play payload is sent. */
+    readonly noReplace?: boolean;
+}
+/**
+ * RestPlayOptions interface
+ */
+export interface RestPlayOptions {
+    guildId: string;
+    data: {
+        /** The base64 encoded track. */
+        encodedTrack?: string;
+        /** The track ID. */
+        identifier?: string;
+        /** The track time to start at. */
+        startTime?: number;
+        /** The track time to end at. */
+        endTime?: number;
+        /** The player volume level. */
+        volume?: number;
+        /** The player position in a track. */
+        position?: number;
+        /** Whether the player is paused. */
+        paused?: boolean;
+        /** The audio effects. */
+        filters?: object;
+        /** voice payload. */
+        voice?: LavalinkVoiceStateUpdate;
+        /** Whether to not replace the track if a play payload is sent. */
+        noReplace?: boolean;
+    };
+}
+/**
+ * PlayerStateEntry interface
+ */
+export interface SerializedPlayerState {
+    clusterId: number;
+    guildId: string;
+    voiceChannelId: string | null;
+    textChannelId: string | null;
+    volume: number;
+    position: number;
+    isAutoplay?: boolean;
+    autoplayTries?: number;
+    paused: boolean;
+    playing: boolean;
+    trackRepeat: boolean;
+    queueRepeat: boolean;
+    dynamicRepeat: boolean;
+    dynamicLoopInterval?: number;
+    voiceState: VoiceState;
+    options: PlayerOptions;
+    node: {
+        sessionId: string;
+        options: {
+            identifier: string;
+        };
+    } | null;
+    queue: {
+        current: Track | null;
+        tracks: Track[];
+        previous: Array<Track | null>;
+    };
+    filters: {
+        bassBoostlevel: number | null;
+        equalizer: EqualizerBand[];
+        distortion: DistortionOptions;
+        karaoke: KaraokeOptions;
+        timescale: TimescaleOptions;
+        vibrato: VibratoOptions;
+        rotation: RotationOptions;
+        reverb: ReverbOptions;
+        volume: number;
+        filterStatus: Record<string, boolean>;
+    } | null;
+    data?: Record<string, unknown> & {
+        clientUser?: AnyUser;
+        nowPlayingMessage?: {
+            id: string;
+            channelId: string;
+            guildId: string;
+        } | null;
+    };
+}
+/**
+ * Lavalink voice state response
+ */
+export type LavalinkVoiceStateResponse = {
+    token: string;
+    endpoint: string;
+    sessionId: string;
+    channelId: string | null;
+};
+/**
+ * Lavalink voice state update
+ */
+export type LavalinkVoiceStateUpdate = {
+    token: string;
+    endpoint: string;
+    sessionId: string;
+    channelId: string;
+};
+/**
+ * ManagerInitOptions interface
+ */
+export interface ManagerInitOptions {
+    clientId?: string;
+    clusterId?: number;
+}
+/**
+ * EqualizerBand interface
+ */
+export interface EqualizerBand {
+    /** The band number being 0 to 14. */
+    band: number;
+    /** The gain amount being -0.25 to 1.00, 0.25 being double. */
+    gain: number;
+}
+/** Options for adjusting the timescale of audio. */
+export interface TimescaleOptions {
+    speed?: number;
+    pitch?: number;
+    rate?: number;
+}
+/** Options for applying vibrato effect to audio. */
+export interface VibratoOptions {
+    frequency: number;
+    depth: number;
+}
+/** Options for applying rotation effect to audio. */
+export interface RotationOptions {
+    rotationHz: number;
+}
+/** Options for applying karaoke effect to audio. */
+export interface KaraokeOptions {
+    level?: number;
+    monoLevel?: number;
+    filterBand?: number;
+    filterWidth?: number;
+}
+/** Options for applying distortion effect to audio. */
+export interface DistortionOptions {
+    sinOffset?: number;
+    sinScale?: number;
+    cosOffset?: number;
+    cosScale?: number;
+    tanOffset?: number;
+    tanScale?: number;
+    offset?: number;
+    scale?: number;
+}
+/** Options for applying reverb effect to audio. */
+export interface ReverbOptions {
+    wet?: number;
+    dry?: number;
+    roomSize?: number;
+    damping?: number;
+}
+/**
+ * Queue interface
+ */
+export interface IQueue {
+    getCurrent(): Track | Promise<Track | null>;
+    setCurrent(track: Track | null): void | Promise<void>;
+    getPrevious(): Track[] | Promise<Track[]>;
+    addPrevious(track: Track | Track[]): void | Promise<void>;
+    setPrevious(track: Track | Track[]): void | Promise<void>;
+    /** Get newest track (index 0) */
+    popPrevious(): Track | Promise<Track | null>;
+    clearPrevious(): void | Promise<void>;
+    size(): number | Promise<number>;
+    totalSize(): number | Promise<number>;
+    duration(): number | Promise<number>;
+    add(track: Track | Track[], offset?: number): void | Promise<void>;
+    remove(start?: number, end?: number): Track[] | Promise<Track[]>;
+    clear(): void | Promise<void>;
+    dequeue(): Track | Promise<Track | undefined>;
+    enqueueFront(track: Track | Track[]): void | Promise<void>;
+    getTracks(): Track[] | Promise<Track[]>;
+    getSlice(start?: number, end?: number): Track[] | Promise<Track[]>;
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Track[] | Promise<Track[]>;
+    shuffle(): void | Promise<void>;
+    userBlockShuffle(): void | Promise<void>;
+    roundRobinShuffle(): void | Promise<void>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): T[] | Promise<T[]>;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track[] | Promise<Track[]>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track | Promise<Track | undefined>;
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean | Promise<boolean>;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean | Promise<boolean>;
+    destroy(): void | Promise<void>;
+}
+/**
+ * Sizes Enum type
+ */
+export type Sizes = "0" | "1" | "2" | "3" | "default" | "mqdefault" | "hqdefault" | "maxresdefault";
+/**
+ * Track Source Name Enum type
+ */
+export type TrackSourceName = keyof typeof TrackSourceTypes;
+/**
+ * Use Node Option Enum type
+ */
+export type UseNodeOption = keyof typeof UseNodeOptions;
+/**
+ * Track End Reason Enum type
+ */
+export type TrackEndReason = keyof typeof TrackEndReasonTypes;
+/**
+ * Player Event Type Enum type
+ */
+export type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted" | "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
+/**
+ * Severity Types Enum type
+ */
+export type Severity = keyof typeof SeverityTypes;
+/**
+ * SponsorBlock Segment Events Enum type
+ */
+export type SponsorBlockSegmentEvents = SponsorBlockSegmentSkipped | SponsorBlockSegmentsLoaded | SponsorBlockChapterStarted | SponsorBlockChaptersLoaded;
+/**
+ * SponsorBlock Segment Event Type Enum type
+ */
+export type SponsorBlockSegmentEventType = "SegmentSkipped" | "SegmentsLoaded" | "ChapterStarted" | "ChaptersLoaded";
+/**
+ * Player Events Enum type
+ */
+export type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents | LyricsEvent;
+/**
+ * Load Type Enum type
+ */
+export type LoadType = keyof typeof LoadTypes;
+/**
+ * NodeLink Get Lyrics Enum type
+ */
+export type NodeLinkGetLyrics = NodeLinkGetLyricsSingle | NodeLinkGetLyricsMultiple | NodeLinkGetLyricsEmpty | NodeLinkGetLyricsError;
+/**
+ * Voice Receiver Event Enum type
+ */
+export type VoiceReceiverEvent = StartSpeakingEventVoiceReceiver | EndSpeakingEventVoiceReceiver;
+/**
+ * Search Result Enum type
+ */
+export type SearchResult = TrackSearchResult | SearchSearchResult | PlaylistSearchResult | ErrorOrEmptySearchResult | AlbumSearchResult | ArtistSearchResult | StationSearchResult | PodcastSearchResult | ShowSearchResult | ShortSearchResult;
+/**
+ * Lyrics Event Enum type
+ */
+export type LyricsEvent = LyricsFoundEvent | LyricsNotFoundEvent | LyricsLineEvent;
+/**
+ * Lyrics Event Type Enum type
+ */
+export type LyricsEventType = "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
+export {};