@kattowo/distube 0.0.0-stage → 6.0.1

package/dist/index.d.mts

@@ -0,0 +1,3260 @@
+import * as discord_js from 'discord.js';
+import { Snowflake, Message, GuildTextBasedChannel, VoiceBasedChannel, VoiceState, Guild, GuildMember, Interaction, Collection, Client, ClientOptions } from 'discord.js';
+import { AudioResource, AudioPlayer, VoiceConnection } from '@discordjs/voice';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { ChildProcess } from 'node:child_process';
+import { Transform, TransformCallback, Readable } from 'node:stream';
+import { IncomingMessage } from 'node:http';
+
+/**
+ * A value that can be awaited.
+ *
+ * It is used by every method of DisTube that can be implemented
+ * synchronously or asynchronously: the plugin methods and the event
+ * listeners.
+ */
+type Awaitable<T = any> = T | PromiseLike<T>;
+/**
+ * Behavior when the {@link Events.ERROR} event is emitted but nobody listens to it.
+ * - `log` (default): the error is logged to the console instead of crashing the process
+ * - `throw`: the error is re-thrown (Node.js default behavior)
+ * - `ignore`: the error is silently discarded
+ */
+type UnhandledErrorBehavior = "log" | "throw" | "ignore";
+/**
+ * The events emitted by a {@link DisTube} instance.
+ */
+declare enum Events {
+    /**
+     * Emitted when DisTube encounters an error while playing songs.
+     *
+     * It is the only special event: Node.js crashes the process when the
+     * `"error"` event is emitted without any listener. DisTube handles it
+     * gracefully instead, following {@link DisTubeOptions.unhandledError}.
+     */
+    ERROR = "error",
+    /**
+     * Emitted after a new playlist is added to a {@link Queue}.
+     */
+    ADD_LIST = "addList",
+    /**
+     * Emitted after a new song is added to a {@link Queue}.
+     */
+    ADD_SONG = "addSong",
+    /**
+     * Emitted when a song starts playing.
+     */
+    PLAY_SONG = "playSong",
+    /**
+     * Emitted when a song finished playing.
+     */
+    FINISH_SONG = "finishSong",
+    /**
+     * Emitted when a {@link Queue} runs out of songs to play.
+     */
+    EMPTY = "empty",
+    /**
+     * Emitted when a {@link Queue} is finished, and its autoplay mode is
+     * disabled.
+     */
+    FINISH = "finish",
+    /**
+     * Emitted when a {@link Queue} is initialized, to change its default
+     * properties.
+     */
+    INIT_QUEUE = "initQueue",
+    /**
+     * Emitted when the autoplay mode is enabled and no related song could be
+     * found.
+     */
+    NO_RELATED = "noRelated",
+    /**
+     * Emitted when the bot is disconnected from a voice channel.
+     */
+    DISCONNECT = "disconnect",
+    /**
+     * Emitted when a {@link Queue} is deleted.
+     */
+    DELETE_QUEUE = "deleteQueue",
+    /**
+     * Emitted for logging FFmpeg debug information.
+     */
+    FFMPEG_DEBUG = "ffmpegDebug",
+    /**
+     * Emitted to provide debug information from DisTube's operation.
+     */
+    DEBUG = "debug"
+}
+/**
+ * The arguments of every {@link Events} event.
+ *
+ * It is the source of truth of the signature of the event listeners:
+ * @see {@link TypedDisTubeEvents}
+ */
+type DisTubeEvents = {
+    /**
+     * Emitted after a new playlist is added to a {@link Queue}.
+     */
+    [Events.ADD_LIST]: [queue: Queue, playlist: Playlist];
+    /**
+     * Emitted after a new song is added to a {@link Queue}.
+     */
+    [Events.ADD_SONG]: [queue: Queue, song: Song];
+    /**
+     * Emitted when a {@link Queue} is deleted.
+     */
+    [Events.DELETE_QUEUE]: [queue: Queue];
+    /**
+     * Emitted when the bot is disconnected from a voice channel.
+     */
+    [Events.DISCONNECT]: [queue: Queue];
+    /**
+     * Emitted when a {@link Queue} runs out of songs to play.
+     */
+    [Events.EMPTY]: [queue: Queue];
+    /**
+     * Emitted when DisTube encounters an error while playing songs.
+     */
+    [Events.ERROR]: [error: Error, queue: Queue, song: Song | undefined];
+    /**
+     * Emitted for logging FFmpeg debug information.
+     */
+    [Events.FFMPEG_DEBUG]: [debug: string];
+    /**
+     * Emitted to provide debug information from DisTube's operation.
+     */
+    [Events.DEBUG]: [debug: string];
+    /**
+     * Emitted when a {@link Queue} is finished, and its autoplay mode is
+     * disabled.
+     */
+    [Events.FINISH]: [queue: Queue];
+    /**
+     * Emitted when a song finished playing.
+     */
+    [Events.FINISH_SONG]: [queue: Queue, song: Song];
+    /**
+     * Emitted when a {@link Queue} is initialized.
+     */
+    [Events.INIT_QUEUE]: [queue: Queue];
+    /**
+     * Emitted when the autoplay mode is enabled and no related song could be
+     * found.
+     */
+    [Events.NO_RELATED]: [queue: Queue, error: DisTubeError];
+    /**
+     * Emitted when a song starts playing.
+     */
+    [Events.PLAY_SONG]: [queue: Queue, song: Song];
+};
+/**
+ * The typed event listeners of a {@link DisTube} instance.
+ *
+ * Every listener of an event receives the arguments of
+ * {@link DisTubeEvents}, and can be synchronous or asynchronous.
+ */
+type TypedDisTubeEvents = {
+    [K in keyof DisTubeEvents]: (...args: DisTubeEvents[K]) => Awaitable;
+};
+/**
+ * The events emitted by a {@link DisTubeVoice} instance.
+ */
+type DisTubeVoiceEvents = {
+    /**
+     * Emitted when the voice connection is disconnected.
+     * @param error - The error that caused the disconnection, when there is one.
+     */
+    disconnect: (error?: Error) => Awaitable;
+    /**
+     * Emitted when an error occurs while playing the audio.
+     * @param error - The error
+     */
+    error: (error: Error) => Awaitable;
+    /**
+     * Emitted when the audio player becomes idle, i.e. the song is finished.
+     */
+    finish: () => Awaitable;
+};
+/**
+ * An FFmpeg audio filter object
+ * ```ts
+ * {
+ *   name:  "bassboost",
+ *   value: "bass=g=10"
+ * }
+ * ```ts
+ */
+interface Filter {
+    /**
+     * Name of the filter
+     */
+    name: string;
+    /**
+     * FFmpeg audio filter argument
+     */
+    value: string;
+}
+/**
+ * Data that resolves to give an FFmpeg audio filter. This can be:
+ * - A name of a default filters or custom filters (`string`)
+ * - A {@link Filter} object
+ * @see {@link defaultFilters}
+ * @see {@link DisTubeOptions|DisTubeOptions.customFilters}
+ */
+type FilterResolvable = string | Filter;
+/**
+ * FFmpeg Filters
+ * ```ts
+ * {
+ *   "Filter Name": "Filter Value",
+ *   "bassboost":   "bass=g=10"
+ * }
+ * ```
+ * @see {@link defaultFilters}
+ */
+type Filters = Record<string, string>;
+/**
+ * DisTube options
+ */
+type DisTubeOptions = {
+    /**
+     * DisTube plugins.
+     * The order of this effects the priority of the plugins when verifying the input.
+     */
+    plugins?: DisTubePlugin[];
+    /**
+     * Whether or not emitting {@link Events.PLAY_SONG} event when looping a song
+     * or next song is the same as the previous one
+     * @default false
+     */
+    emitNewSongOnly?: boolean;
+    /**
+     * Whether or not saving the previous songs of the queue and enable {@link
+     * Queue#previous} method. Disable it may help to reduce the memory usage
+     * @default true
+     */
+    savePreviousSongs?: boolean;
+    /**
+     * Override {@link defaultFilters} or add more ffmpeg filters
+     */
+    customFilters?: Filters;
+    /**
+     * Whether or not playing age-restricted content and disabling safe search in
+     * non-NSFW channel
+     * @default false
+     */
+    nsfw?: boolean;
+    /**
+     * Whether or not emitting `addSong` event when creating a new Queue
+     * @default true
+     */
+    emitAddSongWhenCreatingQueue?: boolean;
+    /**
+     * Whether or not emitting `addList` event when creating a new Queue
+     * @default true
+     */
+    emitAddListWhenCreatingQueue?: boolean;
+    /**
+     * Whether or not joining the new voice channel when using {@link DisTube#play}
+     * method
+     * @default true
+     */
+    joinNewVoiceChannel?: boolean;
+    /**
+     * Behavior when the {@link Events.ERROR} event is emitted but nobody listens to it.
+     *
+     * By default (`"log"`), the error is logged to the console instead of crashing the
+     * process, which is the Node.js default behavior for the special `"error"` event.
+     * @default "log"
+     */
+    unhandledError?: UnhandledErrorBehavior;
+    /**
+     * Time (in milliseconds) a track may stay in the "buffering" state before it is
+     * considered stuck and gets skipped automatically.
+     *
+     * Set to `0` to disable the stuck-track detection.
+     * @default 10000
+     */
+    stuckThreshold?: number;
+    /**
+     * FFmpeg options
+     */
+    ffmpeg?: {
+        /**
+         * FFmpeg path
+         */
+        path?: string;
+        /**
+         * FFmpeg default arguments
+         */
+        args?: Partial<FFmpegArgs>;
+    };
+};
+/**
+ * Data that can be resolved to give a guild id string. This can be:
+ * - A guild id string | a guild {@link https://discord.js.org/#/docs/main/stable/class/Snowflake|Snowflake}
+ * - A {@link https://discord.js.org/#/docs/main/stable/class/Guild | Guild}
+ * - A {@link https://discord.js.org/#/docs/main/stable/class/Message | Message}
+ * - A {@link https://discord.js.org/#/docs/main/stable/class/BaseGuildVoiceChannel
+ *   | BaseGuildVoiceChannel}
+ * - A {@link https://discord.js.org/#/docs/main/stable/class/BaseGuildTextChannel
+ *   | BaseGuildTextChannel}
+ * - A {@link https://discord.js.org/#/docs/main/stable/class/VoiceState |
+ *   VoiceState}
+ * - A {@link https://discord.js.org/#/docs/main/stable/class/GuildMember |
+ *   GuildMember}
+ * - A {@link https://discord.js.org/#/docs/main/stable/class/Interaction |
+ *   Interaction}
+ * - A {@link DisTubeVoice}
+ * - A {@link Queue}
+ */
+type GuildIdResolvable = Queue | DisTubeVoice | Snowflake | Message | GuildTextBasedChannel | VoiceBasedChannel | VoiceState | Guild | GuildMember | Interaction | string;
+/**
+ * The raw information of a song.
+ *
+ * It is the input of the {@link Song} constructor: a plugin builds it from
+ * the data of its source.
+ */
+interface SongInfo<T = unknown> {
+    /**
+     * The plugin that created this song, or `null` when it was created manually.
+     */
+    plugin: DisTubePlugin | null;
+    /**
+     * The identifier of the source of the song, e.g. `youtube`.
+     */
+    source: string;
+    /**
+     * Whether the song can be streamed directly from its source.
+     *
+     * When it is `false`, DisTube looks for a playable version of the song with
+     * the other plugins.
+     */
+    playFromSource: boolean;
+    /**
+     * The identifier of the song in its source.
+     */
+    id: string;
+    /**
+     * The name of the song.
+     */
+    name?: string;
+    /**
+     * Whether the song is a live stream.
+     */
+    isLive?: boolean;
+    /**
+     * The duration of the song, in seconds.
+     */
+    duration?: number;
+    /**
+     * The URL of the song.
+     */
+    url?: string;
+    /**
+     * The URL of the thumbnail of the song.
+     */
+    thumbnail?: string;
+    /**
+     * The number of views of the song.
+     */
+    views?: number;
+    /**
+     * The number of likes of the song.
+     */
+    likes?: number;
+    /**
+     * The number of dislikes of the song.
+     */
+    dislikes?: number;
+    /**
+     * The number of reposts (shares) of the song.
+     */
+    reposts?: number;
+    /**
+     * The uploader (the author, the channel, ...) of the song.
+     */
+    uploader?: {
+        /**
+         * The name of the uploader.
+         */
+        name?: string;
+        /**
+         * The URL of the uploader.
+         */
+        url?: string;
+    };
+    /**
+     * Whether the song is age-restricted.
+     */
+    ageRestricted?: boolean;
+    /**
+     * Source specific metadata of the song.
+     *
+     * It is used by the plugin that created the song to keep the data it needs to
+     * play it (stream url, identifiers, ...). It is ignored when the song is
+     * created with a `metadata` option.
+     */
+    metadata?: T;
+}
+/**
+ * The raw information of a playlist.
+ *
+ * It is the input of the {@link Playlist} constructor: a plugin builds it from
+ * the data of its source.
+ */
+interface PlaylistInfo {
+    /**
+     * The identifier of the source of the playlist, e.g. `youtube`.
+     */
+    source: string;
+    /**
+     * The songs of the playlist.
+     */
+    songs: Song[];
+    /**
+     * The identifier of the playlist in its source.
+     */
+    id?: string;
+    /**
+     * The name of the playlist.
+     */
+    name?: string;
+    /**
+     * The URL of the playlist.
+     */
+    url?: string;
+    /**
+     * The URL of the thumbnail of the playlist.
+     */
+    thumbnail?: string;
+}
+/**
+ * A song that is related to another song.
+ *
+ * It is the same as a {@link Song}, without the `related` property of the
+ * previous versions of DisTube.
+ */
+type RelatedSong = Omit<Song, "related">;
+/**
+ * The options of the handler of a song or a playlist.
+ */
+type PlayHandlerOptions = {
+    /**
+     * [Default: false] Skip the playing song (if exists) and play the added playlist
+     * instantly
+     */
+    skip?: boolean;
+    /**
+     * [Default: 0] Position of the song/playlist to add to the queue, \<= 0 to add to
+     * the end of the queue
+     */
+    position?: number;
+    /**
+     * The default text channel of the queue
+     */
+    textChannel?: GuildTextBasedChannel;
+};
+/**
+ * The options of a jump in the queue.
+ */
+interface JumpOptions {
+    /**
+     * [Default: false] Whether or not skipped song(s) will be added to the end of the
+     * queue
+     */
+    requeue?: boolean;
+}
+/**
+ * The options of {@link DisTube#play}.
+ */
+interface PlayOptions<T = unknown> extends PlayHandlerOptions, ResolveOptions<T> {
+    /**
+     * The message that triggered the command.
+     *
+     * It is used as the default {@link PlayHandlerOptions.textChannel} of the queue
+     * when no `textChannel` is provided.
+     */
+    message?: Message;
+}
+/**
+ * The kind of result a search is looking for.
+ */
+declare enum SearchResultType {
+    /**
+     * A single track, i.e. a song.
+     */
+    TRACK = "track",
+    /**
+     * A video, i.e. a song with a video.
+     */
+    VIDEO = "video",
+    /**
+     * A playlist of songs.
+     */
+    PLAYLIST = "playlist",
+    /**
+     * An album of songs.
+     */
+    ALBUM = "album",
+    /**
+     * The songs of an artist.
+     */
+    ARTIST = "artist"
+}
+/**
+ * The options of the resolution of a song or a playlist.
+ */
+interface ResolveOptions<T = unknown> {
+    /**
+     * Requested user
+     */
+    member?: GuildMember;
+    /**
+     * Metadata
+     */
+    metadata?: T;
+    /**
+     * The source to resolve the input in.
+     *
+     * It matches the {@link Plugin.source} of a plugin, or one of its
+     * {@link Plugin.aliases}. When it is not given, every plugin is used.
+     */
+    source?: string;
+}
+/**
+ * Options of a search.
+ */
+interface SearchOptions<T = unknown> extends ResolveOptions<T> {
+    /**
+     * [Default: 10] Maximum number of results.
+     */
+    limit?: number;
+    /**
+     * The kind of result the caller is looking for.
+     */
+    type?: SearchResultType;
+    /**
+     * Whether or not filtering the explicit content.
+     */
+    safeSearch?: boolean;
+}
+/**
+ * The options of the resolution of a playlist.
+ */
+interface ResolvePlaylistOptions<T = unknown> extends ResolveOptions<T> {
+    /**
+     * Source of the playlist
+     */
+    source?: string;
+}
+/**
+ * The options of a custom playlist.
+ */
+interface CustomPlaylistOptions {
+    /**
+     * A guild member creating the playlist
+     */
+    member?: GuildMember;
+    /**
+     * Whether or not fetch the songs in parallel
+     */
+    parallel?: boolean;
+    /**
+     * Metadata
+     */
+    metadata?: any;
+    /**
+     * Playlist name
+     */
+    name?: string;
+    /**
+     * Playlist source
+     */
+    source?: string;
+    /**
+     * Playlist url
+     */
+    url?: string;
+    /**
+     * Playlist thumbnail
+     */
+    thumbnail?: string;
+}
+/**
+ * The repeat mode of a {@link Queue}
+ */
+declare enum RepeatMode {
+    /**
+     * The queue plays every song once. `0`.
+     */
+    DISABLED = 0,
+    /**
+     * The queue repeats the current song. `1`.
+     */
+    SONG = 1,
+    /**
+     * The queue repeats the whole queue. `2`.
+     */
+    QUEUE = 2
+}
+/**
+ * All available plugin types:
+ */
+declare enum PluginType {
+    /**
+     * A plugin that extracts, searches and plays the songs of its source.
+     * `"extractor"`: {@link ExtractorPlugin}
+     */
+    EXTRACTOR = "extractor",
+    /**
+     * A plugin that only extracts the info of the links of its source.
+     * `"info-extractor"`: {@link InfoExtractorPlugin}
+     */
+    INFO_EXTRACTOR = "info-extractor",
+    /**
+     * A plugin that extracts and plays the songs of its source, but cannot
+     * search for them. `"playable-extractor"`: {@link PlayableExtractorPlugin}
+     */
+    PLAYABLE_EXTRACTOR = "playable-extractor"
+}
+/**
+ * Every kind of plugin DisTube can use.
+ *
+ * - {@link ExtractorPlugin}
+ * - {@link InfoExtractorPlugin}
+ * - {@link PlayableExtractorPlugin}
+ */
+type DisTubePlugin = ExtractorPlugin | InfoExtractorPlugin | PlayableExtractorPlugin;
+/**
+ * A FFmpeg argument.
+ *
+ * The value is the argument itself (`"-1"`), or an array of the values of a
+ * repeatable argument (`["-1", "-2"]`).
+ */
+type FFmpegArg = Record<string, string | number | boolean | Array<string | null | undefined> | null | undefined>;
+/**
+ * FFmpeg arguments for different use cases
+ */
+type FFmpegArgs = {
+    /**
+     * The arguments that are applied to the FFmpeg process itself.
+     */
+    global: FFmpegArg;
+    /**
+     * The arguments that are applied to the input of the FFmpeg process.
+     */
+    input: FFmpegArg;
+    /**
+     * The arguments that are applied to the output of the FFmpeg process.
+     *
+     * The `af` argument is replaced by the filters of the {@link Queue}.
+     */
+    output: FFmpegArg;
+};
+/**
+ * FFmpeg options
+ */
+type FFmpegOptions = {
+    /**
+     * Path to the ffmpeg executable
+     * @default "ffmpeg"
+     */
+    path: string;
+    /**
+     * Arguments
+     */
+    args: FFmpegArgs;
+};
+
+/**
+ * The version of DisTube.
+ *
+ * The placeholder is replaced by the real version at build time.
+ */
+declare const version: string;
+/**
+ * The sample rate of the audio, in Hz.
+ */
+declare const AUDIO_SAMPLE_RATE = 48000;
+/**
+ * The number of channels of the audio.
+ */
+declare const AUDIO_CHANNELS = 2;
+/**
+ * Default volume percentage (0-100)
+ */
+declare const DEFAULT_VOLUME = 50;
+/**
+ * The timeout to join a voice channel, in milliseconds.
+ */
+declare const JOIN_TIMEOUT_MS = 30000;
+/**
+ * The delay between two reconnection attempts, in milliseconds.
+ */
+declare const RECONNECT_TIMEOUT_MS = 5000;
+/**
+ * The maximum number of reconnection attempts before giving up.
+ */
+declare const RECONNECT_MAX_ATTEMPTS = 5;
+/**
+ * Default time (in milliseconds) a track may stay in the "buffering" state
+ * before it is considered stuck and gets skipped.
+ */
+declare const STUCK_THRESHOLD_MS = 10000;
+/**
+ * The HTTP status codes that are followed as a redirection.
+ */
+declare const HTTP_REDIRECT_CODES: Set<number>;
+/**
+ * The maximum number of redirections that are followed before giving up.
+ */
+declare const MAX_REDIRECT_DEPTH = 5;
+/**
+ * Default DisTube audio filters.
+ */
+declare const defaultFilters: Filters;
+/**
+ * The default options of a {@link DisTube} instance.
+ *
+ * They are overridden by the options given to the constructor of
+ * {@link DisTube}.
+ */
+declare const defaultOptions: {
+    plugins: never[];
+    emitNewSongOnly: false;
+    savePreviousSongs: true;
+    nsfw: false;
+    emitAddSongWhenCreatingQueue: true;
+    emitAddListWhenCreatingQueue: true;
+    joinNewVoiceChannel: true;
+    unhandledError: "log";
+    stuckThreshold: number;
+};
+
+/**
+ * Class representing a song.
+ */
+declare class Song<T = unknown> {
+    #private;
+    /**
+     * The source of this song info
+     */
+    source: string;
+    /**
+     * Song ID.
+     */
+    id: string;
+    /**
+     * Song name.
+     */
+    name?: string;
+    /**
+     * Indicates if the song is an active live.
+     */
+    isLive?: boolean;
+    /**
+     * Song duration.
+     */
+    duration: number;
+    /**
+     * Formatted duration string (`hh:mm:ss`, `mm:ss` or `Live`).
+     */
+    formattedDuration: string;
+    /**
+     * Song URL.
+     */
+    url?: string;
+    /**
+     * Song thumbnail.
+     */
+    thumbnail?: string;
+    /**
+     * Song view count
+     */
+    views?: number;
+    /**
+     * Song like count
+     */
+    likes?: number;
+    /**
+     * Song dislike count
+     */
+    dislikes?: number;
+    /**
+     * Song repost (share) count
+     */
+    reposts?: number;
+    /**
+     * Song uploader
+     */
+    uploader: {
+        /**
+         * The name of the uploader.
+         */
+        name?: string;
+        /**
+         * The URL of the uploader.
+         */
+        url?: string;
+    };
+    /**
+     * Whether or not an age-restricted content
+     */
+    ageRestricted?: boolean;
+    /**
+     * Stream info
+     */
+    stream: {
+        /**
+         * The stream of this song will be played from source
+         */
+        playFromSource: true;
+        /**
+         * Stream URL of this song
+         */
+        url?: string;
+    } | {
+        /**
+         * The stream of this song will be played from another song
+         */
+        playFromSource: false;
+        /**
+         * The song that this song will be played from
+         */
+        song?: Song<T>;
+    };
+    /**
+     * The plugin that created this song
+     */
+    plugin: DisTubePlugin | null;
+    /**
+     * Create a Song
+     *
+     * @param info      - Raw song info
+     * @param options   - Optional data
+     * @param options.member   - The user that requested the song
+     * @param options.metadata - The metadata of the song
+     */
+    constructor(info: SongInfo<T>, { member, metadata }?: ResolveOptions<T>);
+    /**
+     * The playlist this song belongs to
+     */
+    get playlist(): Playlist | undefined;
+    /**
+     * Set the playlist this song belongs to.
+     * @param playlist - The playlist
+     * @throws {@link DisTubeError} When the value is not a {@link Playlist}
+     */
+    set playlist(playlist: Playlist | undefined);
+    /**
+     * User requested to play this song.
+     */
+    get member(): GuildMember | undefined;
+    /**
+     * Set the user that requested this song.
+     *
+     * The value is ignored when it is not a valid guild member.
+     * @param member - The member
+     */
+    set member(member: GuildMember | undefined);
+    /**
+     * User requested to play this song.
+     */
+    get user(): discord_js.User | undefined;
+    /**
+     * Optional metadata that can be used to identify the song. This is attached by the
+     * {@link DisTube#play} method.
+     */
+    get metadata(): T;
+    /**
+     * Set the metadata of the song.
+     * @param metadata - The metadata
+     */
+    set metadata(metadata: T);
+    /**
+     * The name of the song, or its url, or its id.
+     * @returns The string representation of the song
+     */
+    toString(): string;
+}
+
+/**
+ * Class representing a playlist.
+ */
+declare class Playlist<T = unknown> implements PlaylistInfo {
+    #private;
+    /**
+     * Playlist source.
+     */
+    source: string;
+    /**
+     * Songs in the playlist.
+     */
+    songs: Song[];
+    /**
+     * Playlist ID.
+     */
+    id?: string;
+    /**
+     * Playlist name.
+     */
+    name?: string;
+    /**
+     * Playlist URL.
+     */
+    url?: string;
+    /**
+     * Playlist thumbnail.
+     */
+    thumbnail?: string;
+    /**
+     * Create a Playlist
+     * @param playlist  - Raw playlist info
+     * @param options   - Optional data
+     * @param options.member   - The user that requested the playlist
+     * @param options.metadata - The metadata of the playlist
+     * @throws {@link DisTubeError} When the playlist does not have any song
+     */
+    constructor(playlist: PlaylistInfo, { member, metadata }?: ResolveOptions<T>);
+    /**
+     * Playlist duration in second.
+     */
+    get duration(): number;
+    /**
+     * Formatted duration string `hh:mm:ss`.
+     */
+    get formattedDuration(): string;
+    /**
+     * User requested.
+     */
+    get member(): GuildMember | undefined;
+    /**
+     * Set the user that requested the playlist.
+     *
+     * The value is ignored when it is not a valid guild member.
+     * @param member - The member
+     */
+    set member(member: GuildMember | undefined);
+    /**
+     * User requested.
+     */
+    get user(): discord_js.User | undefined;
+    /**
+     * Optional metadata that can be used to identify the playlist.
+     */
+    get metadata(): T;
+    /**
+     * Set the metadata of the playlist.
+     *
+     * The metadata of the songs is not changed when the metadata is `undefined`.
+     * @param metadata - The metadata
+     */
+    set metadata(metadata: T);
+    /**
+     * The name of the playlist and the number of its songs.
+     * @returns The string representation of the playlist
+     */
+    toString(): string;
+}
+
+/**
+ * DisTube's Handler
+ */
+declare class DisTubeHandler extends DisTubeBase {
+    #private;
+    /**
+     * Resolve a {@link Song} to a {@link Song}.
+     * @param song    - The song to resolve
+     * @param options - Optional options
+     * @returns The resolved song
+     */
+    resolve<T = unknown>(song: Song<T>, options?: Omit<ResolveOptions, "metadata">): Promise<Song<T>>;
+    /**
+     * Resolve a {@link Playlist} to a {@link Playlist}.
+     * @param song    - The playlist to resolve
+     * @param options - Optional options
+     * @returns The resolved playlist
+     */
+    resolve<T = unknown>(song: Playlist<T>, options?: Omit<ResolveOptions, "metadata">): Promise<Playlist<T>>;
+    /**
+     * Resolve a url or a search query to a {@link Song} or a {@link Playlist}.
+     * @param song    - The url or the search query to resolve
+     * @param options - Optional options
+     * @returns The resolved song or playlist
+     */
+    resolve<T = unknown>(song: string, options?: ResolveOptions<T>): Promise<Song<T> | Playlist<T>>;
+    /**
+     * Resolve a {@link Song} to a {@link Song}.
+     * @param song    - The song to resolve
+     * @param options - Optional options
+     * @returns The resolved song
+     */
+    resolve<T = unknown>(song: Song, options: ResolveOptions<T>): Promise<Song<T>>;
+    /**
+     * Resolve a {@link Playlist} to a {@link Playlist}.
+     * @param song    - The playlist to resolve
+     * @param options - Optional options
+     * @returns The resolved playlist
+     */
+    resolve<T = unknown>(song: Playlist, options: ResolveOptions<T>): Promise<Playlist<T>>;
+    /**
+     * Resolve a url or a supported object to a {@link Song} or {@link Playlist}
+     * @throws {@link DisTubeError}
+     * @param song    - Resolvable input
+     * @param options - Optional options
+     * @returns Resolved
+     * @example
+     * ```ts
+     * const song = await distube.handler.resolve("Never gonna give you up");
+     * ```
+     */
+    resolve(song: string | Song | Playlist, options?: ResolveOptions): Promise<Song | Playlist>;
+    /**
+     * Find the plugin that supports the given url.
+     * @param url - The url to check
+     * @returns The plugin, or `null` when there is none
+     */
+    _getPluginFromURL(url: string): Promise<DisTubePlugin | null>;
+    /**
+     * Find the plugin that can handle the given song.
+     * @param song - The song
+     * @returns The plugin, or `null` when there is none
+     */
+    _getPluginFromSong(song: Song): Promise<DisTubePlugin | null>;
+    /**
+     * Find the plugin of the given type that can handle the given song.
+     * @param song     - The song
+     * @param types    - The types of the plugin to look for
+     * @param validate - Whether the url of the song has to be validated
+     * @returns The plugin, or `null` when there is none
+     */
+    _getPluginFromSong<T extends PluginType>(song: Song, types: T[], validate?: boolean): Promise<(DisTubePlugin & {
+        type: T;
+    }) | null>;
+    /**
+     * Get {@link Song}'s stream info and attach it to the song.
+     * @param song - A Song
+     * @returns A promise that resolves when the stream info is attached
+     * @throws {@link DisTubeError} When no plugin supports the song, or when its
+     * stream URL cannot be found
+     */
+    attachStreamInfo(song: Song): Promise<void>;
+    /**
+     * Follow the redirections of an url.
+     * @param url        - The url to follow
+     * @param maxRedirect - The maximum number of redirections to follow
+     * @returns The final url
+     */
+    followRedirectLink(url: string, maxRedirect?: number): Promise<string>;
+}
+
+/**
+ * The validated options of a {@link DisTube} instance.
+ *
+ * Every option has a default value, and every option is validated when the
+ * instance is created.
+ */
+declare class Options {
+    #private;
+    /**
+     * The plugins of the DisTube instance.
+     */
+    plugins: DisTubePlugin[];
+    /**
+     * Whether or not the {@link Events.PLAY_SONG} event is emitted when looping a
+     * song or when the next song is the same as the previous one.
+     * @default false
+     */
+    emitNewSongOnly: boolean;
+    /**
+     * Whether or not the previous songs of a {@link Queue} are saved.
+     * @default true
+     */
+    savePreviousSongs: boolean;
+    /**
+     * The custom FFmpeg audio filters, that override the {@link defaultFilters}.
+     */
+    customFilters?: Filters;
+    /**
+     * Whether or not age-restricted content can be played in a non-NSFW channel.
+     * @default false
+     */
+    nsfw: boolean;
+    /**
+     * Whether or not the {@link Events.ADD_SONG} event is emitted when a new
+     * {@link Queue} is created.
+     * @default true
+     */
+    emitAddSongWhenCreatingQueue: boolean;
+    /**
+     * Whether or not the {@link Events.ADD_LIST} event is emitted when a new
+     * {@link Queue} is created.
+     * @default true
+     */
+    emitAddListWhenCreatingQueue: boolean;
+    /**
+     * Whether or not the bot joins the new voice channel when
+     * {@link DisTube#play} is used.
+     * @default true
+     */
+    joinNewVoiceChannel: boolean;
+    /**
+     * The behavior of the {@link Events.ERROR} event when it has no listener.
+     * @default "log"
+     */
+    unhandledError: UnhandledErrorBehavior;
+    /**
+     * The time (in milliseconds) a track may stay in the "buffering" state before
+     * it is considered stuck and gets skipped.
+     *
+     * Set to `0` to disable the stuck-track detection.
+     * @default 10000
+     */
+    stuckThreshold: number;
+    /**
+     * The FFmpeg options of the DisTube instance.
+     */
+    ffmpeg: FFmpegOptions;
+    /**
+     * Create the options of a {@link DisTube} instance.
+     * @param options - The options given by the user
+     * @throws {@link DisTubeError} When an option has an invalid type, or when it
+     * is not a known option
+     */
+    constructor(options: DisTubeOptions);
+}
+
+/**
+ * Options for {@link DisTubeStream}
+ */
+interface StreamOptions {
+    /**
+     * FFmpeg options
+     */
+    ffmpeg: FFmpegOptions;
+    /**
+     * Seek time (in seconds).
+     * @default 0
+     */
+    seek?: number;
+}
+/**
+ * Check that FFmpeg is installed and can be spawned.
+ *
+ * The check is only done once: the result is cached.
+ * @param distube - The DisTube instance
+ * @returns Nothing
+ * @throws {@link DisTubeError} When FFmpeg cannot be spawned
+ */
+declare const checkFFmpeg: (distube: DisTube) => void;
+/**
+ * Create a stream to play with {@link DisTubeVoice}
+ */
+declare class DisTubeStream extends TypedEmitter<{
+    debug: (debug: string) => Awaitable;
+    error: (error: Error) => Awaitable;
+}> {
+    #private;
+    /**
+     * The FFmpeg process that decodes the audio.
+     *
+     * It is `undefined` until {@link DisTubeStream#spawn} is called.
+     */
+    process?: ChildProcess;
+    /**
+     * The stream of the decoded audio, with the volume applied to it.
+     */
+    stream: VolumeTransformer;
+    /**
+     * The Discord.js audio resource that is played by the audio player.
+     */
+    audioResource: AudioResource;
+    /**
+     * The seek time in seconds that this stream started from
+     */
+    readonly seekTime: number;
+    /**
+     * Create a DisTubeStream to play with {@link DisTubeVoice}
+     * @param url     - Stream URL
+     * @param options - Stream options
+     */
+    constructor(url: string, options: StreamOptions);
+    /**
+     * Spawn the FFmpeg process that decodes the audio.
+     * @returns Nothing
+     * @throws {Error} When the FFmpeg process cannot be created
+     */
+    spawn(): void;
+    private debug;
+    /**
+     * Set the volume of the stream.
+     * @param volume - The volume of the stream, between `0` and `1`
+     * @returns Nothing
+     */
+    setVolume(volume: number): void;
+    /**
+     * Kill the FFmpeg process and destroy the stream.
+     * @returns Nothing
+     */
+    kill(): void;
+}
+declare class VolumeTransformer extends Transform {
+    private buffer;
+    private readonly extrema;
+    vol: number;
+    _transform(newChunk: Buffer, _encoding: BufferEncoding, done: TransformCallback): void;
+}
+
+/**
+ * Create a voice connection to the voice channel
+ */
+declare class DisTubeVoice extends TypedEmitter<DisTubeVoiceEvents> {
+    #private;
+    /**
+     * The id of the guild of this voice connection.
+     */
+    readonly id: Snowflake;
+    /**
+     * The voice manager that instantiated this connection.
+     */
+    readonly voices: DisTubeVoiceManager;
+    /**
+     * The audio player that plays the audio of this connection.
+     */
+    readonly audioPlayer: AudioPlayer;
+    /**
+     * The Discord.js voice connection.
+     */
+    connection: VoiceConnection;
+    /**
+     * Whether or not an error was already emitted for the current stream.
+     *
+     * It prevents the same error from being emitted several times.
+     */
+    emittedError: boolean;
+    /**
+     * Whether or not the voice connection has been disconnected.
+     */
+    isDisconnected: boolean;
+    /**
+     * The stream that is currently playing.
+     */
+    stream?: DisTubeStream;
+    /**
+     * The stream that was playing when the playback was paused.
+     */
+    pausingStream?: DisTubeStream;
+    /**
+     * Create a voice connection to the voice channel.
+     * @param voiceManager - The voice manager of the DisTube instance
+     * @param channel      - The voice channel to join
+     */
+    constructor(voiceManager: DisTubeVoiceManager, channel: VoiceBasedChannel);
+    /**
+     * The voice channel id the bot is in
+     */
+    get channelId(): string | undefined;
+    /**
+     * The voice channel the bot is in.
+     *
+     * Setting it moves the bot to another voice channel.
+     */
+    get channel(): VoiceBasedChannel;
+    /**
+     * Move the bot to another voice channel.
+     * @param channel - The voice channel to join
+     * @throws {@link DisTubeError} When the channel is invalid, when it belongs to
+     * another guild or client, or when the bot cannot join it
+     */
+    set channel(channel: VoiceBasedChannel);
+    /**
+     * Join a voice channel with this connection
+     * @param channel - A voice channel
+     * @returns The voice connection
+     * @throws {@link DisTubeError} When the connection cannot be established
+     */
+    join(channel?: VoiceBasedChannel): Promise<DisTubeVoice>;
+    /**
+     * Leave the voice channel of this connection
+     * @param error - Optional, an error to emit with 'error' event.
+     * @returns Nothing
+     */
+    leave(error?: Error): void;
+    /**
+     * Stop the playing stream
+     * @param force - If true, will force the {@link DisTubeVoice#audioPlayer} to enter the Idle state even
+     *                if the {@link DisTubeStream#audioResource} has silence padding frames.
+     * @returns Nothing
+     */
+    stop(force?: boolean): void;
+    /**
+     * Play a {@link DisTubeStream}
+     * @param dtStream - DisTubeStream
+     * @returns A promise that resolves when the stream is playing
+     * @throws {@link DisTubeError} When no encryption library is available
+     */
+    play(dtStream: DisTubeStream): Promise<void>;
+    /**
+     * Set the volume percentage of the stream.
+     * @param volume - The volume percentage, from `0` to `100`
+     * @throws {@link DisTubeError} When the volume is not a number, or when it is
+     * negative
+     */
+    set volume(volume: number);
+    /**
+     * Get or set the volume percentage
+     */
+    get volume(): number;
+    /**
+     * Playback duration of the audio resource in seconds (time since playback started)
+     */
+    get playbackDuration(): number;
+    /**
+     * Current playback time in seconds, accounting for seek offset
+     */
+    get playbackTime(): number;
+    /**
+     * Pause the playback of the audio player.
+     * @returns Nothing
+     */
+    pause(): void;
+    /**
+     * Resume the playback of the audio player.
+     *
+     * The FFmpeg process is spawned again when the stream was killed while the
+     * playback was paused.
+     * @returns Nothing
+     */
+    unpause(): void;
+    /**
+     * Emit an event of the voice connection.
+     *
+     * The special `"error"` event never crashes the process when there is no
+     * listener for it, even when the voice connection is used outside of a
+     * {@link Queue}.
+     * @param event - The event name
+     * @param args  - The event arguments
+     * @returns `true` when the event had listeners, `false` otherwise
+     */
+    emit<U extends keyof DisTubeVoiceEvents>(event: U, ...args: Parameters<DisTubeVoiceEvents[U]>): boolean;
+    /**
+     * Whether the bot is self-deafened
+     */
+    get selfDeaf(): boolean;
+    /**
+     * Whether the bot is self-muted
+     */
+    get selfMute(): boolean;
+    /**
+     * Self-deafens/undeafens the bot.
+     * @param selfDeaf - Whether or not the bot should be self-deafened
+     * @returns true if the voice state was successfully updated, otherwise false
+     * @throws {@link DisTubeError} When the value is not a boolean
+     */
+    setSelfDeaf(selfDeaf: boolean): boolean;
+    /**
+     * Self-mutes/unmutes the bot.
+     * @param selfMute - Whether or not the bot should be self-muted
+     * @returns true if the voice state was successfully updated, otherwise false
+     * @throws {@link DisTubeError} When the value is not a boolean
+     */
+    setSelfMute(selfMute: boolean): boolean;
+    /**
+     * The voice state of this connection
+     */
+    get voiceState(): VoiceState | undefined;
+}
+
+/**
+ * Manages the collection of a data model.
+ */
+declare abstract class BaseManager<V> extends DisTubeBase {
+    /**
+     * The collection of items for this manager.
+     */
+    collection: Collection<string, V>;
+    /**
+     * The size of the collection.
+     */
+    get size(): number;
+}
+
+/**
+ * Manages the collection of a data model paired with a guild id.
+ */
+declare abstract class GuildIdManager<V> extends BaseManager<V> {
+    /**
+     * Add an item to the collection.
+     *
+     * The item is not added when there is already one for the same guild.
+     * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+     * @param data         - The item to add
+     * @returns This manager, to allow chaining
+     * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+     */
+    add(idOrInstance: GuildIdResolvable, data: V): this;
+    /**
+     * Get the item of a guild.
+     * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+     * @returns The item of the guild, or `undefined` when there is none
+     * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+     */
+    get(idOrInstance: GuildIdResolvable): V | undefined;
+    /**
+     * Remove the item of a guild.
+     * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+     * @returns `true` when an item was removed, `false` otherwise
+     * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+     */
+    remove(idOrInstance: GuildIdResolvable): boolean;
+    /**
+     * Check whether a guild has an item.
+     * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+     * @returns `true` when there is an item for the guild
+     * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+     */
+    has(idOrInstance: GuildIdResolvable): boolean;
+}
+
+/**
+ * Manages voice connections
+ */
+declare class DisTubeVoiceManager extends GuildIdManager<DisTubeVoice> {
+    /**
+     * Create a {@link DisTubeVoice} instance
+     * @param channel - A voice channel to join
+     * @returns The voice connection of the guild
+     * @throws {@link DisTubeError} When the guild already has a voice connection
+     * that is not managed by DisTube
+     */
+    create(channel: VoiceBasedChannel): DisTubeVoice;
+    /**
+     * Join a voice channel and wait until the connection is ready
+     * @param channel - A voice channel to join
+     * @returns The voice connection of the guild
+     * @throws {@link DisTubeError} When the connection cannot be established
+     */
+    join(channel: VoiceBasedChannel): Promise<DisTubeVoice>;
+    /**
+     * Leave the connected voice channel in a guild
+     * @param guild - Queue Resolvable
+     * @returns Nothing
+     */
+    leave(guild: GuildIdResolvable): void;
+}
+
+/**
+ * Queue manager
+ */
+declare class QueueManager extends GuildIdManager<Queue> {
+    #private;
+    /**
+     * Create a {@link Queue}
+     * @param channel     - A voice channel
+     * @param textChannel - Default text channel
+     * @returns The created queue
+     * @throws {@link DisTubeError} When the guild already has a queue, or when
+     * the voice channel cannot be joined
+     */
+    create(channel: VoiceBasedChannel, textChannel?: GuildTextBasedChannel): Promise<Queue>;
+    /**
+     * Handle the queue when a Song finish
+     * @param queue - queue
+     * @returns A promise that resolves when the next song is playing
+     */
+    handleSongFinish(queue: Queue): Promise<void>;
+    /**
+     * Play a song on voice connection with queue properties
+     * @param queue         - The guild queue to play
+     * @param emitPlaySong  - Whether or not emit {@link Events.PLAY_SONG} event
+     * @param options       - Optional options
+     * @param options.keepSongOnError - Whether the current song has to stay in the
+     * queue when the stream cannot be started
+     * @returns A promise that resolves when the song is playing
+     * @throws {@link DisTubeError} When the song does not have any stream URL
+     */
+    playSong(queue: Queue, emitPlaySong?: boolean, options?: {
+        keepSongOnError?: boolean;
+    }): Promise<void>;
+}
+
+/**
+ * A request of the stream server.
+ */
+interface StreamRequest {
+    /**
+     * The path after the source, e.g. `v/abc123`.
+     */
+    path: string;
+    /**
+     * The parsed query parameters.
+     */
+    query: URLSearchParams;
+    /**
+     * The byte offset the client asked for, or `0`.
+     */
+    offset: number;
+    /**
+     * Aborted when the client disconnects.
+     */
+    signal: AbortSignal;
+    /**
+     * The raw request.
+     */
+    request: IncomingMessage;
+}
+/**
+ * The response of a stream handler.
+ */
+interface StreamResponse {
+    /**
+     * The audio bytes.
+     */
+    body: Readable | AsyncIterable<Uint8Array>;
+    /**
+     * The content type. Default: `application/octet-stream`.
+     */
+    contentType?: string;
+    /**
+     * The status code. Default: `200`.
+     */
+    status?: number;
+    /**
+     * The total size of the stream, when it is known.
+     *
+     * It is required to answer the range requests.
+     */
+    size?: number;
+    /**
+     * Extra headers.
+     */
+    headers?: Record<string, string | number>;
+}
+/**
+ * The handler of a source.
+ */
+type StreamHandler = (req: StreamRequest) => Promise<StreamResponse | null | undefined> | StreamResponse | null | undefined;
+/**
+ * A handle to release a resource.
+ */
+interface Disposable {
+    /**
+     * Release the resource.
+     * @returns Nothing
+     */
+    dispose(): void;
+}
+/**
+ * Options of the stream server.
+ */
+interface StreamServerOptions {
+    /**
+     * The port of the server. `0` (the default) lets the operating system pick a
+     * free one, which is what a plugin should use: a fixed port makes the next
+     * instance fail with `EADDRINUSE`.
+     */
+    port?: number;
+    /**
+     * The prefix of the URLs. A random one is generated by default, so the other
+     * local processes cannot guess them.
+     */
+    prefix?: string;
+}
+/**
+ * A local HTTP server that the plugins use to stream the audio.
+ *
+ * Every plugin that cannot hand out a static URL to FFmpeg needs an HTTP
+ * server: a source that has to be decrypted, captured or negotiated cannot be
+ * fetched by FFmpeg directly. Instead of every plugin running its own server,
+ * they register a handler on this one.
+ *
+ * The server is started on the first registration and it is closed by
+ * {@link DisTube#destroy}.
+ */
+declare class StreamServer {
+    #private;
+    /**
+     * Create a stream server.
+     * @param options - Optional options
+     */
+    constructor({ port, prefix }?: StreamServerOptions);
+    /**
+     * The prefix of the URLs of the server.
+     */
+    get prefix(): string;
+    /**
+     * The base URL of the server, e.g. `http://127.0.0.1:51234`.
+     *
+     * @throws When the server is not started yet.
+     */
+    get baseUrl(): string;
+    /**
+     * Register a source.
+     *
+     * The handler is called for every request of that source. Return `null` to
+     * answer a `404`.
+     * @param source  - The identifier of the source
+     * @param handler - The handler of the source
+     * @returns A handle to unregister the source
+     * @example
+     * ```ts
+     * const disposable = distube.streams.register("my-source", async req => ({
+     *   body: Readable.from(Buffer.from("audio")),
+     *   contentType: "audio/mpeg",
+     * }));
+     * ```
+     */
+    register(source: string, handler: StreamHandler): Disposable;
+    /**
+     * Build the URL of a stream.
+     *
+     * The server is started when it is not running yet.
+     * @param source - The identifier of the source
+     * @param path   - The path after the source
+     * @param query  - The query parameters
+     * @returns The URL of the stream
+     * @example
+     * ```ts
+     * const url = await distube.streams.url("my-source", "abc123", { token: "secret" });
+     * ```
+     */
+    url(source: string, path?: string, query?: Record<string, string | number | boolean>): Promise<string>;
+    /**
+     * Close the server and release every handler.
+     * @returns A promise that resolves when the server is closed
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * The table of the error messages of DisTube.
+ *
+ * Every entry is the message of one error code. A message can be a template
+ * that receives the arguments of the error.
+ */
+declare const ERROR_MESSAGES: {
+    /**
+     * A value does not have the expected type.
+     *
+     * It is raised when an argument of a public method is not of the type that
+     * the method expects, e.g. when a voice channel is not a voice channel.
+     */
+    INVALID_TYPE: (expected: (number | string) | readonly (number | string)[], got: any, name?: string) => string;
+    /**
+     * A number is not in the expected range.
+     *
+     * It is raised when a numeric argument is out of the range that the method
+     * accepts, e.g. a negative volume.
+     */
+    NUMBER_COMPARE: (name: string, expected: string, value: number) => string;
+    /**
+     * An array is empty.
+     *
+     * It is raised when an argument that must hold at least one element is
+     * empty, e.g. the songs of a custom playlist.
+     */
+    EMPTY_ARRAY: (name: string) => string;
+    /**
+     * An array does not have any valid element.
+     *
+     * It is raised when every element of an array was filtered out, e.g. when
+     * all the songs of an array are invalid.
+     */
+    EMPTY_FILTERED_ARRAY: (name: string, type: string) => string;
+    /**
+     * A string is empty.
+     *
+     * It is raised when a string argument that must not be empty is empty.
+     */
+    EMPTY_STRING: (name: string) => string;
+    /**
+     * An object has a key that is not allowed.
+     *
+     * It is raised when an options object has a key that DisTube does not know,
+     * e.g. `{ emitNewSong: true }` instead of `{ emitNewSongOnly: true }`.
+     */
+    INVALID_KEY: (obj: string, key: string) => string;
+    /**
+     * A required key is missing.
+     *
+     * It is raised when an object does not have a key that DisTube needs.
+     */
+    MISSING_KEY: (obj: string, key: string) => string;
+    /**
+     * Several required keys are missing.
+     *
+     * It is raised when an object does not have the keys that DisTube needs.
+     */
+    MISSING_KEYS: (obj: string, key: string[], all: boolean) => string;
+    /**
+     * The Discord.js client does not have the required intents.
+     *
+     * It is raised when the `GuildVoiceStates` intent is missing: DisTube
+     * cannot work without it.
+     */
+    MISSING_INTENTS: (i: string) => string;
+    /**
+     * A DisTube option that is needed is disabled.
+     *
+     * It is raised when a feature cannot work because one of its options is
+     * disabled, e.g. {@link Queue#previous} when
+     * {@link DisTubeOptions.savePreviousSongs} is `false`.
+     */
+    DISABLED_OPTION: (o: string) => string;
+    /**
+     * A DisTube option that must be disabled is enabled.
+     *
+     * It is raised when a feature cannot work because one of its options is
+     * enabled.
+     */
+    ENABLED_OPTION: (o: string) => string;
+    /**
+     * The user is not in any voice channel.
+     *
+     * It is raised when a command needs the voice channel of the user, but the
+     * user is not connected to any voice channel.
+     */
+    NOT_IN_VOICE: string;
+    /**
+     * The voice channel is full.
+     *
+     * It is raised when the bot cannot join a voice channel because it is
+     * full.
+     */
+    VOICE_FULL: string;
+    /**
+     * The guild already has a voice connection that DisTube does not manage.
+     *
+     * It is raised when DisTube cannot create a voice connection because
+     * another one already exists in the guild.
+     */
+    VOICE_ALREADY_CREATED: string;
+    /**
+     * The voice connection could not be established in time.
+     *
+     * It is raised when the connection did not become ready before
+     * {@link JOIN_TIMEOUT_MS}.
+     */
+    VOICE_CONNECT_FAILED: (s: number) => string;
+    /**
+     * The bot does not have the permission to join the voice channel.
+     *
+     * It is raised when the bot cannot join a voice channel because of a missing
+     * permission.
+     */
+    VOICE_MISSING_PERMS: string;
+    /**
+     * The voice connection could not be restored.
+     *
+     * It is raised when every reconnection attempt of
+     * {@link RECONNECT_MAX_ATTEMPTS} failed.
+     */
+    VOICE_RECONNECT_FAILED: string;
+    /**
+     * The voice channel belongs to another guild.
+     *
+     * It is raised when a voice connection is asked to join a voice channel of
+     * another guild.
+     */
+    VOICE_DIFFERENT_GUILD: string;
+    /**
+     * The voice channel belongs to another client.
+     *
+     * It is raised when a voice connection is asked to join a voice channel
+     * that was created by another Discord.js client.
+     */
+    VOICE_DIFFERENT_CLIENT: string;
+    /**
+     * The FFmpeg process exited with an unexpected code.
+     *
+     * It is raised when the FFmpeg process that decodes the audio exits with a
+     * code that is neither `0` nor `255`.
+     */
+    FFMPEG_EXITED: (code: number) => string;
+    /**
+     * FFmpeg is not installed at the given path.
+     *
+     * It is raised when the FFmpeg executable cannot be spawned, e.g. when
+     * {@link DisTubeOptions.ffmpeg} points to a path that does not exist.
+     */
+    FFMPEG_NOT_INSTALLED: (path: string) => string;
+    /**
+     * No encryption library is available.
+     *
+     * It is raised when Discord cannot decrypt the audio: neither the
+     * `aes-256-gcm` cipher of Node.js nor one of the supported third-party
+     * encryption libraries is available.
+     */
+    ENCRYPTION_LIBRARIES_MISSING: string;
+    /**
+     * The guild does not have a playing queue.
+     *
+     * It is raised when a queue operation is used in a guild that has no
+     * {@link Queue}.
+     */
+    NO_QUEUE: string;
+    /**
+     * The guild already has a queue.
+     *
+     * It is raised when a {@link Queue} is created for a guild that already
+     * has one.
+     */
+    QUEUE_EXIST: string;
+    /**
+     * The queue has been stopped already.
+     *
+     * It is raised when an operation needs a running queue, but the queue was
+     * stopped.
+     */
+    QUEUE_STOPPED: string;
+    /**
+     * The queue is already paused.
+     *
+     * It is raised when {@link Queue#pause} is used on a paused queue.
+     */
+    PAUSED: string;
+    /**
+     * The queue is already playing.
+     *
+     * It is raised when {@link Queue#resume} is used on a queue that is not
+     * paused.
+     */
+    RESUMED: string;
+    /**
+     * The queue does not have any previous song.
+     *
+     * It is raised when {@link Queue#previous} is used on a queue without any
+     * history.
+     */
+    NO_PREVIOUS: string;
+    /**
+     * The queue does not have any up next song.
+     *
+     * It is raised when a jump goes past the end of the queue while the
+     * autoplay mode is disabled.
+     */
+    NO_UP_NEXT: string;
+    /**
+     * The queue does not have any song at the given position.
+     *
+     * It is raised when {@link Queue#jump} is used with a position that is out
+     * of the bounds of the queue.
+     */
+    NO_SONG_POSITION: string;
+    /**
+     * The queue does not have any playing song.
+     *
+     * It is raised when a related song is requested but the queue is empty.
+     */
+    NO_PLAYING_SONG: string;
+    /**
+     * The track is stuck and does not produce any audio.
+     *
+     * It is raised when a track stays in the "buffering" state for longer than
+     * {@link DisTubeOptions.stuckThreshold} milliseconds. The queue skips it.
+     */
+    TRACK_STUCK: string;
+    /**
+     * There is no extractor plugin.
+     *
+     * It is raised when a search is requested but no {@link ExtractorPlugin} is
+     * registered in {@link DisTubeOptions.plugins}.
+     */
+    NO_EXTRACTOR_PLUGIN: string;
+    /**
+     * No related song could be found.
+     *
+     * It is raised when the autoplay mode is enabled and no plugin could find
+     * a related song for the current one.
+     */
+    NO_RELATED: string;
+    /**
+     * The related song cannot be played.
+     *
+     * It is raised when the related song of the autoplay mode cannot be
+     * played.
+     */
+    CANNOT_PLAY_RELATED: string;
+    /**
+     * The video is unavailable.
+     *
+     * It is raised when the source of the song does not have the video anymore,
+     * e.g. when it was removed or when it is private.
+     */
+    UNAVAILABLE_VIDEO: string;
+    /**
+     * No playable format was found.
+     *
+     * It is raised when the source of the song does not have any format that
+     * FFmpeg can play.
+     */
+    UNPLAYABLE_FORMATS: string;
+    /**
+     * The content is age-restricted and cannot be played in this channel.
+     *
+     * It is raised when an age-restricted song is played in a non-NSFW channel
+     * while {@link DisTubeOptions.nsfw} is `false`.
+     */
+    NON_NSFW: string;
+    /**
+     * The url is not supported.
+     *
+     * It is raised when no plugin of {@link DisTubeOptions.plugins} can handle
+     * the url.
+     */
+    NOT_SUPPORTED_URL: string;
+    /**
+     * No plugin supports the song.
+     *
+     * It is raised when no plugin of {@link DisTubeOptions.plugins} can play
+     * the song.
+     */
+    NOT_SUPPORTED_SONG: (song: string) => string;
+    /**
+     * The array does not have any valid song.
+     *
+     * It is raised when every element of the `songs` array of
+     * {@link DisTube#createCustomPlaylist} is neither a {@link Song} nor a
+     * valid url.
+     */
+    NO_VALID_SONG: string;
+    /**
+     * The input cannot be resolved to a song or a playlist.
+     *
+     * It is raised when the input of {@link DisTubeHandler#resolve} is neither
+     * a url, nor a {@link Song}, nor a {@link Playlist}.
+     */
+    CANNOT_RESOLVE_SONG: (t: any) => string;
+    /**
+     * The stream url of the song cannot be found.
+     *
+     * It is raised when the plugin of the song does not return a stream url.
+     */
+    CANNOT_GET_STREAM_URL: (song: string) => string;
+    /**
+     * The search query of the song cannot be built.
+     *
+     * It is raised when the plugin of the song cannot build a query to look for
+     * a playable version of it.
+     */
+    CANNOT_GET_SEARCH_QUERY: (song: string) => string;
+    /**
+     * No song was found for the query.
+     *
+     * It is raised when no plugin of {@link DisTubeOptions.plugins} has any
+     * result for the search query.
+     */
+    NO_RESULT: (query: string) => string;
+    /**
+     * The song does not have any stream url.
+     *
+     * It is raised when a song is played while it does not have a stream url
+     * attached to it.
+     */
+    NO_STREAM_URL: (song: string) => string;
+    /**
+     * Every video of the playlist was filtered out.
+     *
+     * It is raised when a playlist does not have any valid video left, e.g.
+     * because all of them were age-restricted and the channel is not NSFW.
+     */
+    EMPTY_FILTERED_PLAYLIST: string;
+    /**
+     * The playlist does not have any valid video.
+     *
+     * It is raised when a playlist is empty.
+     */
+    EMPTY_PLAYLIST: string;
+};
+type ErrorMessage = typeof ERROR_MESSAGES;
+type ErrorCode = keyof ErrorMessage;
+type StaticErrorCode = {
+    [K in ErrorCode]-?: ErrorMessage[K] extends string ? K : never;
+}[ErrorCode];
+type TemplateErrorCode = Exclude<keyof typeof ERROR_MESSAGES, StaticErrorCode>;
+/**
+ * The error raised by DisTube.
+ *
+ * Every error of the library is a `DisTubeError`: it has a machine readable
+ * `errorCode` and a human readable message that is built from the code.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await distube.play(channel, "Never gonna give you up");
+ * } catch (error) {
+ *   if (error instanceof DisTubeError && error.errorCode === "NO_RESULT") {
+ *     // No song was found for the query.
+ *   }
+ * }
+ * ```
+ */
+declare class DisTubeError<T extends string = any> extends Error {
+    /**
+     * The code of the error, e.g. `NO_RESULT`.
+     */
+    errorCode: string;
+    /**
+     * Create a DisTube error with a static error code.
+     * @param code - The code of the error
+     */
+    constructor(code: T extends StaticErrorCode ? T : never);
+    /**
+     * Create a DisTube error with a templated error code.
+     * @param code - The code of the error
+     * @param args - The arguments of the message template of the code
+     */
+    constructor(code: T extends TemplateErrorCode ? T : never, ...args: Parameters<ErrorMessage[typeof code]>);
+    /**
+     * Create a DisTube error with a templated error code.
+     * @param code - The code of the error
+     * @param _    - Not used: it prevents this overload from being selected
+     */
+    constructor(code: TemplateErrorCode, _: never);
+    /**
+     * Create a DisTube error with a custom message.
+     * @param code    - The code of the error
+     * @param message - The custom message of the error
+     */
+    constructor(code: T extends ErrorCode ? never : T, message: string);
+    /**
+     * Create a {@link DisTubeError} with a custom message.
+     *
+     * The default message of an error code is a generic template. Use this factory
+     * when you need to tell the user what exactly went wrong, or when you want to
+     * keep the original error as the `cause` of the error.
+     *
+     * It is polymorphic: calling it on a subclass creates an instance of that
+     * subclass.
+     *
+     * @param code    - The error code
+     * @param message - The custom message
+     * @param options - Optional options
+     * @param options.cause - The original error that caused this one
+     * @returns The created error
+     */
+    static withMessage<T extends string = any>(code: T, message: string, options?: {
+        cause?: unknown;
+    }): DisTubeError<T>;
+    /**
+     * The name of the error, with its code.
+     * @returns The name of the error, e.g. `DisTubeError [NO_RESULT]`
+     */
+    get name(): string;
+    /**
+     * The code of the error, e.g. `NO_RESULT`.
+     *
+     * It is an alias of {@link DisTubeError.errorCode}.
+     * @returns The code of the error
+     */
+    get code(): string;
+}
+
+/**
+ * Manage filters of a playing {@link Queue}
+ */
+declare class FilterManager extends BaseManager<Filter> {
+    #private;
+    /**
+     * The queue to manage
+     */
+    queue: Queue;
+    /**
+     * Create a filter manager for a queue.
+     * @param queue - The queue to manage
+     */
+    constructor(queue: Queue);
+    /**
+     * Enable a filter or multiple filters to the manager
+     * @param filterOrFilters - The filter or filters to enable
+     * @param override        - Wether or not override the applied filter with new filter value
+     * @returns This manager, to allow chaining
+     * @throws {@link DisTubeError} When a filter is not a valid {@link FilterResolvable}
+     * @example
+     * ```ts
+     * queue.filters.add("bassboost");
+     * ```
+     */
+    add(filterOrFilters: FilterResolvable | FilterResolvable[], override?: boolean): this;
+    /**
+     * Clear enabled filters of the manager
+     * @returns This manager, to allow chaining
+     */
+    clear(): this;
+    /**
+     * Set the filters applied to the manager
+     * @param filters - The filters to apply
+     * @returns This manager, to allow chaining
+     * @throws {@link DisTubeError} When the array is invalid, or when a filter is
+     * not a valid {@link FilterResolvable}
+     */
+    set(filters: FilterResolvable[]): this;
+    /**
+     * Disable a filter or multiple filters
+     * @param filterOrFilters - The filter or filters to disable
+     * @returns This manager, to allow chaining
+     * @throws {@link DisTubeError} When a filter is not a valid {@link FilterResolvable}
+     */
+    remove(filterOrFilters: FilterResolvable | FilterResolvable[]): this;
+    /**
+     * Check whether a filter enabled or not
+     * @param filter - The filter to check
+     * @returns `true` when the filter is enabled
+     * @throws {@link DisTubeError} When the filter is not a valid {@link FilterResolvable}
+     */
+    has(filter: FilterResolvable): boolean;
+    /**
+     * Array of enabled filter names
+     */
+    get names(): string[];
+    /**
+     * Array of enabled filters
+     */
+    get values(): Filter[];
+    /**
+     * The FFmpeg arguments of the enabled filters.
+     *
+     * It is the `af` output argument of the FFmpeg process.
+     */
+    get ffmpegArgs(): FFmpegArg;
+    /**
+     * The names of the enabled filters, as a comma separated string.
+     * @returns The names of the enabled filters
+     */
+    toString(): string;
+}
+
+/**
+ * Task queuing system
+ *
+ * It makes sure that the tasks of a {@link Queue} are processed one after the
+ * other, instead of all at the same time.
+ */
+declare class TaskQueue {
+    #private;
+    /**
+     * Waits for last task finished and queues a new task
+     * @param isPlay - Whether the task is a play task
+     * @returns A promise that resolves when the last queued task is finished
+     */
+    queuing(isPlay?: boolean): Promise<void>;
+    /**
+     * Removes the finished task and processes the next task
+     * @returns Nothing
+     */
+    resolve(): void;
+    /**
+     * The remaining number of tasks
+     */
+    get remaining(): number;
+    /**
+     * Whether or not having a play task
+     */
+    get hasPlayTask(): boolean;
+}
+
+/**
+ * Represents a queue.
+ */
+declare class Queue extends DisTubeBase {
+    #private;
+    /**
+     * Queue id (Guild id)
+     */
+    readonly id: Snowflake;
+    /**
+     * Voice connection of this queue.
+     */
+    voice: DisTubeVoice;
+    /**
+     * List of songs in the queue (The first one is the playing song)
+     */
+    songs: Song[];
+    /**
+     * List of the previous songs.
+     */
+    previousSongs: Song[];
+    /**
+     * Whether stream is currently stopped.
+     */
+    stopped: boolean;
+    /**
+     * Whether or not the stream is currently paused.
+     *
+     * It is also `true` once the queue has been stopped, so that `!queue.paused`
+     * stays `false` as soon as the queue is not playing anymore.
+     */
+    paused: boolean;
+    /**
+     * Type of repeat mode (`0` is disabled, `1` is repeating a song, `2` is repeating
+     * all the queue). Default value: `0` (disabled)
+     */
+    repeatMode: RepeatMode;
+    /**
+     * Whether or not the autoplay mode is enabled. Default value: `false`
+     */
+    autoplay: boolean;
+    /**
+     * FFmpeg arguments for the current queue. Default value is defined with {@link DisTubeOptions}.ffmpeg.args.
+     * `af` output argument will be replaced with {@link Queue#filters} manager
+     */
+    ffmpegArgs: FFmpegArgs;
+    /**
+     * The text channel of the Queue. (Default: where the first command is called).
+     */
+    textChannel?: GuildTextBasedChannel;
+    /**
+     * What time in the song to begin (in seconds).
+     * @internal
+     */
+    _beginTime: number;
+    /**
+     * Whether or not the queue is being updated manually (skip, jump, previous)
+     * @internal
+     */
+    _manualUpdate: boolean;
+    /**
+     * Task queuing system
+     * @internal
+     */
+    _taskQueue: TaskQueue;
+    /**
+     * {@link DisTubeVoice} listener
+     * @internal
+     */
+    _listeners?: DisTubeVoiceEvents;
+    /**
+     * Create a queue for the guild
+     * @param distube     - DisTube
+     * @param voice       - Voice connection
+     * @param textChannel - Default text channel
+     */
+    constructor(distube: DisTube, voice: DisTubeVoice, textChannel?: GuildTextBasedChannel);
+    /**
+     * The client user as a `GuildMember` of this queue's guild
+     */
+    get clientMember(): discord_js.GuildMember | undefined;
+    /**
+     * The filter manager of the queue
+     */
+    get filters(): FilterManager;
+    /**
+     * Whether or not the queue is still active.
+     *
+     * It is `false` only when the queue has been stopped. A paused queue is still
+     * active.
+     */
+    get isActive(): boolean;
+    /**
+     * Formatted duration string.
+     */
+    get formattedDuration(): string;
+    /**
+     * Queue's duration.
+     */
+    get duration(): number;
+    /**
+     * What time in the song is playing (in seconds).
+     */
+    get currentTime(): number;
+    /**
+     * Formatted {@link Queue#currentTime} string.
+     */
+    get formattedCurrentTime(): string;
+    /**
+     * The voice channel playing in.
+     */
+    get voiceChannel(): discord_js.VoiceBasedChannel | null;
+    /**
+     * Get or set the stream volume. Default value: `50`.
+     */
+    get volume(): number;
+    /**
+     * Set the stream volume.
+     * @param value - The volume percentage, from `0` to `100`
+     * @throws {@link DisTubeError} When the volume is not a number, or when it is
+     * negative
+     */
+    set volume(value: number);
+    /**
+     * Add a song or a list of songs to the queue.
+     * @throws {DisTubeError}
+     * @param song     - Song to add
+     * @param position - Position to add, \<= 0 to add to the end of the queue
+     * @returns The guild queue
+     * @example
+     * ```ts
+     * queue.addToQueue(song);
+     * ```
+     */
+    addToQueue(song: Song | Song[], position?: number): Queue;
+    /**
+    /**
+     * Pause the guild stream
+     * @returns The guild queue
+     * @throws {@link DisTubeError} When the queue is already paused
+     * @example
+     * ```ts
+     * await queue.pause();
+     * ```
+     */
+    pause(): Promise<Queue>;
+    /**
+     * Resume the guild stream
+     * @returns The guild queue
+     * @throws {@link DisTubeError} When the queue is not paused
+     * @example
+     * ```ts
+     * await queue.resume();
+     * ```
+     */
+    resume(): Promise<Queue>;
+    /**
+     * Set the guild stream's volume
+     * @param percent - The percentage of volume you want to set
+     * @returns The guild queue
+     * @throws {@link DisTubeError} When the volume is not a number, or when it is
+     * negative
+     */
+    setVolume(percent: number): Queue;
+    /**
+     * Skip the playing song if there is a next song in the queue. <info>If {@link
+     * Queue#autoplay} is `true` and there is no up next song, DisTube will add and
+     * play a related song.</info>
+     * @param options - Skip options
+     * @returns The song will skip to
+     * @throws {@link DisTubeError} When there is no up next song, or when the
+     * position is out of the bounds of the queue
+     * @example
+     * ```ts
+     * await queue.skip();
+     * ```
+     */
+    skip(options?: JumpOptions): Promise<Song>;
+    /**
+     * Play the previous song if exists
+     * @returns The guild queue
+     * @throws {@link DisTubeError} When {@link DisTubeOptions.savePreviousSongs} is
+     * disabled, or when the queue does not have any previous song
+     */
+    previous(): Promise<Song>;
+    /**
+     * Shuffle the queue's songs
+     * @returns The guild queue
+     */
+    shuffle(): Promise<Queue>;
+    /**
+     * Jump to the song position in the queue. The next one is 1, 2,... The previous
+     * one is -1, -2,...
+     * if `num` is invalid number
+     * @param position - The song position to play
+     * @param options  - Skip options
+     * @returns The new Song will be played
+     * @throws {@link DisTubeError} When the position is invalid, when there is no
+     * up next song, or when {@link DisTubeOptions.savePreviousSongs} is disabled
+     * and the jump is backwards
+     */
+    jump(position: number, options?: JumpOptions): Promise<Song>;
+    /**
+     * Set the repeat mode of the guild queue.
+     * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
+     * @param mode - The repeat modes (toggle if `undefined`)
+     * @returns The new repeat mode
+     * @throws {@link DisTubeError} When the mode is not a valid {@link RepeatMode}
+     */
+    setRepeatMode(mode?: RepeatMode): RepeatMode;
+    /**
+     * Set the playing time to another position
+     * @param time - Time in seconds
+     * @returns The guild queue
+     * @throws {@link DisTubeError} When the time is not a number, or when it is
+     * negative
+     * @example
+     * ```ts
+     * await queue.seek(60);
+     * ```
+     */
+    seek(time: number): Promise<Queue>;
+    /**
+     * Internal implementation of addRelatedSong without task queue protection.
+     * Used by methods that already hold the task queue lock.
+     * @param song - The song to get related songs from. Defaults to the current playing song.
+     * @returns A promise that resolves to the added song
+     * @throws {@link DisTubeError} When the queue does not have any playing song,
+     * or when no related song could be found
+     * @internal
+     */
+    _addRelatedSong(song?: Song): Promise<Song>;
+    /**
+     * Add a related song of the playing song to the queue
+     * @param song - The song to get related songs from. Defaults to the current playing song.
+     * @returns The added song
+     * @throws {@link DisTubeError} When the queue does not have any playing song,
+     * or when no related song could be found
+     */
+    addRelatedSong(song?: Song): Promise<Song>;
+    /**
+     * Stop the guild stream and delete the queue
+     * @returns A promise that resolves when the queue is stopped
+     */
+    stop(): Promise<void>;
+    /**
+     * Remove the queue from the manager
+     * @returns Nothing
+     */
+    remove(): void;
+    /**
+     * Toggle autoplay mode
+     * @returns Autoplay mode state
+     */
+    toggleAutoplay(): boolean;
+    /**
+     * Play the first song in the queue
+     * @param emitPlaySong - Whether or not emit {@link Events.PLAY_SONG} event
+     * @returns A promise that resolves when the song is playing
+     * @throws {@link DisTubeError} When the queue has been stopped
+     */
+    play(emitPlaySong?: boolean): Promise<void>;
+    /**
+     * Restart the current stream with the current FFmpeg arguments, keeping the
+     * playback position.
+     *
+     * The FFmpeg audio filters are applied when the stream is created, so the stream
+     * has to be recreated whenever the filters change.
+     *
+     * Unlike a regular playback error, a failure while restarting the stream does
+     * **not** remove the current song from the queue.
+     * @returns A promise that resolves when the stream is restarted
+     * @internal
+     */
+    _restartStream(): Promise<void>;
+}
+
+/**
+ * The result of a search.
+ *
+ * It is the result type of every search, at the plugin level and at the
+ * DisTube level.
+ */
+declare class SearchResult<T = unknown> {
+    /**
+     * The query of the search.
+     */
+    readonly query: string;
+    /**
+     * The kind of result that was looked for.
+     */
+    readonly queryType: SearchResultType;
+    /**
+     * The songs that were found.
+     */
+    readonly songs: Song<T>[];
+    /**
+     * The playlist that was found, when the search returned one.
+     */
+    readonly playlist?: Playlist<T>;
+    /**
+     * The identifiers of the plugins that contributed to the result.
+     */
+    readonly sources: string[];
+    /**
+     * Create a search result.
+     * @param query   - The query of the search
+     * @param options - Optional data
+     * @param options.songs     - The songs that were found
+     * @param options.playlist  - The playlist that was found
+     * @param options.queryType - The kind of result that was looked for
+     * @param options.sources   - The identifiers of the plugins that contributed
+     * to the result
+     * @example
+     * ```ts
+     * const result = new SearchResult("Never gonna give you up", { songs: [song] });
+     * ```
+     */
+    constructor(query: string, { songs, playlist, queryType, sources, }?: {
+        songs?: Song<T>[];
+        playlist?: Playlist<T>;
+        queryType?: SearchResultType;
+        sources?: string[];
+    });
+    /**
+     * Whether the search returned nothing.
+     * @returns `true` when the result has neither songs nor a playlist
+     */
+    isEmpty(): boolean;
+    /**
+     * Whether the search returned songs.
+     * @returns `true` when the result has at least one song
+     */
+    hasSongs(): boolean;
+    /**
+     * Whether the search returned a playlist.
+     * @returns `true` when the result has a playlist
+     */
+    hasPlaylist(): boolean;
+    /**
+     * A plain object representation of the result.
+     * @returns The plain object representation of the result
+     */
+    toJSON(): object;
+}
+
+/**
+ * DisTube class
+ */
+declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
+    #private;
+    /**
+     * @event
+     * Emitted after DisTube add a new playlist to the playing {@link Queue}.
+     * @param queue    - The guild queue
+     * @param playlist - Playlist info
+     */
+    static readonly [Events.ADD_LIST]: (queue: Queue, playlist: Playlist) => Awaitable;
+    /**
+     * @event
+     * Emitted after DisTube add a new song to the playing {@link Queue}.
+     * @param queue - The guild queue
+     * @param song  - Added song
+     */
+    static readonly [Events.ADD_SONG]: (queue: Queue, song: Song) => Awaitable;
+    /**
+     * @event
+     * Emitted when the {@link Queue} is deleted with any reasons.
+     * @param queue - The guild queue
+     */
+    static readonly [Events.DELETE_QUEUE]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when the bot is disconnected to a voice channel.
+     * @param queue - The guild queue
+     */
+    static readonly [Events.DISCONNECT]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when the {@link Queue} runs out of songs to play.
+     * @param queue - The guild queue
+     */
+    static readonly [Events.EMPTY]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube encounters an error while playing songs.
+     * @param error   - error
+     * @param queue   - The queue encountered the error
+     * @param song    - The playing song when encountered the error
+     */
+    static readonly [Events.ERROR]: (error: Error, queue: Queue, song?: Song) => Awaitable;
+    /**
+     * @event
+     * Emitted for logging FFmpeg debug information.
+     * @param debug - Debug message string.
+     */
+    static readonly [Events.FFMPEG_DEBUG]: (debug: string) => Awaitable;
+    /**
+     * @event
+     * Emitted to provide debug information from DisTube's operation.
+     * Useful for troubleshooting or logging purposes.
+     *
+     * @param debug - Debug message string.
+     */
+    static readonly [Events.DEBUG]: (debug: string) => Awaitable;
+    /**
+     * @event
+     * Emitted when there is no more song in the queue and {@link Queue#autoplay} is `false`.
+     * @param queue - The guild queue
+     */
+    static readonly [Events.FINISH]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube finished a song.
+     * @param queue - The guild queue
+     * @param song  - Finished song
+     */
+    static readonly [Events.FINISH_SONG]: (queue: Queue, song: Song) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube initialize a queue to change queue default properties.
+     * @param queue - The guild queue
+     */
+    static readonly [Events.INIT_QUEUE]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when {@link Queue#autoplay} is `true`, {@link Queue#songs} is empty, and
+     * DisTube cannot find related songs to play.
+     * @param queue - The guild queue
+     * @param error - The error that occurred while looking for related songs
+     */
+    static readonly [Events.NO_RELATED]: (queue: Queue, error: DisTubeError) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube play a song.
+     * If {@link DisTubeOptions}.emitNewSongOnly is `true`, this event is not emitted
+     * when looping a song or next song is the previous one.
+     * @param queue - The guild queue
+     * @param song  - Playing song
+     */
+    static readonly [Events.PLAY_SONG]: (queue: Queue, song: Song) => Awaitable;
+    /**
+     * DisTube internal handler
+     */
+    readonly handler: DisTubeHandler;
+    /**
+     * DisTube options
+     */
+    readonly options: Options;
+    /**
+     * Discord.js v14 client
+     */
+    readonly client: Client;
+    /**
+     * Queues manager
+     */
+    readonly queues: QueueManager;
+    /**
+     * DisTube voice connections manager
+     */
+    readonly voices: DisTubeVoiceManager;
+    /**
+     * DisTube plugins
+     */
+    readonly plugins: DisTubePlugin[];
+    /**
+     * The local HTTP server the plugins use to stream the audio.
+     *
+     * A plugin that cannot hand out a static URL to FFmpeg registers a handler on
+     * it, instead of running its own server.
+     */
+    readonly streams: StreamServer;
+    /**
+     * DisTube ffmpeg audio filters
+     */
+    readonly filters: Filters;
+    /**
+     * Create a new DisTube class.
+     * @throws {@link DisTubeError}
+     * @param client - Discord.JS client
+     * @param opts   - Custom DisTube options
+     * @example
+     * ```ts
+     * const distube = new DisTube(client, { nsfw: false });
+     * ```
+     */
+    constructor(client: Client, opts?: DisTubeOptions);
+    /**
+     * Create a DisTube instance and wait for the plugins to be initialized.
+     *
+     * Use it when a plugin does asynchronous work in its `init` method: the
+     * constructor cannot await it.
+     * @param client - The Discord.js client
+     * @param opts   - Optional options
+     * @returns The DisTube instance
+     * @example
+     * ```ts
+     * const distube = await DisTube.create(client, { plugins: [new YoutubePlugin()] });
+     * ```
+     */
+    static create(client: Client, opts?: DisTubeOptions): Promise<DisTube>;
+    /**
+     * Emit an event of the DisTube instance.
+     *
+     * The special {@link Events.ERROR} event is handled differently than the other
+     * events: Node.js throws an `ERR_UNHANDLED_ERROR` when the special `"error"`
+     * event is emitted without any listener, which crashes the whole process.
+     *
+     * Instead of crashing, DisTube follows {@link DisTubeOptions.unhandledError}
+     * (`"log"` by default).
+     * @param event - The event name
+     * @param args  - The event arguments
+     * @returns `true` when the event had listeners, `false` otherwise
+     */
+    emit<U extends keyof TypedDisTubeEvents>(event: U, ...args: Parameters<TypedDisTubeEvents[U]>): boolean;
+    /**
+     * DisTube version
+     */
+    static get version(): string;
+    /**
+     * DisTube version
+     */
+    get version(): string;
+    /**
+     * Play / add a song or playlist from url.
+     * Search and play a song (with {@link ExtractorPlugin}) if it is not a valid url.
+     * @throws {@link DisTubeError}
+     * @param voiceChannel - The channel will be joined if the bot isn't in any channels, the bot will be
+     *                       moved to this channel if {@link DisTubeOptions}.joinNewVoiceChannel is `true`
+     * @param song         - URL | Search string | {@link Song} | {@link Playlist}
+     * @param options      - Optional options
+     * @returns A promise that resolves when the song is added to the queue
+     * @example
+     * ```ts
+     * await distube.play(channel, "Never gonna give you up", { message });
+     * ```
+     */
+    play<T = unknown>(voiceChannel: VoiceBasedChannel, song: string | Song | Playlist, options?: PlayOptions<T>): Promise<void>;
+    /**
+     * Create a custom playlist
+     * @param songs   - Array of url or Song
+     * @param options - Optional options
+     * @returns The created playlist
+     * @throws {@link DisTubeError} When the array is empty, or when it does not
+     * have any valid song
+     */
+    createCustomPlaylist(songs: (string | Song)[], { member, parallel, metadata, name, source, url, thumbnail }?: CustomPlaylistOptions): Promise<Playlist>;
+    /**
+     * Get the guild queue
+     * @param guild - The type can be resolved to give a {@link Queue}
+     * @returns The queue of the guild, or `undefined` when there is none
+     * @example
+     * ```ts
+     * const queue = distube.getQueue(guildId);
+     * ```
+     */
+    getQueue(guild: GuildIdResolvable): Queue | undefined;
+    /**
+     * Get a plugin by the identifier of its source.
+     *
+     * It matches the {@link Plugin.source} of the plugin, or one of its
+     * {@link Plugin.aliases}. The identifier of the class is used when the
+     * plugin does not define a source (`YoutubePlugin` -> `youtube`).
+     * @param source - The identifier of the source
+     * @returns The plugin, or `undefined` when there is none
+     * @example
+     * ```ts
+     * const plugin = distube.getPlugin("youtube");
+     * ```
+     */
+    getPlugin(source: string): DisTubePlugin | undefined;
+    /**
+     * Search for the songs of the plugins.
+     *
+     * The plugins are used in the order they were registered. When
+     * {@link ResolveOptions.source} is given, only the matching plugin is used.
+     * @param query   - The search query
+     * @param options - Optional options
+     * @returns The result of the search
+     * @example
+     * ```ts
+     * const result = await distube.search("Never gonna give you up", { limit: 5 });
+     * ```
+     */
+    search<T = unknown>(query: string, options?: SearchOptions<T>): Promise<SearchResult<T>>;
+    /**
+    /**
+    /**
+    /**
+     * Emit error event
+     * @param error   - error
+     * @param queue   - The queue encountered the error
+     * @param song    - The playing song when encountered the error
+     * @returns Nothing
+     */
+    emitError(error: Error, queue: Queue, song?: Song): void;
+    /**
+     * Emit debug event
+     * @param message - debug message
+     * @returns Nothing
+     */
+    debug(message: string): void;
+    /**
+     * Destroy the DisTube instance.
+     *
+     * Stops every queue, leaves every voice channel, destroys every plugin and
+     * removes every listener.
+     * Call it before your Discord.js client is destroyed to release all resources.
+     * @returns A promise that resolves when every resource is released
+     * @example
+     * ```ts
+     * await distube.destroy();
+     * ```
+     */
+    destroy(): Promise<void>;
+}
+
+/**
+ * The base class of every DisTube internal that needs a reference to the
+ * {@link DisTube} instance.
+ */
+declare abstract class DisTubeBase {
+    /**
+     * The DisTube instance this object belongs to.
+     */
+    distube: DisTube;
+    /**
+     * Create a new base object.
+     * @param distube - The DisTube instance
+     */
+    constructor(distube: DisTube);
+    /**
+     * Emit the {@link DisTube} of this base
+     * @param eventName - Event name
+     * @param args      - arguments
+     * @returns `true` when the event had listeners, `false` otherwise
+     */
+    emit(eventName: keyof DisTubeEvents, ...args: any): boolean;
+    /**
+     * Emit error event
+     * @param error   - error
+     * @param queue   - The queue encountered the error
+     * @param song    - The playing song when encountered the error
+     * @returns Nothing
+     */
+    emitError(error: Error, queue: Queue, song?: Song): void;
+    /**
+     * Emit debug event
+     * @param message - debug message
+     * @returns Nothing
+     */
+    debug(message: string): void;
+    /**
+     * The queue manager
+     */
+    get queues(): QueueManager;
+    /**
+     * The voice manager
+     */
+    get voices(): DisTubeVoiceManager;
+    /**
+     * Discord.js client
+     */
+    get client(): Client;
+    /**
+     * DisTube options
+     */
+    get options(): Options;
+    /**
+     * DisTube handler
+     */
+    get handler(): DisTubeHandler;
+    /**
+     * DisTube plugins
+     */
+    get plugins(): DisTubePlugin[];
+}
+
+/**
+ * DisTube Plugin
+ */
+declare abstract class Plugin {
+    /**
+     * Type of the plugin
+     */
+    abstract readonly type: PluginType;
+    /**
+     * The identifier of the source of the plugin.
+     *
+     * It defaults to the name of the class, lowercased, without the `Plugin`
+     * suffix (`YoutubePlugin` -> `youtube`).
+     *
+     * It is used to route a search to a plugin, and to find a plugin with
+     * {@link DisTube#getPlugin}.
+     */
+    readonly source?: string;
+    /**
+     * Additional identifiers of the source of the plugin, e.g. `["yt"]`.
+     */
+    readonly aliases?: string[];
+    /**
+     * Whether the songs of this plugin can be played directly.
+     *
+     * When it is `false`, the songs of the plugin are resolved to a playable
+     * version by another plugin. It defaults to `true`.
+     */
+    readonly playable?: boolean;
+    /**
+     * DisTube
+     */
+    distube: DisTube;
+    /**
+     * Initialize the plugin.
+     *
+     * It can be asynchronous: use {@link DisTube.create} to wait for the
+     * initialization of the plugins.
+     * @param distube - The DisTube instance
+     * @returns Nothing, or a promise that resolves when the plugin is initialized
+     * @example
+     * ```ts
+     * override async init(distube: DisTube) {
+     *   this.client = await createSession();
+     * }
+     * ```
+     */
+    init(distube: DisTube): void | Promise<void>;
+    /**
+     * Every identifier of this plugin: its {@link Plugin.source} and its
+     * {@link Plugin.aliases}, lowercased.
+     *
+     * The static properties of the class are used when the instance ones are not
+     * defined, so a plugin can declare them either way.
+     */
+    get identifiers(): string[];
+    /**
+     * The local HTTP server of the DisTube instance.
+     *
+     * Register a handler on it when the plugin cannot hand out a static URL to
+     * FFmpeg, instead of running its own server.
+     */
+    get streams(): StreamServer;
+    /**
+     * Search for a song of the source.
+     *
+     * Override it to enable the search of your source. It returns `null` by
+     * default, because a source that cannot be searched does not have any result.
+     * @param _query   - Search query
+     * @param _options - Optional options
+     * @returns The song that was found, or `null`
+     * @example
+     * ```ts
+     * override async searchSong(query: string): Promise<Song | null> {
+     *   return findSong(query);
+     * }
+     * ```
+     */
+    searchSong<T>(_query: string, _options: ResolveOptions<T>): Awaitable<Song<T> | null>;
+    /**
+     * Search for the songs of the source.
+     *
+     * The default implementation returns the single result of
+     * {@link Plugin#searchSong}. Override it to return more results, or to return
+     * a playlist.
+     * @param query   - Search query
+     * @param options - Optional options
+     * @returns The result of the search
+     * @example
+     * ```ts
+     * const result = await plugin.search("Never gonna give you up", { limit: 5 });
+     * ```
+     */
+    search<T>(query: string, options?: SearchOptions<T>): Promise<SearchResult<T>>;
+    /**
+     * Create the query used to find a playable version of a song.
+     *
+     * It is used when the plugin cannot play the songs it resolves.
+     * @param song - Input song
+     * @returns The search query
+     * @example
+     * ```ts
+     * override createSearchQuery(song: Song): string {
+     *   return `${song.name} ${song.uploader?.name}`;
+     * }
+     * ```
+     */
+    createSearchQuery<T>(song: Song<T>): Awaitable<string>;
+    /**
+     * Get related songs from a supported url.
+     *
+     * Override it to enable the autoplay for your source. Return an empty array
+     * when your source does not have any related songs.
+     * @param _song - Input song
+     * @returns The related songs
+     */
+    getRelatedSongs(_song: Song): Awaitable<Song[]>;
+    /**
+     * Destroy the plugin.
+     *
+     * It is called when the {@link DisTube} instance is destroyed. Override it to
+     * release every resource held by the plugin (HTTP servers, timers, browser
+     * sessions, ...).
+     * @returns Nothing, or a promise that resolves when the plugin is destroyed
+     */
+    destroy(): void | Promise<void>;
+}
+
+/**
+ * This plugin can extract the info, search, and play a song directly from its source
+ */
+declare abstract class ExtractorPlugin extends Plugin {
+    /**
+     * The type of the plugin.
+     */
+    readonly type: PluginType;
+    /**
+     * Check if the url is working with this plugin
+     * @param url - Input url
+     * @returns `true` when the plugin can handle the url
+     */
+    abstract validate(url: string): Awaitable<boolean>;
+    /**
+     * Resolve the validated url to a {@link Song} or a {@link Playlist}.
+     * @param url     - URL
+     * @param options - Optional options
+     * @returns The resolved song or playlist
+     */
+    abstract resolve<T>(url: string, options: ResolveOptions<T>): Awaitable<Song<T> | Playlist<T>>;
+    /**
+     * Get the stream url from {@link Song#url}. Returns {@link Song#url} by default.
+     * Not needed if the plugin plays song from YouTube.
+     * @param song - Input song
+     * @returns The url of the audio stream
+     */
+    abstract getStreamURL<T>(song: Song<T>): Awaitable<string>;
+}
+
+/**
+ * This plugin only can extract the info from supported links, but not play song directly from its source
+ *
+ * @deprecated Use {@link ExtractorPlugin} with `playable: false` instead.
+ */
+declare abstract class InfoExtractorPlugin extends ExtractorPlugin {
+    /**
+     * The type of the plugin.
+     */
+    readonly type: PluginType;
+    /**
+     * The songs of this plugin are resolved to a playable version by another
+     * plugin.
+     */
+    readonly playable = false;
+    /**
+     * Check if the url is working with this plugin
+     * @param url - Input url
+     * @returns `true` when the plugin can handle the url
+     */
+    abstract validate(url: string): Awaitable<boolean>;
+    /**
+     * Resolve the validated url to a {@link Song} or a {@link Playlist}.
+     * @param url     - URL
+     * @param options - Optional options
+     * @returns The resolved song or playlist
+     */
+    abstract resolve<T>(url: string, options: ResolveOptions<T>): Awaitable<Song<T> | Playlist<T>>;
+    /**
+     * Create a search query to be used in {@link ExtractorPlugin#searchSong}
+     * @param song - Input song
+     * @returns The search query
+     */
+    abstract createSearchQuery<T>(song: Song<T>): Awaitable<string>;
+    /**
+     * This plugin cannot play the songs it resolves, so it never has a stream url.
+     * @param _song - Input song
+     * @returns Nothing: it always throws
+     * @throws {@link PluginError} Always, with the code `NO_STREAM`
+     */
+    getStreamURL<T>(_song: Song<T>): Promise<string>;
+}
+
+/**
+ * This plugin can extract and play song from supported links, but cannot search for songs from its source
+ */
+declare abstract class PlayableExtractorPlugin extends ExtractorPlugin {
+    /**
+     * The type of the plugin.
+     */
+    readonly type: PluginType;
+    /**
+     * Check if the url is working with this plugin
+     * @param url - Input url
+     * @returns `true` when the plugin can handle the url
+     */
+    abstract validate(url: string): Awaitable<boolean>;
+    /**
+     * Resolve the validated url to a {@link Song} or a {@link Playlist}.
+     * @param url     - URL
+     * @param options - Optional options
+     * @returns The resolved song or playlist
+     */
+    abstract resolve<T>(url: string, options: ResolveOptions<T>): Awaitable<Song<T> | Playlist<T>>;
+    /**
+     * Get the stream url from {@link Song#url}. Returns {@link Song#url} by default.
+     * Not needed if the plugin plays song from YouTube.
+     * @param song - Input song
+     * @returns The url of the audio stream
+     */
+    abstract getStreamURL<T>(song: Song<T>): Awaitable<string>;
+}
+
+/**
+ * The error codes a plugin can raise.
+ */
+declare enum PluginErrorCode {
+    /**
+     * The URL is not supported by the plugin.
+     */
+    UNSUPPORTED_URL = "UNSUPPORTED_URL",
+    /**
+     * The song, the playlist or the album was not found.
+     */
+    NOT_FOUND = "NOT_FOUND",
+    /**
+     * The plugin could not get a playable stream for the song.
+     */
+    NO_STREAM = "NO_STREAM",
+    /**
+     * The source is temporarily unavailable: rate limit, server error or network
+     * failure.
+     */
+    SOURCE_UNAVAILABLE = "SOURCE_UNAVAILABLE",
+    /**
+     * The content is age-restricted.
+     */
+    AGE_RESTRICTED = "AGE_RESTRICTED"
+}
+/**
+ * The error raised by a plugin.
+ *
+ * It extends {@link DisTubeError}, so the code of the error is available with
+ * `error.errorCode` and the error can be caught with `instanceof DisTubeError`.
+ */
+declare class PluginError<T extends PluginErrorCode = PluginErrorCode> extends DisTubeError<T> {
+    /**
+     * Create a plugin error.
+     * @param code    - The error code
+     * @param message - The message. It defaults to the one of the error code.
+     * @param options - Optional options
+     * @param options.cause - The original error that caused this one
+     * @example
+     * ```ts
+     * throw new PluginError(PluginErrorCode.NOT_FOUND);
+     * ```
+     */
+    constructor(code: T, message?: string, options?: {
+        cause?: unknown;
+    });
+    /**
+     * The name of the error, with its code.
+     * @returns The name of the error, e.g. `PluginError [NOT_FOUND]`
+     */
+    get name(): string;
+}
+
+/**
+ * Format duration to string
+ * @param sec - Duration in seconds
+ * @returns The formatted duration, e.g. `01:23` or `01:02:03`
+ */
+declare function formatDuration(sec: number): string;
+declare const SUPPORTED_PROTOCOL: readonly ["https:", "http:", "file:"];
+/**
+ * Check if the string is an URL
+ * @param input - input
+ * @returns `true` when the input is an URL with a supported protocol
+ */
+declare function isURL(input: any): input is `${(typeof SUPPORTED_PROTOCOL)[number]}//${string}`;
+/**
+ * Check if the Client has enough intents to using DisTube
+ * @param options - options
+ * @returns Nothing
+ * @throws {@link DisTubeError} When the `GuildVoiceStates` intent is missing
+ */
+declare function checkIntents(options: ClientOptions): void;
+/**
+ * Check if the voice channel is empty
+ * @param voiceState - voiceState
+ * @returns `true` when there is no human user in the voice channel of the state
+ */
+declare function isVoiceChannelEmpty(voiceState: VoiceState): boolean;
+/**
+ * Check if the value is a valid Discord snowflake.
+ * @param id - The value to check
+ * @returns `true` when the value is a valid snowflake
+ */
+declare function isSnowflake(id: any): id is Snowflake;
+/**
+ * Check if the value is a Discord.js guild member.
+ * @param member - The value to check
+ * @returns `true` when the value looks like a guild member
+ */
+declare function isMemberInstance(member: any): member is GuildMember;
+/**
+ * Check if the value is a Discord.js guild text based channel.
+ * @param channel - The value to check
+ * @returns `true` when the value looks like a guild text based channel
+ */
+declare function isTextChannelInstance(channel: any): channel is GuildTextBasedChannel;
+/**
+ * Check if the value is a Discord.js message.
+ * @param message - The value to check
+ * @returns `true` when the value looks like a message
+ */
+declare function isMessageInstance(message: any): message is Message<true>;
+/**
+ * Check if the value is a Discord.js voice based channel.
+ * @param channel - The value to check
+ * @returns `true` when the value looks like a voice based channel
+ */
+declare function isSupportedVoiceChannel(channel: any): channel is VoiceBasedChannel;
+/**
+ * Check if the value is a Discord.js guild.
+ * @param guild - The value to check
+ * @returns `true` when the value looks like a guild
+ */
+declare function isGuildInstance(guild: any): guild is Guild;
+/**
+ * Resolve a guild id from anything that can be resolved to a guild id.
+ * @param resolvable - The value to resolve
+ * @returns The id of the guild
+ * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+ */
+declare function resolveGuildId(resolvable: GuildIdResolvable): Snowflake;
+/**
+ * Check if the value is a Discord.js client.
+ * @param client - The value to check
+ * @returns `true` when the value looks like a client
+ */
+declare function isClientInstance(client: any): client is Client;
+/**
+ * Check that an object does not have any key that is not in a source.
+ * @param target     - The object to check
+ * @param source     - The valid keys, or the object that holds them
+ * @param sourceName - The name of the source, used in the error message
+ * @returns Nothing
+ * @throws {@link DisTubeError} When the target is not an object, or when it has
+ * an invalid key
+ */
+declare function checkInvalidKey(target: Record<string, any>, source: Record<string, any> | string[], sourceName: string): void;
+/**
+ * Check if the value is a plain object.
+ * @param obj - The value to check
+ * @returns `true` when the value is an object and not an array nor `null`
+ */
+declare function isObject(obj: any): obj is object;
+/**
+ * The keys of a type, as an array.
+ */
+type KeyOf<T> = T extends object ? (keyof T)[] : [];
+/**
+ * Get the keys of an object.
+ * @param obj - The object
+ * @returns The keys of the object, or an empty array when it is not an object
+ */
+declare function objectKeys<T>(obj: T): KeyOf<T>;
+/**
+ * Check if the channel is age-restricted.
+ * @param channel - The channel to check
+ * @returns `true` when the channel is a NSFW channel
+ */
+declare function isNsfwChannel(channel?: GuildTextBasedChannel): boolean;
+/**
+ * The falsy values of JavaScript.
+ */
+type Falsy = undefined | null | false | 0 | "";
+/**
+ * Check if a value is not falsy.
+ * @param x - The value to check
+ * @returns `true` when the value is not falsy
+ */
+declare const isTruthy: <T>(x: T | Falsy) => x is T;
+/**
+ * Handle an error that was emitted through the special `"error"` event without
+ * any listener.
+ *
+ * Node.js throws an `ERR_UNHANDLED_ERROR` in that situation, which crashes the
+ * whole process. DisTube handles it gracefully instead.
+ * @param error    - The error
+ * @param behavior - The behavior to apply. Defaults to `"log"`.
+ * @returns Nothing
+ * @throws The given error when the behavior is `"throw"`
+ */
+declare function handleUnhandledError(error: Error, behavior?: UnhandledErrorBehavior): void;
+/**
+ * Check that an encryption library is available.
+ *
+ * Discord encrypts the audio with DAVE, so a cipher is required to play it.
+ * The `aes-256-gcm` cipher of Node.js is used when it is available, otherwise
+ * one of the supported third-party libraries is used.
+ * @returns `true` when an encryption library is available
+ */
+declare const checkEncryptionLibraries: () => Promise<boolean>;
+
+export { AUDIO_CHANNELS, AUDIO_SAMPLE_RATE, BaseManager, DEFAULT_VOLUME, DisTube, DisTubeBase, DisTubeError, DisTubeHandler, DisTubeStream, DisTubeVoice, DisTubeVoiceManager, Events, ExtractorPlugin, FilterManager, GuildIdManager, HTTP_REDIRECT_CODES, InfoExtractorPlugin, JOIN_TIMEOUT_MS, MAX_REDIRECT_DEPTH, Options, PlayableExtractorPlugin, Playlist, Plugin, PluginError, PluginErrorCode, PluginType, Queue, QueueManager, RECONNECT_MAX_ATTEMPTS, RECONNECT_TIMEOUT_MS, RepeatMode, STUCK_THRESHOLD_MS, SearchResult, SearchResultType, Song, StreamServer, TaskQueue, checkEncryptionLibraries, checkFFmpeg, checkIntents, checkInvalidKey, DisTube as default, defaultFilters, defaultOptions, formatDuration, handleUnhandledError, isClientInstance, isGuildInstance, isMemberInstance, isMessageInstance, isNsfwChannel, isObject, isSnowflake, isSupportedVoiceChannel, isTextChannelInstance, isTruthy, isURL, isVoiceChannelEmpty, objectKeys, resolveGuildId, version };
+export type { Awaitable, CustomPlaylistOptions, DisTubeEvents, DisTubeOptions, DisTubePlugin, DisTubeVoiceEvents, Disposable, FFmpegArg, FFmpegArgs, FFmpegOptions, Falsy, Filter, FilterResolvable, Filters, GuildIdResolvable, JumpOptions, KeyOf, PlayHandlerOptions, PlayOptions, PlaylistInfo, RelatedSong, ResolveOptions, ResolvePlaylistOptions, SearchOptions, SongInfo, StreamHandler, StreamOptions, StreamRequest, StreamResponse, StreamServerOptions, TypedDisTubeEvents, UnhandledErrorBehavior };