discord-player 6.1.0 → 6.2.0

package/README.md

@@ -30,8 +30,8 @@ Discord Player requires Discord.js 14.0 or higher. PLease make sure you have a c
 #### Main Library
 
 ```bash
-$ npm install discord-player # main library
-$ npm install @discord-player/extractor # extractors provider
+$ yarn add discord-player # main library
+$ yarn add @discord-player/extractor # extractors provider
 ```
 
 > Discord Player recognizes `@discord-player/extractor` and loads it automatically by default.
@@ -41,8 +41,8 @@ $ npm install @discord-player/extractor # extractors provider
 Discord Player is a high level framework for Discord VoIP. Discord only accepts opus packets, thus you need to install opus library. You can install any of these:
 
 ```bash
-$ npm install @discordjs/opus
-$ npm install opusscript
+$ yarn add @discordjs/opus
+$ yarn add opusscript
 ```
 
 #### FFmpeg or Avconv
@@ -50,7 +50,7 @@ $ npm install opusscript
 FFmpeg or Avconv is required for media transcoding. You can get it from [https://ffmpeg.org](https://www.ffmpeg.org/download.html) or by installing it from npm:
 
 ```bash
-$ npm install ffmpeg-static
+$ yarn add ffmpeg-static
 ```
 
 You can get avconv from [https://libav.org/download](https://libav.org/download).
@@ -60,9 +60,9 @@ You can get avconv from [https://libav.org/download](https://libav.org/download)
 You also need to install streaming library if you want to add support for youtube playback. You can install one of these libraries:
 
 ```bash
-$ npm install ytdl-core
-$ npm install play-dl
-$ npm install @distube/ytdl-core
+$ yarn add ytdl-core
+$ yarn add play-dl
+$ yarn add @distube/ytdl-core
 ```
 
 Done with all these? Let's write a simple music bot then.
@@ -125,6 +125,7 @@ That's all it takes to build your own music bot.
 
 #### Check out the [Documentation](https://discord-player.js.org) for more info.
 
-## Example bots made with Discord Player
+## Community Resources
 
-[You can find community-built example bots that use discord-player here](https://github.com/Androz2091/discord-player/issues/1638)
+A curated list of resources (such as open source music bots, extractors, etc.) built by Discord Player community.
+[https://discord-player.js.org/docs/guides/community-resources](https://discord-player.js.org/docs/guides/community-resources)

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import * as discord_js from 'discord.js';
 import { User, VoiceChannel, StageChannel, UserResolvable, Guild, VoiceState, VoiceBasedChannel, GuildVoiceChannelResolvable, Snowflake, Client, GuildResolvable } from 'discord.js';
 import * as _discordjs_voice from '@discordjs/voice';
 import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, StreamType, EndBehaviorType } from '@discordjs/voice';
+export { AudioPlayer, CreateAudioPlayerOptions, createAudioPlayer } from '@discordjs/voice';
 import { Readable, Duplex } from 'stream';
 import * as _discord_player_equalizer from '@discord-player/equalizer';
 import { PCMFilters, EqualizerBand, BiquadFilters, FiltersChain } from '@discord-player/equalizer';
@@ -88,7 +89,7 @@ interface ExtractorExecutionEvents {
 }
 declare class ExtractorExecutionContext extends PlayerEventsEmitter<ExtractorExecutionEvents> {
     player: Player;
-    store: Collection<string, BaseExtractor>;
+    store: Collection<string, BaseExtractor<object>>;
     constructor(player: Player);
     /**
      * Load default extractors from `@discord-player/extractor`
@@ -113,13 +114,13 @@ declare class ExtractorExecutionContext extends PlayerEventsEmitter<ExtractorExe
      * Get single extractor
      * @param identifier The extractor to get
      */
-    get(identifier: string): BaseExtractor | undefined;
+    get(identifier: string): BaseExtractor<object> | undefined;
     /**
      * Register single extractor
      * @param _extractor The extractor to register
      * @param options Options supplied to the extractor
      */
-    register(_extractor: typeof BaseExtractor, options?: Record<string, unknown>): Promise<void>;
+    register<O extends object, T extends typeof BaseExtractor<O>>(_extractor: T, options: ConstructorParameters<T>['1']): Promise<void>;
     /**
      * Unregister single extractor
      * @param _extractor The extractor to unregister
@@ -134,17 +135,18 @@ declare class ExtractorExecutionContext extends PlayerEventsEmitter<ExtractorExe
      * @param fn The runner function
      * @param filterBlocked Filter blocked extractors
      */
-    run<T = unknown>(fn: ExtractorExecutionFN<T>, filterBlocked?: boolean): Promise<ExtractorExecutionResult<T> | null>;
+    run<T = unknown>(fn: ExtractorExecutionFN<T>, filterBlocked?: boolean): Promise<ExtractorExecutionResult<T> | undefined>;
 }
 interface ExtractorExecutionResult<T = unknown> {
     extractor: BaseExtractor;
+    error: Error | null;
     result: T;
 }
 type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
 
-declare class BaseExtractor {
+declare class BaseExtractor<T extends object = object> {
     context: ExtractorExecutionContext;
-    options: Record<string, unknown>;
+    options: T;
     /**
      * Identifier for this extractor
      */
@@ -154,11 +156,16 @@ declare class BaseExtractor {
      * @param context Context that instantiated this extractor
      * @param options Initialization options for this extractor
      */
-    constructor(context: ExtractorExecutionContext, options?: Record<string, unknown>);
+    constructor(context: ExtractorExecutionContext, options?: T);
     /**
      * Identifier of this extractor
      */
     get identifier(): string;
+    /**
+     * Reconfigures this extractor
+     * @param options The new options to apply
+     */
+    reconfigure(options: T): Promise<void>;
     /**
      * This method will be executed when this extractor is activated
      */
@@ -313,7 +320,7 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
      * @param {VoiceChannel|StageChannel} channel The connected channel
      * @private
      */
-    constructor(connection: VoiceConnection, channel: VoiceChannel | StageChannel, queue: GuildQueue, connectionTimeout?: number);
+    constructor(connection: VoiceConnection, channel: VoiceChannel | StageChannel, queue: GuildQueue, connectionTimeout?: number, audioPlayer?: AudioPlayer);
     /**
      * Check if the player has been paused manually
      */
@@ -492,6 +499,73 @@ declare class GuildQueueHistory<Meta = unknown> {
     back(): Promise<void>;
 }
 
+interface AsyncQueueAcquisitionOptions {
+    /**
+     * AbortSignal to cancel this entry
+     */
+    signal?: AbortSignal;
+}
+declare class AsyncQueue {
+    /**
+     * The queued entries
+     */
+    entries: Array<AsyncQueueEntry>;
+    /**
+     * Clear entries queue
+     * @param consume Whether or not to consume all entries before clearing
+     */
+    clear(consume?: boolean): void;
+    /**
+     * The total number of entries in this queue. Returns `0` if no entries are available.
+     */
+    get size(): number;
+    /**
+     * Acquire an entry.
+     *
+     * ```typescript
+     * // lock the queue
+     * const entry = asyncQueue.acquire();
+     * // wait until previous task is completed
+     * await entry.getTask();
+     * // do something expensive
+     * await performSomethingExpensive();
+     * // make sure to release the lock once done
+     * asyncQueue.release();
+     * ```
+     */
+    acquire(options?: AsyncQueueAcquisitionOptions): AsyncQueueEntry;
+    /**
+     * Release the current acquisition and move to next entry.
+     */
+    release(): void;
+    /**
+     * Cancel all entries
+     */
+    cancelAll(): void;
+    /**
+     * Remove the given entry from the queue
+     * @param entry The entry to remove
+     */
+    removeEntry(entry: AsyncQueueEntry): boolean;
+}
+declare class AsyncQueueEntry {
+    queue: AsyncQueue;
+    options?: AsyncQueueAcquisitionOptions | undefined;
+    readonly id: string;
+    private readonly promise;
+    signal: AbortSignal | null;
+    onAbort: (() => void) | null;
+    private resolve;
+    private reject;
+    constructor(queue: AsyncQueue, options?: AsyncQueueAcquisitionOptions | undefined);
+    setAbortSignal(signal: AbortSignal): void;
+    consume(): void;
+    release(): void;
+    cancel(): void;
+    cleanup(): void;
+    getTask(): Promise<void>;
+}
+
 declare const FFMPEG_SRATE_REGEX: RegExp;
 interface ResourcePlayOptions {
     queue?: boolean;
@@ -512,6 +586,7 @@ interface PlayerTimestamp {
 declare class GuildQueuePlayerNode<Meta = unknown> {
     #private;
     queue: GuildQueue<Meta>;
+    tasksQueue: AsyncQueue;
     constructor(queue: GuildQueue<Meta>);
     /**
      * If the player is currently in idle mode
@@ -533,6 +608,10 @@ declare class GuildQueuePlayerNode<Meta = unknown> {
      * Reset progress history
      */
     resetProgress(): void;
+    /**
+     * Set player progress
+     */
+    setProgress(progress: number): void;
     /**
      * The stream time for current session
      */
@@ -625,6 +704,24 @@ declare class GuildQueuePlayerNode<Meta = unknown> {
      * @param index The position to insert to, defaults to 0.
      */
     insert(track: Track, index?: number): void;
+    /**
+     * Moves a track in the queue
+     * @param from The track to move
+     * @param to The position to move to
+     */
+    move(from: TrackResolvable, to: number): void;
+    /**
+     * Copy a track in the queue
+     * @param from The track to clone
+     * @param to The position to clone at
+     */
+    copy(from: TrackResolvable, to: number): void;
+    /**
+     * Swap two tracks in the queue
+     * @param first The first track to swap
+     * @param second The second track to swap
+     */
+    swap(first: TrackResolvable, second: TrackResolvable): void;
     /**
      * Stop the playback
      * @param force Whether or not to forcefully stop the playback
@@ -811,7 +908,7 @@ declare class AFilterGraph<Meta = unknown> {
     get ffmpeg(): (keyof QueueFilters)[];
     get equalizer(): EqualizerBand[];
     get biquad(): null;
-    get filters(): ("8D" | "Tremolo" | "Vibrato" | "BassBoost")[];
+    get filters(): ("8D" | "Tremolo" | "Vibrato")[];
     get volume(): _discord_player_equalizer.VolumeTransformer | null;
     get resampler(): _discord_player_equalizer.PCMResampler | null;
     dump(): FilterGraph;
@@ -849,10 +946,12 @@ interface GuildNodeInit<Meta = unknown> {
     selfDeaf?: boolean;
     metadata?: Meta | null;
     bufferingTimeout: number;
+    noEmitInsert: boolean;
 }
 interface VoiceConnectConfig {
     deaf?: boolean;
     timeout?: number;
+    audioPlayer?: AudioPlayer;
 }
 interface PostProcessedResult {
     stream: Readable;
@@ -925,7 +1024,35 @@ declare enum GuildQueueEvent {
     /**
      * Emitted when the voice state is updated. Consuming this event may disable default voice state update handler if `Player.isVoiceStateHandlerLocked()` returns `false`.
      */
-    voiceStateUpdate = "voiceStateUpdate"
+    voiceStateUpdate = "voiceStateUpdate",
+    /**
+     * Emitted when volume is updated
+     */
+    volumeChange = "volumeChange",
+    /**
+     * Emitted when player is paused
+     */
+    playerPause = "playerPause",
+    /**
+     * Emitted when player is resumed
+     */
+    playerResume = "playerResume",
+    /**
+     * Biquad Filters Update
+     */
+    biquadFiltersUpdate = "biquadFiltersUpdate",
+    /**
+     * Equalizer Update
+     */
+    equalizerUpdate = "equalizerUpdate",
+    /**
+     * DSP update
+     */
+    dspUpdate = "dspUpdate",
+    /**
+     * Audio Filters Update
+     */
+    audioFiltersUpdate = "audioFiltersUpdate"
 }
 interface GuildQueueEvents<Meta = unknown> {
     /**
@@ -1022,6 +1149,51 @@ interface GuildQueueEvents<Meta = unknown> {
      * @param newState The new voice state
      */
     voiceStateUpdate: (queue: GuildQueue<Meta>, oldState: VoiceState, newState: VoiceState) => unknown;
+    /**
+     * Emitted when audio player is paused
+     * @param queue The queue where this event occurred
+     */
+    playerPause: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when audio player is resumed
+     * @param queue The queue where this event occurred
+     */
+    playerResume: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when audio player's volume is changed
+     * @param queue The queue where this event occurred
+     * @param oldVolume The old volume
+     * @param newVolume The updated volume
+     */
+    volumeChange: (queue: GuildQueue<Meta>, oldVolume: number, newVolume: number) => unknown;
+    /**
+     * Emitted when equalizer config is updated
+     * @param queue The queue where this event occurred
+     * @param oldFilters Old filters
+     * @param newFilters New filters
+     */
+    equalizerUpdate: (queue: GuildQueue<Meta>, oldFilters: EqualizerBand[], newFilters: EqualizerBand[]) => unknown;
+    /**
+     * Emitted when biquad filters is updated
+     * @param queue The queue where this event occurred
+     * @param oldFilters Old filters
+     * @param newFilters New filters
+     */
+    biquadFiltersUpdate: (queue: GuildQueue<Meta>, oldFilters: BiquadFilters | null, newFilters: BiquadFilters | null) => unknown;
+    /**
+     * Emitted when dsp filters is updated
+     * @param queue The queue where this event occurred
+     * @param oldFilters Old filters
+     * @param newFilters New filters
+     */
+    dspUpdate: (queue: GuildQueue<Meta>, oldFilters: PCMFilters[], newFilters: PCMFilters[]) => unknown;
+    /**
+     * Emitted when ffmpeg audio filters is updated
+     * @param queue The queue where this event occurred
+     * @param oldFilters Old filters
+     * @param newFilters New filters
+     */
+    audioFiltersUpdate: (queue: GuildQueue<Meta>, oldFilters: FiltersName[], newFilters: FiltersName[]) => unknown;
 }
 declare class GuildQueue<Meta = unknown> {
     #private;
@@ -1038,6 +1210,7 @@ declare class GuildQueue<Meta = unknown> {
     repeatMode: QueueRepeatMode;
     timeouts: Collection<string, NodeJS.Timeout>;
     stats: GuildQueueStatistics<Meta>;
+    tasksQueue: AsyncQueue;
     constructor(player: Player, options: GuildNodeInit<Meta>);
     /**
      * Estimated duration of this queue in ms
@@ -1059,18 +1232,13 @@ declare class GuildQueue<Meta = unknown> {
     /**
      * The metadata of this queue
      */
-    get metadata(): Meta | undefined | null;
-    set metadata(m: Meta | undefined | null);
+    get metadata(): Meta;
+    set metadata(m: Meta);
     /**
      * Set metadata for this queue
      * @param m Metadata to set
      */
-    setMetadata(m: Meta | undefined | null): void;
-    /**
-     * Indicates if this queue is currently initializing
-     */
-    get initializing(): boolean;
-    set initializing(v: boolean);
+    setMetadata(m: Meta): void;
     /**
      * Indicates current track of this queue
      */
@@ -1146,6 +1314,24 @@ declare class GuildQueue<Meta = unknown> {
      * @param index The index to insert the track at (defaults to 0)
      */
     insertTrack(track: Track, index?: number): void;
+    /**
+     * Moves a track in the queue
+     * @param from The track to move
+     * @param to The position to move to
+     */
+    moveTrack(track: TrackResolvable, index?: number): void;
+    /**
+     * Copy a track in the queue
+     * @param from The track to clone
+     * @param to The position to clone at
+     */
+    copyTrack(track: TrackResolvable, index?: number): void;
+    /**
+     * Swap two tracks in the queue
+     * @param src The first track to swap
+     * @param dest The second track to swap
+     */
+    swapTracks(src: TrackResolvable, dest: TrackResolvable): void;
     /**
      * Connect to a voice channel
      * @param channelResolvable The voice channel to connect to
@@ -1165,10 +1351,6 @@ declare class GuildQueue<Meta = unknown> {
      * @returns
      */
     revive(): void;
-    /**
-     * Wait for this queue to initialize
-     */
-    awaitInitialization(): Promise<boolean>;
     /**
      * Set self deaf
      * @param mode On/Off state
@@ -1231,6 +1413,7 @@ declare class VoiceUtils {
         deaf?: boolean;
         maxTime?: number;
         queue: GuildQueue;
+        audioPlayer?: AudioPlayer;
     }): Promise<StreamDispatcher>;
     /**
      * Joins a voice channel
@@ -1285,7 +1468,7 @@ declare class SearchResult {
     /**
      * The extractor
      */
-    get extractor(): BaseExtractor | null;
+    get extractor(): BaseExtractor<object> | null;
     /**
      * Playlist result
      */
@@ -1385,28 +1568,47 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      */
     static singleton(client: Client, options?: PlayerInitOptions): Player;
     /**
-     * Get all active player instances
+     * Get all active master player instances
      */
     static getAllPlayers(): Player[];
     /**
-     * Clear all player instances
+     * Clear all master player instances
      */
     static clearAllPlayers(): void;
     /**
-     * The current query cache provider
+     * The current query cache provider in use
      */
     get queryCache(): QueryCache | null;
     /**
-     * Alias to `Player.nodes`
+     * Alias to `Player.nodes`.
      */
     get queues(): GuildNodeManager<unknown>;
     /**
-     * Event loop lag
+     * Event loop latency in ms. If your bot is laggy and this returns a number above 20ms for example,
+     * some expensive task is being executed on the current thread which is slowing down the event loop.
      * @type {number}
      */
     get eventLoopLag(): number;
     /**
-     * Generates statistics
+     * Generates statistics that could be useful. Statistics generator is still experimental.
+     * @example ```typescript
+     * const stats = player.generateStatistics();
+     *
+     * console.log(stats);
+     *
+     * // outputs something like
+     * // {
+     * //   instances: number,
+     * //   queuesCount: number,
+     * //   queryCacheEnabled: boolean,
+     * //   queues: [
+     * //      GuildQueueStatisticsMetadata,
+     * //      GuildQueueStatisticsMetadata,
+     * //      GuildQueueStatisticsMetadata,
+     * //      ...
+     * //   ]
+     * // }
+     * ```
      */
     generateStatistics(): {
         instances: number;
@@ -1415,7 +1617,11 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
         queues: GuildQueueStatisticsMetadata[];
     };
     /**
-     * Destroy player
+     * Destroy every single queues managed by this master player instance
+     * @example ```typescript
+     * // use me when you want to immediately terminate every single queues in existence 🔪
+     * await player.destroy();
+     * ```
      */
     destroy(): Promise<void>;
     private _handleVoiceState;
@@ -1424,18 +1630,26 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * @param {VoiceState} oldState The old voice state
      * @param {VoiceState} newState The new voice state
      * @returns {void}
+     * @example ```typescript
+     * // passing voice state update data to this method will trigger voice state handler
+     *
+     * client.on('voiceStateUpdate', (oldState, newState) => {
+     *   // this is definitely a rocket science, right here
+     *   player.handleVoiceState(oldState, newState);
+     * });
+     * ```
      */
     handleVoiceState(oldState: VoiceState, newState: VoiceState): void;
     /**
-     * Lock voice state handler
+     * Lock voice state handler. When this method is called, discord-player will keep using the default voice state update handler, even if custom implementation exists.
      */
     lockVoiceStateHandler(): void;
     /**
-     * Unlock voice state handler
+     * Unlock voice state handler. When this method is called, discord-player will stop using the default voice state update handler if custom implementation exists.
      */
     unlockVoiceStateHandler(): void;
     /**
-     * Checks if voice state handler is locked
+     * Checks if voice state handler is locked.
      */
     isVoiceStateHandlerLocked(): boolean;
     /**
@@ -1443,26 +1657,42 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * @param channel The voice channel on which the music should be played
      * @param query The track or source to play
      * @param options Options for player
+     * @example ```typescript
+     * // no need to worry about queue management, just use this method 😄
+     * const query = 'this is my super cool search query that I want to play';
+     *
+     * try {
+     *    const { track } = await player.play(voiceChannel, query);
+     *   console.log(`🎉 I am playing ${track.title} 🎉`);
+     * } catch(e) {
+     *   console.log(`😭 Failed to play error oh no:\n\n${e}`);
+     * }
+     * ```
      */
     play<T = unknown>(channel: GuildVoiceChannelResolvable, query: string | Track | SearchResult | Track[] | Playlist, options?: SearchOptions & {
         nodeOptions?: GuildNodeCreateOptions<T>;
         connectionOptions?: VoiceConnectConfig;
         afterSearch?: (result: SearchResult) => Promise<SearchResult>;
     }): Promise<PlayerNodeInitializationResult<T>>;
-    /**
-     * @typedef {object} PlayerSearchResult
-     * @property {Playlist} [playlist] The playlist (if any)
-     * @property {Track[]} tracks The tracks
-     */
     /**
      * Search tracks
      * @param {string | Track | Track[] | Playlist | SearchResult} query The search query
      * @param {SearchOptions} options The search options
      * @returns {Promise<SearchResult>}
+     * @example ```typescript
+     * const searchQuery = 'pass url or text or discord-player track constructable objects, we got you covered 😎';
+     * const result = await player.search(searchQuery);
+     *
+     * console.log(result); // Logs `SearchResult` object
+     * ```
      */
     search(query: string | Track | Track[] | Playlist | SearchResult, options?: SearchOptions): Promise<SearchResult>;
     /**
      * Generates a report of the dependencies used by the `@discordjs/voice` module. Useful for debugging.
+     * @example ```typescript
+     * console.log(player.scanDeps());
+     * // -> logs dependencies report
+     * ```
      * @returns {string}
      */
     scanDeps(): string;
@@ -1497,6 +1727,7 @@ interface GuildNodeCreateOptions<T = unknown> {
     connectionTimeout?: number;
     defaultFFmpegFilters?: FiltersName[];
     bufferingTimeout?: number;
+    noEmitInsert?: boolean;
 }
 type NodeResolvable = GuildQueue | GuildResolvable;
 declare class GuildNodeManager<Meta = unknown> {
@@ -1694,6 +1925,7 @@ interface PlayerProgressbarOptions {
  * - SPOTIFY_SONG
  * - SPOTIFY_ALBUM
  * - SPOTIFY_PLAYLIST
+ * - SPOTIFY_SEARCH
  * - FACEBOOK
  * - VIMEO
  * - ARBITRARY
@@ -1706,7 +1938,8 @@ interface PlayerProgressbarOptions {
  * - APPLE_MUSIC_PLAYLIST
  * - APPLE_MUSIC_SEARCH
  * - FILE
- * @typedef {number} QueryType
+ * - AUTO_SEARCH
+ * @typedef {string} QueryType
  */
 declare const QueryType: {
     readonly AUTO: "auto";
@@ -1718,6 +1951,7 @@ declare const QueryType: {
     readonly SPOTIFY_SONG: "spotifySong";
     readonly SPOTIFY_ALBUM: "spotifyAlbum";
     readonly SPOTIFY_PLAYLIST: "spotifyPlaylist";
+    readonly SPOTIFY_SEARCH: "spotifySearch";
     readonly FACEBOOK: "facebook";
     readonly VIMEO: "vimeo";
     readonly ARBITRARY: "arbitrary";
@@ -1730,6 +1964,7 @@ declare const QueryType: {
     readonly APPLE_MUSIC_PLAYLIST: "appleMusicPlaylist";
     readonly APPLE_MUSIC_SEARCH: "appleMusicSearch";
     readonly FILE: "file";
+    readonly AUTO_SEARCH: "autoSearch";
 };
 type SearchQueryType = keyof typeof QueryType | (typeof QueryType)[keyof typeof QueryType];
 interface PlayerEvents {
@@ -1759,15 +1994,17 @@ type QueryExtractorSearch = `ext:${string}`;
 /**
  * @typedef {object} SearchOptions
  * @property {UserResolvable} requestedBy The user who requested this search
- * @property {typeof QueryType|string} [searchEngine=QueryType.AUTO] The query search engine, can be extractor name to target specific one (custom)
+ * @property {typeof QueryType|string} [searchEngine='auto'] The query search engine, can be extractor name to target specific one (custom)
  * @property {string[]} [blockExtractors[]] List of the extractors to block
  * @property {boolean} [ignoreCache] If it should ignore query cache lookup
+ * @property {SearchQueryType} [fallbackSearchEngine='autoSearch'] Fallback search engine to use
  */
 interface SearchOptions {
     requestedBy?: UserResolvable;
     searchEngine?: SearchQueryType | QueryExtractorSearch;
     blockExtractors?: string[];
     ignoreCache?: boolean;
+    fallbackSearchEngine?: (typeof QueryType)[keyof typeof QueryType];
 }
 /**
  * The queue repeat mode. This can be one of:
@@ -2001,6 +2238,7 @@ declare class TypeUtil {
     static isBoolean(t: unknown): t is boolean;
     static isNullish(t: unknown): t is null | undefined;
     static isArray(t: unknown): t is unknown[];
+    static isError(t: unknown): t is Error;
 }
 
 declare class QueryResolver {
@@ -2022,9 +2260,8 @@ declare class QueryResolver {
     /**
      * Resolves the given search query
      * @param {string} query The query
-     * @returns {QueryType}
      */
-    static resolve(query: string): (typeof QueryType)[keyof typeof QueryType];
+    static resolve(query: string, fallbackSearchEngine?: (typeof QueryType)[keyof typeof QueryType]): (typeof QueryType)[keyof typeof QueryType];
     /**
      * Parses vimeo id from url
      * @param {string} query The query
@@ -2043,7 +2280,8 @@ declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta
 
 declare function useMasterPlayer(): Player | null;
 
-declare function useMetadata<T = unknown>(node: NodeResolvable): readonly [() => T, (metadata: T | null) => void];
+type SetterFN<T, P> = (previous: P) => T;
+declare function useMetadata<T = unknown>(node: NodeResolvable): readonly [() => T, (metadata: T | SetterFN<T, T>) => void];
 
 interface TimelineDispatcherOptions {
     ignoreFilters: boolean;
@@ -2064,4 +2302,4 @@ declare function onBeforeCreateStream(handler: OnBeforeCreateStreamHandler): voi
 
 declare const version: string;
 
-export { AFilterGraph, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackResolvable, TrackSource, TypeUtil, Util, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, createFFmpegStream, onAfterCreateStream, onBeforeCreateStream, useHistory, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, version };
+export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackResolvable, TrackSource, TypeUtil, Util, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, createFFmpegStream, onAfterCreateStream, onBeforeCreateStream, useHistory, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, version };