distube 4.1.0 → 4.2.0

package/dist/index.d.ts

@@ -1,151 +1,197 @@
-import ytdl, { Cookie } from '@distube/ytdl-core';
+import * as ytdl from '@distube/ytdl-core';
+import ytdl__default, { Cookie } from '@distube/ytdl-core';
 import * as discord_js from 'discord.js';
 import { GuildTextBasedChannel, Message, Snowflake, VoiceBasedChannel, VoiceState, Guild, GuildMember, Interaction, Client, Collection, ClientOptions } from 'discord.js';
 import ytpl from '@distube/ytpl';
 import { Video, Playlist as Playlist$1 } from '@distube/ytsr';
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { AudioPlayer, VoiceConnection, AudioResource, StreamType as StreamType$1 } from '@discordjs/voice';
-import { FFmpeg } from 'prism-media';
-import * as _discordjs_collection from '@discordjs/collection';
+import { PassThrough } from 'node:stream';
+import { ChildProcess } from 'child_process';
 
 type Awaitable<T = any> = T | PromiseLike<T>;
-type DisTubeVoiceEvents = {
-    disconnect: (error?: Error) => Awaitable;
-    error: (error: Error) => Awaitable;
-    finish: () => Awaitable;
-};
 type DisTubeEvents = {
-    error: [channel: GuildTextBasedChannel | undefined, error: Error];
     addList: [queue: Queue, playlist: Playlist];
     addSong: [queue: Queue, song: Song];
-    playSong: [queue: Queue, song: Song];
-    finishSong: [queue: Queue, song: Song];
+    deleteQueue: [queue: Queue];
+    disconnect: [queue: Queue];
     empty: [queue: Queue];
+    error: [channel: GuildTextBasedChannel | undefined, error: Error];
+    ffmpegDebug: [debug: string];
     finish: [queue: Queue];
+    finishSong: [queue: Queue, song: Song];
     initQueue: [queue: Queue];
     noRelated: [queue: Queue];
-    disconnect: [queue: Queue];
-    deleteQueue: [queue: Queue];
+    playSong: [queue: Queue, song: Song];
     searchCancel: [message: Message<true>, query: string];
-    searchNoResult: [message: Message<true>, query: string];
     searchDone: [message: Message<true>, answer: Message<true>, query: string];
     searchInvalidAnswer: [message: Message<true>, answer: Message<true>, query: string];
+    searchNoResult: [message: Message<true>, query: string];
     searchResult: [message: Message<true>, results: SearchResult[], query: string];
 };
 type TypedDisTubeEvents = {
     [K in keyof DisTubeEvents]: (...args: DisTubeEvents[K]) => Awaitable;
 };
+type DisTubeVoiceEvents = {
+    disconnect: (error?: Error) => Awaitable;
+    error: (error: Error) => Awaitable;
+    finish: () => Awaitable;
+};
 /**
  * An FFmpeg audio filter object
- * ```
+ *
+ * ```ts
  * {
  *   name:  "bassboost",
  *   value: "bass=g=10"
  * }
- * ```
- * @typedef {Object} Filter
- * @prop {string} name Name of the filter
- * @prop {string} value FFmpeg audio filter(s)
+ * ```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
- * @typedef {string|Filter} FilterResolvable
+ *
  * @see {@link defaultFilters}
  * @see {@link DisTubeOptions|DisTubeOptions.customFilters}
  */
 type FilterResolvable = string | Filter;
 /**
  * FFmpeg Filters
- * ```
+ *
+ * ```ts
  * {
  *   "Filter Name": "Filter Value",
  *   "bassboost":   "bass=g=10"
  * }
- * ```
- * @typedef {Object.<string, string>} Filters
+ * ```ts
+ *
  * @see {@link defaultFilters}
  */
 type Filters = Record<string, string>;
 /**
- * DisTube options.
- * @typedef {Object} DisTubeOptions
- * @prop {Array<CustomPlugin|ExtractorPlugin>} [plugins] DisTube plugins.
- * @prop {boolean} [emitNewSongOnly=false] Whether or not emitting {@link DisTube#event:playSong} event
- * when looping a song or next song is the same as the previous one
- * @prop {boolean} [leaveOnEmpty=true] Whether or not leaving voice channel
- * if the voice channel is empty after {@link DisTubeOptions}.emptyCooldown seconds.
- * @prop {boolean} [leaveOnFinish=false] Whether or not leaving voice channel when the queue ends.
- * @prop {boolean} [leaveOnStop=true] Whether or not leaving voice channel after using {@link DisTube#stop} function.
- * @prop {boolean} [savePreviousSongs=true] Whether or not saving the previous songs of the queue
- * and enable {@link DisTube#previous} method
- * @prop {number} [searchSongs=0] Limit of search results emits in {@link DisTube#event:searchResult} event
- * when {@link DisTube#play} method executed. If `searchSongs <= 1`, play the first result
- * @prop {Cookie[]|string} [youtubeCookie] YouTube cookies. Guide: {@link https://distube.js.org/#/docs/DisTube/main/general/cookie YouTube Cookies}
- * @prop {Filters} [customFilters] Override {@link defaultFilters} or add more ffmpeg filters.
- * @prop {ytdl.getInfoOptions} [ytdlOptions] `ytdl-core` get info options
- * @prop {number} [searchCooldown=60] Built-in search cooldown in seconds (When searchSongs is bigger than 0)
- * @prop {number} [emptyCooldown=60] Built-in leave on empty cooldown in seconds (When leaveOnEmpty is true)
- * @prop {boolean} [nsfw=false] Whether or not playing age-restricted content
- * and disabling safe search in non-NSFW channel.
- * @prop {boolean} [emitAddListWhenCreatingQueue=true] Whether or not emitting `addList` event when creating a new Queue
- * @prop {boolean} [emitAddSongWhenCreatingQueue=true] Whether or not emitting `addSong` event when creating a new Queue
- * @prop {boolean} [joinNewVoiceChannel=true] Whether or not joining the new voice channel
- * when using {@link DisTube#play} method
- * @prop {StreamType} [streamType=StreamType.OPUS] Decide the {@link DisTubeStream#type} will be used
- * (Not the same as {@link DisTubeStream#type})
- * @prop {boolean} [directLink=true] Whether or not playing a song with direct link
+ * DisTube options
  */
 type DisTubeOptions = {
+    /**
+     * DisTube plugins
+     */
     plugins?: (CustomPlugin | ExtractorPlugin)[];
+    /**
+     * Whether or not emitting {@link DisTube#playSong} event when looping a song
+     * or next song is the same as the previous one
+     */
     emitNewSongOnly?: boolean;
+    /**
+     * Whether or not leaving voice channel if the voice channel is empty after {@link
+     * DisTubeOptions}.emptyCooldown seconds
+     */
+    leaveOnEmpty?: boolean;
+    /**
+     * Whether or not leaving voice channel when the queue ends
+     */
     leaveOnFinish?: boolean;
+    /**
+     * Whether or not leaving voice channel after using {@link DisTube#stop} function
+     */
     leaveOnStop?: boolean;
-    leaveOnEmpty?: boolean;
+    /**
+     * Built-in leave on empty cooldown in seconds (When leaveOnEmpty is true)
+     */
     emptyCooldown?: number;
+    /**
+     * Whether or not saving the previous songs of the queue and enable {@link
+     * DisTube#previous} method
+     */
     savePreviousSongs?: boolean;
+    /**
+     * Limit of search results emits in {@link DisTube#searchResult} event when
+     * {@link DisTube#play} method executed. If `searchSongs <= 1`, play the first
+     * result
+     */
     searchSongs?: number;
+    /**
+     * Built-in search cooldown in seconds (When searchSongs is bigger than 0)
+     */
     searchCooldown?: number;
+    /**
+     * YouTube cookies. Guide: {@link
+     * https://distube.js.org/#/docs/DisTube/main/general/cookie | YouTube Cookies}
+     */
     youtubeCookie?: Cookie[] | string;
+    /**
+     * Override {@link defaultFilters} or add more ffmpeg filters
+     */
     customFilters?: Filters;
-    ytdlOptions?: ytdl.downloadOptions;
+    /**
+     * `ytdl-core` get info options
+     */
+    ytdlOptions?: ytdl__default.downloadOptions;
+    /**
+     * Whether or not playing age-restricted content and disabling safe search in
+     * non-NSFW channel
+     */
     nsfw?: boolean;
+    /**
+     * Whether or not emitting `addSong` event when creating a new Queue
+     */
     emitAddSongWhenCreatingQueue?: boolean;
+    /**
+     * Whether or not emitting `addList` event when creating a new Queue
+     */
     emitAddListWhenCreatingQueue?: boolean;
+    /**
+     * Whether or not joining the new voice channel when using {@link DisTube#play}
+     * method
+     */
     joinNewVoiceChannel?: boolean;
+    /**
+     * Decide the {@link DisTubeStream#type} will be used (Not the same as {@link
+     * DisTubeStream#type})
+     */
     streamType?: StreamType;
+    /**
+     * Whether or not playing a song with direct link
+     */
     directLink?: boolean;
+    /**
+     * FFmpeg path
+     */
+    ffmpegPath?: string;
+    /**
+     * FFmpeg default arguments
+     */
+    ffmpegDefaultArgs?: FFmpegOptions;
 };
 /**
  * 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 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}
- * @typedef {
- * Discord.Snowflake|
- * Discord.Guild|
- * Discord.Message|
- * Discord.BaseGuildVoiceChannel|
- * Discord.BaseGuildTextChannel|
- * Discord.VoiceState|
- * Discord.GuildMember|
- * Discord.Interaction|
- * DisTubeVoice|
- * Queue|
- * string
- * } GuildIdResolvable
  */
 type GuildIdResolvable = Queue | DisTubeVoice | Snowflake | Message | GuildTextBasedChannel | VoiceBasedChannel | VoiceState | Guild | GuildMember | Interaction | string;
 interface OtherSongInfo {
@@ -189,76 +235,80 @@ interface PlaylistInfo {
     name?: string;
     url?: string;
     thumbnail?: string;
-    /** @deprecated */
+    /**
+     * @deprecated Use {@link PlaylistInfo#name}
+     */
     title?: string;
-    /** @deprecated */
+    /**
+     * @deprecated Use {@link PlaylistInfo#url}
+     */
     webpage_url?: string;
 }
 type RelatedSong = Omit<Song, "related">;
-/**
- * @typedef {Object} PlayHandlerOptions
- * @prop {Discord.BaseGuildTextChannel} [options.textChannel] The default text channel of the queue
- * @prop {boolean} [options.skip=false] Skip the playing song (if exists) and play the added playlist instantly
- * @prop {number} [options.position=0] Position of the song/playlist to add to the queue,
- * <= 0 to add to the end of the queue.
- */
 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;
 };
-/**
- * @typedef {Object} PlayOptions
- * @prop {Discord.GuildMember} [member] Requested user (default is your bot)
- * @prop {Discord.BaseGuildTextChannel} [textChannel] Default {@link Queue#textChannel}
- * @prop {boolean} [skip=false]
- * Skip the playing song (if exists) and play the added song/playlist if `position` is 1.
- * If `position` is defined and not equal to 1, it will skip to the next song instead of the added song
- * @prop {number} [position=0] Position of the song/playlist to add to the queue,
- * <= 0 to add to the end of the queue.
- * @prop {Discord.Message} [message] Called message (For built-in search events. If this is a {@link https://developer.mozilla.org/en-US/docs/Glossary/Falsy|falsy value}, it will play the first result instead)
- * @prop {*} [metadata] Optional metadata that can be attached to the song/playlist will be played,
- * This is useful for identification purposes when the song/playlist is passed around in events.
- * See {@link Song#metadata} or {@link Playlist#metadata}
- */
 interface PlayOptions extends PlayHandlerOptions, ResolveOptions<any> {
+    /**
+     * Called message (For built-in search events. If this is a {@link
+     * https://developer.mozilla.org/en-US/docs/Glossary/Falsy | falsy value}, it will
+     * play the first result instead)
+     */
     message?: Message;
 }
-/**
- * @typedef {Object} ResolveOptions
- * @prop {Discord.GuildMember} [member] Requested user
- * @prop {*} [metadata] Metadata
- */
 interface ResolveOptions<T = unknown> {
+    /**
+     * Requested user
+     */
     member?: GuildMember;
+    /**
+     * Metadata
+     */
     metadata?: T;
 }
-/**
- * @typedef {ResolveOptions} ResolvePlaylistOptions
- * @prop {string} [source] Source of the playlist
- */
 interface ResolvePlaylistOptions<T = unknown> extends ResolveOptions<T> {
+    /**
+     * Source of the playlist
+     */
     source?: string;
 }
-/**
- * @typedef {Object} CustomPlaylistOptions
- * @prop {Discord.GuildMember} [member] A guild member creating the playlist
- * @prop {Object} [properties] Additional properties such as `name`
- * @prop {boolean} [parallel=true] Whether or not fetch the songs in parallel
- * @prop {*} [metadata] Metadata
- */
 interface CustomPlaylistOptions {
+    /**
+     * A guild member creating the playlist
+     */
     member?: GuildMember;
+    /**
+     * Additional properties such as `name`
+     */
     properties?: Record<string, any>;
+    /**
+     * Whether or not fetch the songs in parallel
+     */
     parallel?: boolean;
+    /**
+     * Metadata
+     */
     metadata?: any;
 }
 /**
  * The repeat mode of a {@link Queue}
- * * `DISABLED` = 0
- * * `SONG` = 1
- * * `QUEUE` = 2
- * @typedef {number} RepeatMode
+ *
+ * - `DISABLED` = 0
+ * - `SONG` = 1
+ * - `QUEUE` = 2
  */
 declare enum RepeatMode {
     DISABLED = 0,
@@ -267,9 +317,9 @@ declare enum RepeatMode {
 }
 /**
  * All available plugin types:
- * * `CUSTOM` = `"custom"`: {@link CustomPlugin}
- * * `EXTRACTOR` = `"extractor"`: {@link ExtractorPlugin}
- * @typedef {"custom"|"extractor"} PluginType
+ *
+ * - `CUSTOM` = `"custom"`: {@link CustomPlugin}
+ * - `EXTRACTOR` = `"extractor"`: {@link ExtractorPlugin}
  */
 declare enum PluginType {
     CUSTOM = "custom",
@@ -277,9 +327,9 @@ declare enum PluginType {
 }
 /**
  * Search result types:
- * * `VIDEO` = `"video"`
- * * `PLAYLIST` = `"playlist"`
- * @typedef {"video"|"playlist"} SearchResultType
+ *
+ * - `VIDEO` = `"video"`
+ * - `PLAYLIST` = `"playlist"`
  */
 declare enum SearchResultType {
     VIDEO = "video",
@@ -287,34 +337,14 @@ declare enum SearchResultType {
 }
 /**
  * Stream types:
- * * `OPUS` = `0` (Better quality, use more resources - **Recommended**)
- * * `RAW` = `1` (Better performance, use less resources)
- * @typedef {number} StreamType
- * @type {StreamType}
+ *
+ * - `OPUS` = `0` (Better quality, use more resources - **Recommended**)
+ * - `RAW` = `1` (Better performance, use less resources)
  */
 declare enum StreamType {
     OPUS = 0,
     RAW = 1
 }
-/**
- * @typedef {Object} Events
- * @prop {string} ERROR error
- * @prop {string} ADD_LIST addList
- * @prop {string} ADD_SONG addSong
- * @prop {string} PLAY_SONG playSong
- * @prop {string} FINISH_SONG finishSong
- * @prop {string} EMPTY empty
- * @prop {string} FINISH finish
- * @prop {string} INIT_QUEUE initQueue
- * @prop {string} NO_RELATED noRelated
- * @prop {string} DISCONNECT disconnect
- * @prop {string} DELETE_QUEUE deleteQueue
- * @prop {string} SEARCH_CANCEL searchCancel
- * @prop {string} SEARCH_NO_RESULT searchNoResult
- * @prop {string} SEARCH_DONE searchDone
- * @prop {string} SEARCH_INVALID_ANSWER searchInvalidAnswer
- * @prop {string} SEARCH_RESULT searchResult
- */
 declare enum Events {
     ERROR = "error",
     ADD_LIST = "addList",
@@ -331,46 +361,37 @@ declare enum Events {
     SEARCH_NO_RESULT = "searchNoResult",
     SEARCH_DONE = "searchDone",
     SEARCH_INVALID_ANSWER = "searchInvalidAnswer",
-    SEARCH_RESULT = "searchResult"
+    SEARCH_RESULT = "searchResult",
+    FFMPEG_DEBUG = "ffmpegDebug"
 }
+type FFmpegOptions = Record<string, string | number | boolean | Array<string | null | undefined> | null | undefined>;
 
 /**
  * Default DisTube audio filters.
- * @typedef {Object} defaultFilters
- * @prop {string} 3d 3d
- * @prop {string} bassboost bassboost
- * @prop {string} echo echo
- * @prop {string} karaoke karaoke
- * @prop {string} nightcore nightcore
- * @prop {string} vaporwave vaporwave
- * @prop {string} flanger flanger
- * @prop {string} gate gate
- * @prop {string} haas haas
- * @prop {string} reverse reverse
- * @prop {string} surround surround
- * @prop {string} mcompand mcompand
- * @prop {string} phaser phaser
- * @prop {string} tremolo tremolo
- * @prop {string} earwax earwax
  */
 declare const defaultFilters: Filters;
 declare const defaultOptions: {
     plugins: never[];
-    emitNewSongOnly: boolean;
-    leaveOnEmpty: boolean;
-    leaveOnFinish: boolean;
-    leaveOnStop: boolean;
-    savePreviousSongs: boolean;
+    emitNewSongOnly: false;
+    leaveOnEmpty: true;
+    leaveOnFinish: false;
+    leaveOnStop: true;
+    savePreviousSongs: true;
     searchSongs: number;
     ytdlOptions: {};
     searchCooldown: number;
     emptyCooldown: number;
-    nsfw: boolean;
-    emitAddSongWhenCreatingQueue: boolean;
-    emitAddListWhenCreatingQueue: boolean;
-    joinNewVoiceChannel: boolean;
-    streamType: StreamType;
-    directLink: boolean;
+    nsfw: false;
+    emitAddSongWhenCreatingQueue: true;
+    emitAddListWhenCreatingQueue: true;
+    joinNewVoiceChannel: true;
+    streamType: StreamType.OPUS;
+    directLink: true;
+    ffmpegPath: string;
+    ffmpegDefaultArgs: {
+        analyzeduration: number;
+        hide_banner: true;
+    };
 };
 
 declare const ERROR_MESSAGES: {
@@ -430,14 +451,13 @@ declare class DisTubeError<T extends string> extends Error {
 
 /**
  * Task queuing system
- * @private
  */
 declare class TaskQueue {
     #private;
     /**
      * Waits for last task finished and queues a new task
-     * @param {boolean} [resolveInfo=false] Whether the task is a resolving info task
-     * @returns {Promise<void>}
+     *
+     * @param resolveInfo - Whether the task is a resolving info task
      */
     queuing(resolveInfo?: boolean): Promise<void>;
     /**
@@ -446,20 +466,16 @@ declare class TaskQueue {
     resolve(): void;
     /**
      * The remaining number of tasks
-     * @type {number}
      */
     get remaining(): number;
     /**
      * Whether or not having a resolving info task
-     * @type {boolean}
      */
     get hasResolveTask(): boolean;
 }
 
 /**
  * Class representing a playlist.
- * @prop {string} source Playlist source
- * @template T - The type for the metadata (if any) of the playlist
  */
 declare class Playlist<T = unknown> implements PlaylistInfo {
     #private;
@@ -471,11 +487,9 @@ declare class Playlist<T = unknown> implements PlaylistInfo {
     [x: string]: any;
     /**
      * Create a playlist
-     * @param {Song[]|PlaylistInfo} playlist Playlist
-     * @param {Object} [options] Optional options
-     * @param {Discord.GuildMember} [options.member] Requested user
-     * @param {Object} [options.properties] Custom properties
-     * @param {T} [options.metadata] Playlist metadata
+     *
+     * @param playlist           - Playlist
+     * @param options            - Optional options
      */
     constructor(playlist: Song[] | PlaylistInfo, options?: {
         member?: GuildMember;
@@ -484,23 +498,19 @@ declare class Playlist<T = unknown> implements PlaylistInfo {
     });
     /**
      * Playlist duration in second.
-     * @type {number}
      */
     get duration(): number;
     /**
      * Formatted duration string `hh:mm:ss`.
-     * @type {string}
      */
     get formattedDuration(): string;
     /**
      * User requested.
-     * @type {Discord.GuildMember?}
      */
     get member(): GuildMember | undefined;
     set member(member: GuildMember | undefined);
     /**
      * User requested.
-     * @type {Discord.User?}
      */
     get user(): discord_js.User | undefined;
     get metadata(): T;
@@ -509,8 +519,8 @@ declare class Playlist<T = unknown> implements PlaylistInfo {
 
 /**
  * A abstract class representing a search result.
- * @abstract
- * @private
+ *
+ * @virtual
  */
 declare abstract class ISearchResult {
     source: "youtube";
@@ -524,13 +534,13 @@ declare abstract class ISearchResult {
     };
     /**
      * Create a search result
-     * @param {Object} info ytsr result
+     *
+     * @param info - ytsr result
      */
     constructor(info: Video | Playlist$1);
 }
 /**
  * A class representing a video search result.
- * @extends ISearchResult
  */
 declare class SearchResultVideo extends ISearchResult {
     type: SearchResultType.VIDEO;
@@ -543,12 +553,10 @@ declare class SearchResultVideo extends ISearchResult {
 }
 /**
  * A video or playlist search result
- * @typedef {SearchResultVideo|SearchResultPlaylist} SearchResult
  */
 type SearchResult = SearchResultVideo | SearchResultPlaylist;
 /**
  * A class representing a playlist search result.
- * @extends ISearchResult
  */
 declare class SearchResultPlaylist extends ISearchResult {
     type: SearchResultType.PLAYLIST;
@@ -559,17 +567,17 @@ declare class SearchResultPlaylist extends ISearchResult {
 /**
  * Class representing a song.
  *
- * <info>If {@link Song} is added from a YouTube {@link SearchResult} or {@link Playlist},
- * some info will be missing to save your resources. It will be filled when emitting {@link DisTube#playSong} event.
+ * <info>If {@link Song} is added from a YouTube {@link SearchResult} or {@link
+ * Playlist}, some info will be missing to save your resources. It will be filled
+ * when emitting {@link DisTube#playSong} event.
  *
  * Missing info: {@link Song#likes}, {@link Song#dislikes}, {@link Song#streamURL},
  * {@link Song#related}, {@link Song#chapters}, {@link Song#age_restricted}</info>
- * @template T - The type for the metadata (if any) of the song
  */
 declare class Song<T = unknown> {
     #private;
     source: string;
-    formats?: ytdl.videoFormat[];
+    formats?: ytdl__default.videoFormat[];
     id?: string;
     name?: string;
     isLive: boolean;
@@ -591,39 +599,34 @@ declare class Song<T = unknown> {
     reposts: number;
     /**
      * Create a Song
-     * @param {ytdl.videoInfo|SearchResult|OtherSongInfo} info Raw info
-     * @param {Object} [options] Optional options
-     * @param {Discord.GuildMember} [options.member] Requested user
-     * @param {string} [options.source="youtube"] Song source
-     * @param {T} [options.metadata] Song metadata
+     *
+     * @param info             - Raw info
+     * @param options          - Optional options
      */
-    constructor(info: ytdl.videoInfo | SearchResult | OtherSongInfo | ytdl.relatedVideo | RelatedSong | ytpl.result["items"][number], options?: {
+    constructor(info: ytdl__default.videoInfo | SearchResult | OtherSongInfo | ytdl__default.relatedVideo | RelatedSong | ytpl.result["items"][number], options?: {
         member?: GuildMember;
         source?: string;
         metadata?: T;
     });
-    _patchYouTube(i: ytdl.videoInfo | SearchResult): void;
+    _patchYouTube(i: ytdl__default.videoInfo | SearchResult): void;
     /**
      * Patch data from other source
-     * @param {OtherSongInfo} info Video info
-     * @private
+     *
+     * @param info - Video info
      */
     _patchOther(info: OtherSongInfo): void;
     /**
      * The playlist added this song
-     * @type {Playlist?}
      */
     get playlist(): Playlist | undefined;
     set playlist(playlist: Playlist | undefined);
     /**
      * User requested.
-     * @type {Discord.GuildMember?}
      */
     get member(): GuildMember | undefined;
     set member(member: GuildMember | undefined);
     /**
      * User requested.
-     * @type {Discord.User?}
      */
     get user(): discord_js.User | undefined;
     get metadata(): T;
@@ -631,53 +634,43 @@ declare class Song<T = unknown> {
 }
 
 /**
- * @private
- * @abstract
+ * @virtual
  */
 declare abstract class DisTubeBase {
     distube: DisTube;
     constructor(distube: DisTube);
     /**
      * Emit the {@link DisTube} of this base
-     * @param {string} eventName Event name
-     * @param {...any} args arguments
-     * @returns {boolean}
+     *
+     * @param eventName - Event name
+     * @param args      - arguments
      */
     emit(eventName: keyof DisTubeEvents, ...args: any): boolean;
     /**
      * Emit error event
-     * @param {Error} error error
-     * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
+     *
+     * @param error   - error
+     * @param channel - Text channel where the error is encountered.
      */
     emitError(error: Error, channel?: GuildTextBasedChannel): void;
     /**
      * The queue manager
-     * @type {QueueManager}
-     * @readonly
      */
     get queues(): QueueManager;
     /**
      * The voice manager
-     * @type {DisTubeVoiceManager}
-     * @readonly
      */
     get voices(): DisTubeVoiceManager;
     /**
      * Discord.js client
-     * @type {Discord.Client}
-     * @readonly
      */
     get client(): Client;
     /**
      * DisTube options
-     * @type {DisTubeOptions}
-     * @readonly
      */
     get options(): Options;
     /**
      * DisTube handler
-     * @type {DisTubeHandler}
-     * @readonly
      */
     get handler(): DisTubeHandler;
 }
@@ -694,182 +687,194 @@ declare class DisTubeVoice extends TypedEmitter<DisTubeVoiceEvents> {
     audioResource?: AudioResource;
     emittedError: boolean;
     isDisconnected: boolean;
+    stream?: DisTubeStream;
     constructor(voiceManager: DisTubeVoiceManager, channel: VoiceBasedChannel);
     /**
      * The voice channel id the bot is in
-     * @type {Snowflake?}
      */
     get channelId(): string | undefined;
     get channel(): VoiceBasedChannel;
     set channel(channel: VoiceBasedChannel);
     /**
      * Join a voice channel with this connection
-     * @param {Discord.BaseGuildVoiceChannel} [channel] A voice channel
-     * @returns {Promise<DisTubeVoice>}
+     *
+     * @param channel - A voice channel
      */
     join(channel?: VoiceBasedChannel): Promise<DisTubeVoice>;
     /**
      * Leave the voice channel of this connection
-     * @param {Error} [error] Optional, an error to emit with 'error' event.
+     *
+     * @param error - Optional, an error to emit with 'error' event.
      */
     leave(error?: Error): void;
     /**
      * Stop the playing stream
-     * @param {boolean} [force=false] If true, will force the {@link DisTubeVoice#audioPlayer} to enter the Idle state
-     * even if the {@link DisTubeVoice#audioResource} has silence padding frames.
-     * @private
+     *
+     * @param force - If true, will force the {@link DisTubeVoice#audioPlayer} to enter the Idle state even
+     *                if the {@link DisTubeVoice#audioResource} has silence padding frames.
      */
     stop(force?: boolean): void;
     /**
-     * Play a readable stream
-     * @private
-     * @param {DisTubeStream} stream Readable stream
+     * Play a {@link DisTubeStream}
+     *
+     * @param dtStream - DisTubeStream
      */
-    play(stream: DisTubeStream): void;
+    play(dtStream: DisTubeStream): void;
     set volume(volume: number);
     get volume(): number;
     /**
      * Playback duration of the audio resource in seconds
-     * @type {number}
      */
     get playbackDuration(): number;
     pause(): void;
     unpause(): void;
     /**
      * Whether the bot is self-deafened
-     * @type {boolean}
      */
     get selfDeaf(): boolean;
     /**
      * Whether the bot is self-muted
-     * @type {boolean}
      */
     get selfMute(): boolean;
     /**
      * Self-deafens/undeafens the bot.
-     * @param {boolean} selfDeaf Whether or not the bot should be self-deafened
-     * @returns {boolean} true if the voice state was successfully updated, otherwise false
+     *
+     * @param selfDeaf - Whether or not the bot should be self-deafened
+     *
+     * @returns true if the voice state was successfully updated, otherwise false
      */
     setSelfDeaf(selfDeaf: boolean): boolean;
     /**
      * Self-mutes/unmutes the bot.
-     * @param {boolean} selfMute Whether or not the bot should be self-muted
-     * @returns {boolean} true if the voice state was successfully updated, otherwise false
+     *
+     * @param selfMute - Whether or not the bot should be self-muted
+     *
+     * @returns true if the voice state was successfully updated, otherwise false
      */
     setSelfMute(selfMute: boolean): boolean;
     /**
      * The voice state of this connection
-     * @type {Discord.VoiceState?}
      */
     get voiceState(): VoiceState | undefined;
 }
 
 interface StreamOptions {
+    ffmpeg: {
+        path: string;
+        args: FFmpegOptions;
+    };
     seek?: number;
-    ffmpegArgs?: string[];
-    isLive?: boolean;
     type?: StreamType;
 }
-declare const chooseBestVideoFormat: (formats: ytdl.videoFormat[], isLive?: boolean) => ytdl.videoFormat;
+declare const chooseBestVideoFormat: ({ duration, formats, isLive }: Song) => ytdl.videoFormat | undefined;
 /**
  * Create a stream to play with {@link DisTubeVoice}
- * @private
  */
-declare class DisTubeStream {
+declare class DisTubeStream extends TypedEmitter<{
+    debug: (debug: string) => Awaitable;
+}> {
+    private killed;
+    process: ChildProcess;
+    stream: PassThrough;
+    type: StreamType$1;
+    url: string;
     /**
-     * Create a stream from ytdl video formats
-     * @param {ytdl.videoFormat[]} formats ytdl video formats
-     * @param {StreamOptions} options options
-     * @returns {DisTubeStream}
-     * @private
+     * Create a DisTubeStream to play with {@link DisTubeVoice}
+     *
+     * @param url     - Stream URL
+     * @param options - Stream options
      */
-    static YouTube(formats: ytdl.videoFormat[] | undefined, options?: StreamOptions): DisTubeStream;
+    constructor(url: string, { ffmpeg, seek, type }: StreamOptions);
+    private debug;
+    kill(): void;
     /**
-     * Create a stream from a stream url
-     * @param {string} url stream url
-     * @param {StreamOptions} options options
-     * @returns {DisTubeStream}
-     * @private
+     * Create a stream from a YouTube {@link Song}
+     *
+     * @param song    - A YouTube Song
+     * @param options - options
      */
-    static DirectLink(url: string, options?: StreamOptions): DisTubeStream;
-    type: StreamType$1;
-    stream: FFmpeg;
-    url: string;
+    static YouTube(song: Song, options: StreamOptions): DisTubeStream;
     /**
-     * Create a DisTubeStream to play with {@link DisTubeVoice}
-     * @param {string} url Stream URL
-     * @param {StreamOptions} options Stream options
-     * @private
+     * Create a stream from a stream url
+     *
+     * @param url     - stream url
+     * @param options - options
      */
-    constructor(url: string, options: StreamOptions);
+    static DirectLink(url: string, options: StreamOptions): DisTubeStream;
 }
 
 /**
  * DisTube's Handler
- * @extends DisTubeBase
- * @private
  */
 declare class DisTubeHandler extends DisTubeBase {
     #private;
     constructor(distube: DisTube);
-    get ytdlOptions(): ytdl.getInfoOptions;
+    get ytdlOptions(): ytdl__default.getInfoOptions;
     get ytCookie(): string;
     /**
-     * @param {string} url url
-     * @param {boolean} [basic=false] getBasicInfo?
-     * @returns {Promise<ytdl.videoInfo>}
+     * @param url   - url
+     * @param basic - getBasicInfo?
      */
-    getYouTubeInfo(url: string, basic?: boolean): Promise<ytdl.videoInfo>;
+    getYouTubeInfo(url: string, basic?: boolean): Promise<ytdl__default.videoInfo>;
     resolve<T = unknown>(song: Song<T>, options?: Omit<ResolveOptions, "metadata">): Promise<Song<T>>;
     resolve<T = unknown>(song: Playlist<T>, options?: Omit<ResolveOptions, "metadata">): Promise<Playlist<T>>;
     resolve<T = unknown>(song: string | SearchResult, options?: ResolveOptions<T>): Promise<Song<T> | Playlist<T>>;
-    resolve<T = unknown>(song: ytdl.videoInfo | OtherSongInfo | ytdl.relatedVideo, options?: ResolveOptions<T>): Promise<Song<T>>;
+    resolve<T = unknown>(song: ytdl__default.videoInfo | OtherSongInfo | ytdl__default.relatedVideo, options?: ResolveOptions<T>): Promise<Song<T>>;
     resolve<T = unknown>(song: Playlist, options: ResolveOptions<T>): Promise<Playlist<T>>;
-    resolve(song: string | ytdl.videoInfo | Song | Playlist | SearchResult | OtherSongInfo | ytdl.relatedVideo, options?: ResolveOptions): Promise<Song | Playlist>;
+    resolve(song: string | ytdl__default.videoInfo | Song | Playlist | SearchResult | OtherSongInfo | ytdl__default.relatedVideo, options?: ResolveOptions): Promise<Song | Playlist>;
     resolvePlaylist<T = unknown>(playlist: Playlist<T> | Song<T>[] | string, options?: Omit<ResolvePlaylistOptions, "metadata">): Promise<Playlist<T>>;
     resolvePlaylist<T = undefined>(playlist: Playlist | Song[] | string, options: ResolvePlaylistOptions<T>): Promise<Playlist<T>>;
     resolvePlaylist(playlist: Playlist | Song[] | string, options?: ResolvePlaylistOptions): Promise<Playlist>;
     /**
-     * Search for a song, fire {@link DisTube#event:error} if not found.
-     * @param {Discord.Message} message The original message from an user
-     * @param {string} query The query string
-     * @returns {Promise<SearchResult?>} Song info
-     * @throws {DisTubeError}
+     * Search for a song, fire {@link DisTube#error} if not found.
+     *
+     * @throws {@link DisTubeError}
+     *
+     * @param message - The original message from an user
+     * @param query   - The query string
+     *
+     * @returns Song info
      */
     searchSong(message: Message<true>, query: string): Promise<SearchResult | null>;
     /**
      * Create a message collector for selecting search results.
      *
-     * Needed events: {@link DisTube#event:searchResult}, {@link DisTube#event:searchCancel},
-     * {@link DisTube#event:searchInvalidAnswer}, {@link DisTube#event:searchDone}.
-     * @param {Discord.Message} message The original message from an user
-     * @param {Array<SearchResult|Song|Playlist>} results The search results
-     * @param {string?} [query] The query string
-     * @returns {Promise<SearchResult|Song|Playlist|null>} Selected result
-     * @throws {DisTubeError}
+     * Needed events: {@link DisTube#searchResult}, {@link DisTube#searchCancel},
+     * {@link DisTube#searchInvalidAnswer}, {@link DisTube#searchDone}.
+     *
+     * @throws {@link DisTubeError}
+     *
+     * @param message - The original message from an user
+     * @param results - The search results
+     * @param query   - The query string
+     *
+     * @returns Selected result
      */
     createSearchMessageCollector<R extends SearchResult | Song | Playlist>(message: Message<true>, results: Array<R>, query?: string): Promise<R | null>;
     /**
      * Play or add a {@link Playlist} to the queue.
-     * @param {Discord.BaseGuildVoiceChannel} voiceChannel A voice channel
-     * @param {Playlist|string} playlist A YouTube playlist url | a Playlist
-     * @param {PlayHandlerOptions} [options] Optional options
-     * @returns {Promise<void>}
-     * @throws {DisTubeError}
+     *
+     * @throws {@link DisTubeError}
+     *
+     * @param voiceChannel - A voice channel
+     * @param playlist     - A YouTube playlist url | a Playlist
+     * @param options      - Optional options
      */
     playPlaylist(voiceChannel: VoiceBasedChannel, playlist: Playlist, options?: PlayHandlerOptions): Promise<void>;
     /**
      * Play or add a {@link Song} to the queue.
-     * @param {Discord.BaseGuildVoiceChannel} voiceChannel A voice channel
-     * @param {Song} song A YouTube playlist url | a Playlist
-     * @param {PlayHandlerOptions} [options] Optional options
-     * @returns {Promise<void>}
-     * @throws {DisTubeError}
+     *
+     * @throws {@link DisTubeError}
+     *
+     * @param voiceChannel - A voice channel
+     * @param song         - A YouTube playlist url | a Playlist
+     * @param options      - Optional options
      */
     playSong(voiceChannel: VoiceBasedChannel, song: Song, options?: PlayHandlerOptions): Promise<void>;
     /**
      * Get {@link Song}'s stream info and attach it to the song.
-     * @param {Song} song A Song
+     *
+     * @param song - A Song
      */
     attachStreamInfo(song: Song): Promise<void>;
 }
@@ -887,44 +892,41 @@ declare class Options {
     searchCooldown: number;
     youtubeCookie?: Cookie[] | string;
     customFilters?: Filters;
-    ytdlOptions: ytdl.getInfoOptions;
+    ytdlOptions: ytdl__default.getInfoOptions;
     nsfw: boolean;
     emitAddSongWhenCreatingQueue: boolean;
     emitAddListWhenCreatingQueue: boolean;
     joinNewVoiceChannel: boolean;
     streamType: StreamType;
     directLink: boolean;
+    ffmpegPath: string;
+    ffmpegDefaultArgs: FFmpegOptions;
     constructor(options: DisTubeOptions);
 }
 
 /**
  * Manages the collection of a data model.
- * @abstract
- * @private
- * @extends DisTubeBase
+ *
+ * @virtual
  */
 declare abstract class BaseManager<V> extends DisTubeBase {
     /**
      * The collection of items for this manager.
-     * @type {Collection}
-     * @name BaseManager#collection
      */
     collection: Collection<string, V>;
     /**
      * The size of the collection.
-     * @type {number}
      */
     get size(): number;
 }
 
 /**
  * Manages the collection of a data model paired with a guild id.
- * @abstract
- * @private
- * @extends BaseManager
+ *
+ * @virtual
  */
 declare abstract class GuildIdManager<V> extends BaseManager<V> {
-    add(idOrInstance: GuildIdResolvable, data: V): this | _discordjs_collection.Collection<string, V>;
+    add(idOrInstance: GuildIdResolvable, data: V): this;
     get(idOrInstance: GuildIdResolvable): V | undefined;
     remove(idOrInstance: GuildIdResolvable): boolean;
     has(idOrInstance: GuildIdResolvable): boolean;
@@ -932,138 +934,123 @@ declare abstract class GuildIdManager<V> extends BaseManager<V> {
 
 /**
  * Manages voice connections for {@link DisTube}
- * @extends BaseManager
  */
 declare class DisTubeVoiceManager extends GuildIdManager<DisTubeVoice> {
     /**
      * Get a {@link DisTubeVoice}.
-     * @method get
-     * @memberof DisTubeVoiceManager#
-     * @param {GuildIdResolvable} guild The queue resolvable to resolve
-     * @returns {DisTubeVoice?}
+     *
+     * @param guild - The queue resolvable to resolve
      */
     /**
      * Collection of {@link DisTubeVoice}.
-     * @name DisTubeVoiceManager#collection
-     * @type {Discord.Collection<string, DisTubeVoice>}
      */
     /**
      * Create a {@link DisTubeVoice}
-     * @param {Discord.BaseGuildVoiceChannel} channel A voice channel to join
-     * @returns {DisTubeVoice}
-     * @private
+     *
+     * @param channel - A voice channel to join
      */
     create(channel: VoiceBasedChannel): DisTubeVoice;
     /**
      * Join a voice channel
-     * @param {Discord.BaseGuildVoiceChannel} channel A voice channel to join
-     * @returns {Promise<DisTubeVoice>}
+     *
+     * @param channel - A voice channel to join
      */
     join(channel: VoiceBasedChannel): Promise<DisTubeVoice>;
     /**
      * Leave the connected voice channel in a guild
-     * @param {GuildIdResolvable} guild Queue Resolvable
+     *
+     * @param guild - Queue Resolvable
      */
     leave(guild: GuildIdResolvable): void;
 }
 
 /**
  * Manage filters of a playing {@link Queue}
- * @extends {BaseManager}
  */
 declare class FilterManager extends BaseManager<Filter> {
     #private;
     /**
      * Collection of {@link Filter}.
-     * @name FilterManager#collection
-     * @type {Discord.Collection<string, DisTubeVoice>}
      */
     queue: Queue;
     constructor(queue: Queue);
     /**
      * Enable a filter or multiple filters to the manager
-     * @param {FilterResolvable|FilterResolvable[]} filterOrFilters The filter or filters to enable
-     * @param {boolean} [override=false] Wether or not override the applied filter with new filter value
-     * @returns {FilterManager}
+     *
+     * @param filterOrFilters - The filter or filters to enable
+     * @param override        - Wether or not override the applied filter with new filter value
      */
     add(filterOrFilters: FilterResolvable | FilterResolvable[], override?: boolean): this;
     /**
      * Clear enabled filters of the manager
-     * @returns {FilterManager}
      */
     clear(): this;
     /**
      * Set the filters applied to the manager
-     * @param {FilterResolvable[]} filters The filters to apply
-     * @returns {FilterManager}
+     *
+     * @param filters - The filters to apply
      */
     set(filters: FilterResolvable[]): this;
     /**
      * Disable a filter or multiple filters
-     * @param {FilterResolvable|FilterResolvable[]} filterOrFilters The filter or filters to disable
-     * @returns {FilterManager}
+     *
+     * @param filterOrFilters - The filter or filters to disable
      */
     remove(filterOrFilters: FilterResolvable | FilterResolvable[]): this;
     /**
      * Check whether a filter enabled or not
-     * @param {FilterResolvable} filter The filter to check
-     * @returns {boolean}
+     *
+     * @param filter - The filter to check
      */
     has(filter: FilterResolvable): boolean;
     /**
      * Array of enabled filter names
-     * @type {Array<string>}
-     * @readonly
      */
     get names(): string[];
     /**
      * Array of enabled filters
-     * @type {Array<Filter>}
-     * @readonly
      */
     get values(): Filter[];
-    get ffmpegArgs(): string[];
+    get ffmpegArgs(): FFmpegOptions;
     toString(): string;
 }
 
 /**
  * Queue manager
- * @extends GuildIdManager
  */
 declare class QueueManager extends GuildIdManager<Queue> {
     #private;
     /**
      * Collection of {@link Queue}.
-     * @name QueueManager#collection
-     * @type {Discord.Collection<string, Queue>}
      */
     /**
      * Create a {@link Queue}
-     * @private
-     * @param {Discord.BaseGuildVoiceChannel} channel A voice channel
-     * @param {Song|Song[]} song First song
-     * @param {Discord.BaseGuildTextChannel} textChannel Default text channel
-     * @returns {Promise<Queue|true>} Returns `true` if encounter an error
+     *
+     * @param channel     - A voice channel
+     * @param song        - First song
+     * @param textChannel - Default text channel
+     *
+     * @returns Returns `true` if encounter an error
      */
     create(channel: VoiceBasedChannel, song: Song[] | Song, textChannel?: GuildTextBasedChannel): Promise<Queue | true>;
     /**
      * Create a ytdl stream
-     * @param {Queue} queue Queue
-     * @returns {DisTubeStream}
+     *
+     * @param queue - Queue
      */
     createStream(queue: Queue): DisTubeStream;
     /**
      * Play a song on voice connection
-     * @private
-     * @param {Queue} queue The guild queue
-     * @returns {Promise<boolean>} error?
+     *
+     * @param queue - The guild queue
+     *
+     * @returns error?
      */
     playSong(queue: Queue): Promise<boolean>;
 }
 
 /**
  * Represents a queue.
- * @extends DisTubeBase
  */
 declare class Queue extends DisTubeBase {
     #private;
@@ -1085,125 +1072,123 @@ declare class Queue extends DisTubeBase {
     _listeners?: DisTubeVoiceEvents;
     /**
      * Create a queue for the guild
-     * @param {DisTube} distube DisTube
-     * @param {DisTubeVoice} voice Voice connection
-     * @param {Song|Song[]} song First song(s)
-     * @param {Discord.BaseGuildTextChannel?} textChannel Default text channel
+     *
+     * @param distube     - DisTube
+     * @param voice       - Voice connection
+     * @param song        - First song(s)
+     * @param textChannel - Default text channel
      */
     constructor(distube: DisTube, voice: DisTubeVoice, song: Song | Song[], textChannel?: GuildTextBasedChannel);
     /**
      * The client user as a `GuildMember` of this queue's guild
-     * @type {Discord.GuildMember?}
      */
     get clientMember(): discord_js.GuildMember | undefined;
     /**
      * The filter manager of the queue
-     * @type {FilterManager}
-     * @readonly
      */
     get filters(): FilterManager;
     /**
      * Formatted duration string.
-     * @type {string}
-     * @readonly
      */
     get formattedDuration(): string;
     /**
      * Queue's duration.
-     * @type {number}
-     * @readonly
      */
     get duration(): number;
     /**
      * What time in the song is playing (in seconds).
-     * @type {number}
-     * @readonly
      */
     get currentTime(): number;
     /**
      * Formatted {@link Queue#currentTime} string.
-     * @type {string}
-     * @readonly
      */
     get formattedCurrentTime(): string;
     /**
      * The voice channel playing in.
-     * @type {Discord.VoiceChannel|Discord.StageChannel|null}
-     * @readonly
      */
     get voiceChannel(): discord_js.VoiceBasedChannel | null;
     get volume(): number;
     set volume(value: number);
     /**
-     * @private
-     * Add a Song or an array of Song to the queue
-     * @param {Song|Song[]} song Song to add
-     * @param {number} [position=0] Position to add, <= 0 to add to the end of the queue
-     * @throws {Error}
-     * @returns {Queue} The guild 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
      */
     addToQueue(song: Song | Song[], position?: number): Queue;
     /**
      * Pause the guild stream
-     * @returns {Queue} The guild queue
+     *
+     * @returns The guild queue
      */
     pause(): Queue;
     /**
      * Resume the guild stream
-     * @returns {Queue} The guild queue
+     *
+     * @returns The guild queue
      */
     resume(): Queue;
     /**
      * Set the guild stream's volume
-     * @param {number} percent The percentage of volume you want to set
-     * @returns {Queue} The guild queue
+     *
+     * @param percent - The percentage of volume you want to set
+     *
+     * @returns The guild queue
      */
     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>
-     * @returns {Promise<Song>} The song will skip to
-     * @throws {Error}
+     * 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>
+     *
+     * @returns The song will skip to
      */
     skip(): Promise<Song>;
     /**
      * Play the previous song if exists
-     * @returns {Promise<Song>} The guild queue
-     * @throws {Error}
+     *
+     * @returns The guild queue
      */
     previous(): Promise<Song>;
     /**
      * Shuffle the queue's songs
-     * @returns {Promise<Queue>} The guild queue
+     *
+     * @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,...
-     * @param {number} position The song position to play
-     * @returns {Promise<Song>} The new Song will be played
-     * @throws {Error} if `num` is invalid number
+     * 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
+     *
+     * @returns The new Song will be played
      */
     jump(position: number): Promise<Song>;
     /**
-     * Set the repeat mode of the guild queue.\
+     * Set the repeat mode of the guild queue.
      * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
-     * @param {RepeatMode?} [mode] The repeat modes (toggle if `undefined`)
-     * @returns {RepeatMode} The new repeat mode
+     *
+     * @param mode - The repeat modes (toggle if `undefined`)
+     *
+     * @returns The new repeat mode
      */
     setRepeatMode(mode?: RepeatMode): RepeatMode;
     /**
      * Set the playing time to another position
-     * @param {number} time Time in seconds
-     * @returns {Queue} The guild queue
+     *
+     * @param time - Time in seconds
+     *
+     * @returns The guild queue
      */
     seek(time: number): Queue;
     /**
      * Add a related song of the playing song to the queue
-     * @returns {Promise<Song>} The added song
-     * @throws {Error}
+     *
+     * @returns The added song
      */
     addRelatedSong(): Promise<Song>;
     /**
@@ -1211,22 +1196,22 @@ declare class Queue extends DisTubeBase {
      */
     stop(): Promise<void>;
     /**
-     * Remove the queue from the manager
-     * (This does not leave the voice channel even if {@link DisTubeOptions|DisTubeOptions.leaveOnStop} is enabled)
-     * @private
+     * Remove the queue from the manager (This does not leave the voice channel even if
+     * {@link DisTubeOptions | DisTubeOptions.leaveOnStop} is enabled)
      */
     remove(): void;
     /**
      * Toggle autoplay mode
-     * @returns {boolean} Autoplay mode state
+     *
+     * @returns Autoplay mode state
      */
     toggleAutoplay(): boolean;
 }
 
 /**
  * DisTube Plugin
- * @abstract
- * @private
+ *
+ * @virtual
  */
 declare abstract class Plugin {
     abstract type: PluginType;
@@ -1234,78 +1219,68 @@ declare abstract class Plugin {
     init(distube: DisTube): void;
     /**
      * Type of the plugin
-     * @name Plugin#type
-     * @type {PluginType}
      */
     /**
      * Emit an event to the {@link DisTube} class
-     * @param {string} eventName Event name
-     * @param {...any} args arguments
-     * @returns {boolean}
+     *
+     * @param eventName - Event name
+     * @param args      - arguments
      */
     emit(eventName: keyof DisTubeEvents, ...args: any): boolean;
     /**
      * Emit error event to the {@link DisTube} class
-     * @param {Error} error error
-     * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
+     *
+     * @param error   - error
+     * @param channel - Text channel where the error is encountered.
      */
     emitError(error: Error, channel?: GuildTextBasedChannel): void;
     /**
      * The queue manager
-     * @type {QueueManager}
-     * @readonly
      */
     get queues(): QueueManager;
     /**
      * The voice manager
-     * @type {DisTubeVoiceManager}
-     * @readonly
      */
     get voices(): DisTubeVoiceManager;
     /**
      * Discord.js client
-     * @type {Discord.Client}
-     * @readonly
      */
     get client(): Client;
     /**
      * DisTube options
-     * @type {DisTubeOptions}
-     * @readonly
      */
     get options(): Options;
     /**
      * DisTube handler
-     * @type {DisTubeHandler}
-     * @readonly
      */
     get handler(): DisTubeHandler;
     /**
      * Check if the string is working with this plugin
-     * @param {string} _string Input string
-     * @returns {boolean|Promise<boolean>}
+     *
+     * @param _string - Input string
      */
     validate(_string: string): Awaitable<boolean>;
     /**
      * Get the stream url from {@link Song#url}. Returns {@link Song#url} by default.
      * Not needed if the plugin plays song from YouTube.
-     * @param {string} url Input url
-     * @returns {string|Promise<string>}
+     *
+     * @param url - Input url
      */
     getStreamURL(url: string): Awaitable<string>;
     /**
-     * Get related songs from a supported url. {@link Song#member} should be `undefined`.
-     * Not needed to add {@link Song#related} because it will be added with this function later.
-     * @param {string} _url Input url
-     * @returns {Song[]|Promise<Song[]>}
+     * Get related songs from a supported url. {@link Song#member} should be
+     * `undefined`. Not needed to add {@link Song#related} because it will be added
+     * with this function later.
+     *
+     * @param _url - Input url
      */
     getRelatedSongs(_url: string): Awaitable<RelatedSong[]>;
 }
 
 /**
  * Custom Plugin
- * @extends Plugin
- * @abstract
+ *
+ * @virtual
  */
 declare abstract class CustomPlugin extends Plugin {
     readonly type = PluginType.CUSTOM;
@@ -1314,8 +1289,8 @@ declare abstract class CustomPlugin extends Plugin {
 
 /**
  * Extractor Plugin
- * @extends Plugin
- * @abstract
+ *
+ * @virtual
  */
 declare abstract class ExtractorPlugin extends Plugin {
     readonly type = PluginType.EXTRACTOR;
@@ -1327,38 +1302,39 @@ declare abstract class ExtractorPlugin extends Plugin {
 
 /**
  * Format duration to string
- * @param {number} sec Duration in seconds
- * @returns {string}
+ *
+ * @param sec - Duration in seconds
  */
 declare function formatDuration(sec: number): string;
 /**
  * Convert formatted duration to seconds
- * @param {*} input Formatted duration string
- * @returns {number}
+ *
+ * @param input - Formatted duration string
  */
 declare function toSecond(input: any): number;
 /**
  * Parse number from input
- * @param {*} input Any
- * @returns {number}
+ *
+ * @param input - Any
  */
 declare function parseNumber(input: any): number;
 declare const SUPPORTED_PROTOCOL: readonly ["https:", "http:", "file:"];
 /**
  * Check if the string is an URL
- * @param {string} input input
- * @returns {boolean}
+ *
+ * @param input - input
  */
 declare function isURL(input: any): input is `${(typeof SUPPORTED_PROTOCOL)[number]}//${string}`;
 /**
  * Check if the Client has enough intents to using DisTube
- * @param {ClientOptions} options options
+ *
+ * @param options - options
  */
 declare function checkIntents(options: ClientOptions): void;
 /**
  * Check if the voice channel is empty
- * @param {Discord.VoiceState} voiceState voiceState
- * @returns {boolean}
+ *
+ * @param voiceState - voiceState
  */
 declare function isVoiceChannelEmpty(voiceState: VoiceState): boolean;
 declare function isSnowflake(id: any): id is Snowflake;
@@ -1387,9 +1363,246 @@ declare class DirectLinkPlugin extends ExtractorPlugin {
 }
 
 declare const version: string;
+interface DisTube extends TypedEmitter<TypedDisTubeEvents> {
+    /**
+     * @event
+     * Emitted after DisTube add a new playlist to the playing {@link Queue}.
+     *
+     * @example
+     * ```ts
+     * distube.on("addList", (queue, playlist) => queue.textChannel.send(
+     *     `Added \`${playlist.name}\` playlist (${playlist.songs.length} songs) to the queue!`
+     * ));
+     * ```
+     *
+     * @param queue    - The guild queue
+     * @param playlist - Playlist info
+     */
+    [Events.ADD_LIST]: (queue: Queue, playlist: Playlist) => Awaitable;
+    /**
+     * @event
+     * Emitted after DisTube add a new song to the playing {@link Queue}.
+     *
+     * @example
+     * ```ts
+     * distube.on("addSong", (queue, song) => queue.textChannel.send(
+     *     `Added ${song.name} - \`${song.formattedDuration}\` to the queue by ${song.user}.`
+     * ));
+     * ```
+     *
+     * @param queue - The guild queue
+     * @param song  - Added song
+     */
+    [Events.ADD_SONG]: (queue: Queue, song: Song) => Awaitable;
+    /**
+     * @event
+     * Emitted when a {@link Queue} is deleted with any reasons.
+     *
+     * @param queue - The guild queue
+     */
+    [Events.DELETE_QUEUE]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when the bot is disconnected to a voice channel.
+     *
+     * @param queue - The guild queue
+     */
+    [Events.DISCONNECT]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when there is no user in the voice channel, {@link DisTubeOptions}.leaveOnEmpty
+     * is `true` and there is a playing queue.
+     *
+     * If there is no playing queue (stopped and {@link DisTubeOptions}.leaveOnStop is
+     * `false`), it will leave the channel without emitting this event.
+     *
+     * @example
+     * ```ts
+     * distube.on("empty", queue => queue.textChannel.send("Channel is empty. Leaving the channel"))
+     * ```
+     *
+     * @param queue - The guild queue
+     */
+    [Events.EMPTY]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube encounters an error while playing songs.
+     *
+     * @example
+     * ```ts
+     * distube.on('error', (channel, e) => {
+     *     if (channel) channel.send(`An error encountered: ${e}`)
+     *     else console.error(e)
+     * })
+     * ```
+     *
+     * @param channel - Text channel where the error is encountered.
+     * @param error   - The error encountered
+     */
+    [Events.ERROR]: (channel: GuildTextBasedChannel | undefined, error: Error) => Awaitable;
+    /**
+     * @event
+     * Emitted for FFmpeg debugging information.
+     *
+     * @param debug - The debug information
+     */
+    [Events.FFMPEG_DEBUG]: (debug: string) => Awaitable;
+    /**
+     * @event
+     * Emitted when there is no more song in the queue and {@link Queue#autoplay} is
+     * `false`. DisTube will leave voice channel if {@link
+     * DisTubeOptions}.leaveOnFinish is `true`.
+     *
+     * @example
+     * ```ts
+     * distube.on("finish", queue => queue.textChannel.send("No more song in queue"));
+     * ```
+     *
+     * @param queue - The guild queue
+     */
+    [Events.FINISH]: (queue: Queue) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube finished a song.
+     *
+     * @example
+     * ```ts
+     * distube.on("finishSong", (queue, song) => queue.textChannel.send(`${song.name} has finished!`));
+     * ```
+     *
+     * @param queue - The guild queue
+     * @param song  - Finished song
+     */
+    [Events.FINISH_SONG]: (queue: Queue, song: Song) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube initialize a queue to change queue default properties.
+     *
+     * @example
+     * ```ts
+     * distube.on("initQueue", queue => {
+     *     queue.autoplay = false;
+     *     queue.volume = 100;
+     * });
+     * ```ts
+     *
+     * @param queue - The guild queue
+     */
+    [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.
+     *
+     * @example
+     * ```ts
+     * distube.on("noRelated", queue => queue.textChannel.send("Can't find related video to play."));
+     * ```ts
+     *
+     * @param queue - The guild queue
+     */
+    [Events.NO_RELATED]: (queue: Queue) => 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.
+     *
+     * @example
+     * ```ts
+     * distube.on("playSong", (queue, song) => queue.textChannel.send(
+     *     `Playing \`${song.name}\` - \`${song.formattedDuration}\`\nRequested by: ${song.user}`
+     * ));
+     * ```ts
+     *
+     * @param queue - The guild queue
+     * @param song  - Playing song
+     */
+    [Events.PLAY_SONG]: (queue: Queue, song: Song) => Awaitable;
+    /**
+     * @event
+     * Emitted when {@link DisTubeOptions | DisTubeOptions.searchSongs} bigger than 0,
+     * and the search canceled due to {@link DisTubeOptions |
+     * DisTubeOptions.searchTimeout}.
+     *
+     * @example
+     * ```ts
+     * // DisTubeOptions.searchSongs > 0
+     * distube.on("searchCancel", (message) => message.channel.send(`Searching canceled`));
+     * ```ts
+     *
+     * @param message - The user message called play method
+     * @param query   - The search query
+     */
+    [Events.SEARCH_CANCEL]: (message: Message, query: string) => Awaitable;
+    /**
+     * @event
+     * Emitted when {@link DisTubeOptions | DisTubeOptions.searchSongs} bigger than 0,
+     * and after the user chose a search result to play.
+     *
+     * @param message - The user message called play method
+     * @param answer  - The answered message of user
+     * @param query   - The search query
+     */
+    [Events.SEARCH_DONE]: (message: Message, answer: string, query: string) => Awaitable;
+    /**
+     * @event
+     * Emitted when {@link DisTubeOptions | DisTubeOptions.searchSongs} bigger than 0,
+     * and the search canceled due to user's next message is not a number or out of
+     * results range.
+     *
+     * @example
+     * ```ts
+     * // DisTubeOptions.searchSongs > 0
+     * distube.on("searchInvalidAnswer", (message) => message.channel.send(`You answered an invalid number!`));
+     * ```ts
+     *
+     * @param message - The user message called play method
+     * @param answer  - The answered message of user
+     * @param query   - The search query
+     */
+    [Events.SEARCH_INVALID_ANSWER]: (message: Message, answer: string, query: string) => Awaitable;
+    /**
+     * @event
+     * Emitted when DisTube cannot find any results for the query.
+     *
+     * @example
+     * ```ts
+     * distube.on("searchNoResult", (message, query) => message.channel.send(`No result found for ${query}!`));
+     * ```ts
+     *
+     * @param message - The user message called play method
+     * @param query   - The search query
+     */
+    [Events.SEARCH_NO_RESULT]: (message: Message, query: string) => Awaitable;
+    /**
+     * @event
+     * Emitted when {@link DisTubeOptions | DisTubeOptions.searchSongs} bigger than 0,
+     * and song param of {@link DisTube#play} is invalid url. DisTube will wait for
+     * user's next message to choose a song manually. <info>{@link
+     * https://support.google.com/youtube/answer/7354993 | Safe search} is enabled if
+     * {@link DisTubeOptions}.nsfw is disabled and the message's channel is not a nsfw
+     * channel.</info>
+     *
+     * @example
+     * ```ts
+     * // DisTubeOptions.searchSongs > 0
+     * distube.on("searchResult", (message, results) => {
+     *     message.channel.send(`**Choose an option from below**\n${
+     *         results.map((song, i) => `**${i + 1}**. ${song.name} - \`${song.formattedDuration}\``).join("\n")
+     *     }\n*Enter anything else or wait 60 seconds to cancel*`);
+     * });
+     * ```ts
+     *
+     * @param message - The user message called play method
+     * @param results - Searched results
+     * @param query   - The search query
+     */
+    [Events.SEARCH_RESULT]: (message: Message, results: SearchResult[], query: string) => Awaitable;
+}
 /**
  * DisTube class
- * @extends EventEmitter
  */
 declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
     #private;
@@ -1402,17 +1615,17 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
     readonly customPlugins: CustomPlugin[];
     readonly filters: Filters;
     /**
-     * @deprecated Use `youtubeCookie: Cookie[]` instead. Guide: {@link https://distube.js.org/#/docs/DisTube/main/general/cookie YouTube Cookies}
+     * @deprecated Use `youtubeCookie: Cookie[]` instead. Guide: {@link
+     * https://distube.js.org/#/docs/DisTube/main/general/cookie | YouTube Cookies}
      */
     constructor(client: Client, otp: DisTubeOptions & {
         youtubeCookie: string;
     });
     /**
      * Create a new DisTube class.
-     * @param {Discord.Client} client Discord.JS client
-     * @param {DisTubeOptions} [otp] Custom DisTube options
-     * @throws {DisTubeError}
+     *
      * @example
+     * ```ts
      * const Discord = require('discord.js'),
      *     DisTube = require('distube'),
      *     client = new Discord.Client();
@@ -1420,24 +1633,25 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      * const distube = new DisTube.default(client, { searchSongs: 10 });
      * // client.DisTube = distube // make it access easily
      * client.login("Your Discord Bot Token")
+     * ```ts
+     *
+     * @throws {@link DisTubeError}
+     *
+     * @param client - Discord.JS client
+     * @param otp    - Custom DisTube options
      */
     constructor(client: Client, otp?: DisTubeOptions);
     static get version(): string;
     /**
      * DisTube version
-     * @type {string}
      */
     get version(): string;
     /**
-     * Play / add a song or playlist from url. Search and play a song if it is not a valid url.
+     * Play / add a song or playlist from url. Search and play a song if it is not a
+     * valid url.
      *
-     * @param {Discord.BaseGuildVoiceChannel} 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 {string|Song|SearchResult|Playlist} song URL | Search string |
-     * {@link Song} | {@link SearchResult} | {@link Playlist}
-     * @param {PlayOptions} [options] Optional options
-     * @throws {DisTubeError}
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1449,15 +1663,21 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *             message
      *         });
      * });
-     * @returns {Promise<void>}
+     * ```ts
+     *
+     * @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 SearchResult} | {@link Playlist}
+     * @param options      - Optional options
      */
     play(voiceChannel: VoiceBasedChannel, song: string | Song | SearchResult | Playlist, options?: PlayOptions): Promise<void>;
     /**
      * Create a custom playlist
-     * @returns {Promise<Playlist>}
-     * @param {Array<string|Song|SearchResult>} songs Array of url, Song or SearchResult
-     * @param {CustomPlaylistOptions} [options] Optional options
+     *
      * @example
+     * ```ts
      * const songs = ["https://www.youtube.com/watch?v=xxx", "https://www.youtube.com/watch?v=yyy"];
      * const playlist = await distube.createCustomPlaylist(songs, {
      *     member: message.member,
@@ -1465,6 +1685,10 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *     parallel: true
      * });
      * distube.play(voiceChannel, playlist, { ... });
+     * ```ts
+     *
+     * @param songs   - Array of url, Song or SearchResult
+     * @param options - Optional options
      */
     createCustomPlaylist(songs: (string | Song | SearchResult)[], options?: CustomPlaylistOptions): Promise<Playlist>;
     search(string: string, options?: {
@@ -1487,10 +1711,9 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
     }): Promise<Array<SearchResult>>;
     /**
      * Get the guild queue
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Queue?}
-     * @throws {Error}
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1502,28 +1725,32 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *         ).join("\n"));
      *     }
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
      */
     getQueue(guild: GuildIdResolvable): Queue | undefined;
     /**
      * Pause the guild stream
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Queue} The guild queue
-     * @throws {Error}
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     *
+     * @returns The guild queue
      */
     pause(guild: GuildIdResolvable): Queue;
     /**
      * Resume the guild stream
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Queue} The guild queue
-     * @throws {Error}
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     *
+     * @returns The guild queue
      */
     resume(guild: GuildIdResolvable): Queue;
     /**
      * Stop the guild stream
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Promise<void>}
-     * @throws {Error}
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1533,15 +1760,16 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *         message.channel.send("Stopped the queue!");
      *     }
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
      */
     stop(guild: GuildIdResolvable): Promise<void>;
     /**
      * Set the guild stream's volume
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @param {number} percent The percentage of volume you want to set
-     * @returns {Queue} The guild queue
-     * @throws {Error}
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1549,16 +1777,21 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *     if (command == "volume")
      *         distube.setVolume(message, Number(args[0]));
      * });
+     * ```ts
+     *
+     * @param guild   - The type can be resolved to give a {@link Queue}
+     * @param percent - The percentage of volume you want to set
+     *
+     * @returns The guild queue
      */
     setVolume(guild: GuildIdResolvable, 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 {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Promise<Song>} The new Song will be played
-     * @throws {Error}
+     * 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>
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1566,14 +1799,18 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *     if (command == "skip")
      *         distube.skip(message);
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     *
+     * @returns The new Song will be played
      */
     skip(guild: GuildIdResolvable): Promise<Song>;
     /**
      * Play the previous song
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Promise<Song>} The new Song will be played
-     * @throws {Error}
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1581,13 +1818,18 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *     if (command == "previous")
      *         distube.previous(message);
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     *
+     * @returns The new Song will be played
      */
     previous(guild: GuildIdResolvable): Promise<Song>;
     /**
      * Shuffle the guild queue songs
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Promise<Queue>} The guild queue
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1595,17 +1837,19 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *     if (command == "shuffle")
      *         distube.shuffle(message);
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     *
+     * @returns The guild queue
      */
     shuffle(guild: GuildIdResolvable): Promise<Queue>;
     /**
-     * Jump to the song number in the queue.
-     * The next one is 1, 2,...
-     * The previous one is -1, -2,...
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @param {number} num The song number to play
-     * @returns {Promise<Song>} The new Song will be played
-     * @throws {Error} if `num` is invalid number (0 < num < {@link Queue#songs}.length)
+     * Jump to the song number in the queue. The next one is 1, 2,... The previous one
+     * is -1, -2,...
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1614,15 +1858,20 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *         distube.jump(message, parseInt(args[0]))
      *             .catch(err => message.channel.send("Invalid song number."));
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     * @param num   - The song number to play
+     *
+     * @returns The new Song will be played
      */
     jump(guild: GuildIdResolvable, num: number): Promise<Song>;
     /**
-     * Set the repeat mode of the guild queue.\
+     * Set the repeat mode of the guild queue.
      * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @param {RepeatMode?} [mode] The repeat modes (toggle if `undefined`)
-     * @returns {RepeatMode} The new repeat mode
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1633,7 +1882,9 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *         message.channel.send("Set repeat mode to `" + mode + "`");
      *     }
      * });
+     * ```ts
      * @example
+     * ```ts
      * const { RepeatMode } = require("distube");
      * let mode;
      * switch(distube.setRepeatMode(message, parseInt(args[0]))) {
@@ -1648,14 +1899,19 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *         break;
      * }
      * message.channel.send("Set repeat mode to `" + mode + "`");
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     * @param mode  - The repeat modes (toggle if `undefined`)
+     *
+     * @returns The new repeat mode
      */
     setRepeatMode(guild: GuildIdResolvable, mode?: number): number;
     /**
      * Toggle autoplay mode
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {boolean} Autoplay mode state
-     * @throws {Error}
+     *
      * @example
+     * ```ts
      * client.on('message', (message) => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1665,20 +1921,26 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *         message.channel.send("Set autoplay mode to `" + (mode ? "On" : "Off") + "`");
      *     }
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     *
+     * @returns Autoplay mode state
      */
     toggleAutoplay(guild: GuildIdResolvable): boolean;
     /**
      * Add related song to the queue
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @returns {Promise<Song>} The guild queue
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     *
+     * @returns The guild queue
      */
     addRelatedSong(guild: GuildIdResolvable): Promise<Song>;
     /**
      * Set the playing time to another position
-     * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-     * @param {number} time Time in seconds
-     * @returns {Queue} Seeked queue
+     *
      * @example
+     * ```ts
      * client.on('message', message => {
      *     if (!message.content.startsWith(config.prefix)) return;
      *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -1686,15 +1948,21 @@ declare class DisTube extends TypedEmitter<TypedDisTubeEvents> {
      *     if (command = 'seek')
      *         distube.seek(message, Number(args[0]));
      * });
+     * ```ts
+     *
+     * @param guild - The type can be resolved to give a {@link Queue}
+     * @param time  - Time in seconds
+     *
+     * @returns Seeked queue
      */
     seek(guild: GuildIdResolvable, time: number): Queue;
     /**
      * Emit error event
-     * @param {Error} error error
-     * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
-     * @private
+     *
+     * @param error   - error
+     * @param channel - Text channel where the error is encountered.
      */
     emitError(error: Error, channel?: GuildTextBasedChannel): void;
 }
 
-export { Awaitable, BaseManager, Chapter, CustomPlaylistOptions, CustomPlugin, DirectLinkPlugin, DisTube, DisTubeBase, DisTubeError, DisTubeEvents, DisTubeHandler, DisTubeOptions, DisTubeStream, DisTubeVoice, DisTubeVoiceEvents, DisTubeVoiceManager, Events, ExtractorPlugin, Filter, FilterManager, FilterResolvable, Filters, GuildIdManager, GuildIdResolvable, Options, OtherSongInfo, PlayHandlerOptions, PlayOptions, Playlist, PlaylistInfo, Plugin, PluginType, Queue, QueueManager, RelatedSong, RepeatMode, ResolveOptions, ResolvePlaylistOptions, SearchResult, SearchResultPlaylist, SearchResultType, SearchResultVideo, Song, StreamType, TaskQueue, TypedDisTubeEvents, checkIntents, checkInvalidKey, chooseBestVideoFormat, DisTube as default, defaultFilters, defaultOptions, formatDuration, isClientInstance, isGuildInstance, isMemberInstance, isMessageInstance, isNsfwChannel, isObject, isRecord, isSnowflake, isSupportedVoiceChannel, isTextChannelInstance, isTruthy, isURL, isVoiceChannelEmpty, objectKeys, parseNumber, resolveGuildId, toSecond, version };
+export { type Awaitable, BaseManager, type Chapter, type CustomPlaylistOptions, CustomPlugin, DirectLinkPlugin, DisTube, DisTubeBase, DisTubeError, type DisTubeEvents, DisTubeHandler, type DisTubeOptions, DisTubeStream, DisTubeVoice, type DisTubeVoiceEvents, DisTubeVoiceManager, Events, ExtractorPlugin, type FFmpegOptions, type Filter, FilterManager, type FilterResolvable, type Filters, GuildIdManager, type GuildIdResolvable, Options, type OtherSongInfo, type PlayHandlerOptions, type PlayOptions, Playlist, type PlaylistInfo, Plugin, PluginType, Queue, QueueManager, type RelatedSong, RepeatMode, type ResolveOptions, type ResolvePlaylistOptions, type SearchResult, SearchResultPlaylist, SearchResultType, SearchResultVideo, Song, StreamType, TaskQueue, type TypedDisTubeEvents, checkIntents, checkInvalidKey, chooseBestVideoFormat, DisTube as default, defaultFilters, defaultOptions, formatDuration, isClientInstance, isGuildInstance, isMemberInstance, isMessageInstance, isNsfwChannel, isObject, isRecord, isSnowflake, isSupportedVoiceChannel, isTextChannelInstance, isTruthy, isURL, isVoiceChannelEmpty, objectKeys, parseNumber, resolveGuildId, toSecond, version };