discord-player 6.0.0-dev.1 → 6.0.0-dev.3

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-import { User, VoiceChannel, StageChannel, Guild, VoiceState, VoiceBasedChannel, GuildVoiceChannelResolvable, GuildResolvable, Snowflake, Client, GuildChannelResolvable, UserResolvable } from 'discord.js';
-import { Readable, Duplex } from 'stream';
+import { User, VoiceChannel, StageChannel, Guild, VoiceState, VoiceBasedChannel, GuildVoiceChannelResolvable, Snowflake, Client, GuildResolvable, UserResolvable } from 'discord.js';
+import * as _discordjs_voice from '@discordjs/voice';
+import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, StreamType } from '@discordjs/voice';
 import * as _discord_player_equalizer from '@discord-player/equalizer';
 import { PCMFilters, EqualizerBand, BiquadFilters, FiltersChain } from '@discord-player/equalizer';
 export { AF_NIGHTCORE_RATE, AF_VAPORWAVE_RATE, BASS_EQ_BANDS, FilterType as BiquadFilterType, BiquadFilters, FiltersChain, AudioFilters as PCMAudioFilters, PCMFilters, Q_BUTTERWORTH, VolumeTransformer } from '@discord-player/equalizer';
-import { EventEmitter, Queue as Queue$1, QueueStrategy, Collection } from '@discord-player/utils';
-import * as _discordjs_voice from '@discordjs/voice';
-import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, StreamType } from '@discordjs/voice';
+import { EventEmitter, Queue, QueueStrategy, Collection } from '@discord-player/utils';
+import { Readable, Duplex } from 'stream';
+import Fuse from 'fuse.js';
 import { downloadOptions } from 'ytdl-core';
 
 declare class Playlist {
@@ -64,7 +65,7 @@ declare class Track {
      * The queue in which this track is located
      * @type {Queue}
      */
-    get queue(): Queue;
+    get queue(): GuildQueue;
     /**
      * The track duration in millisecond
      * @type {number}
@@ -113,6 +114,7 @@ interface VoiceEvents {
     volume: (volume: number) => any;
 }
 declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
+    queue: GuildQueue;
     readonly connectionTimeout: number;
     readonly voiceConnection: VoiceConnection;
     readonly audioPlayer: AudioPlayer;
@@ -126,7 +128,7 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
      * @param {VoiceChannel|StageChannel} channel The connected channel
      * @private
      */
-    constructor(connection: VoiceConnection, channel: VoiceChannel | StageChannel, connectionTimeout?: number);
+    constructor(connection: VoiceConnection, channel: VoiceChannel | StageChannel, queue: GuildQueue, connectionTimeout?: number);
     /**
      * Check if the player has been paused manually
      */
@@ -150,11 +152,11 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
     isIdle(): boolean;
     /**
      * Creates stream
-     * @param {Readable|Duplex|string} src The stream source
+     * @param {Readable} src The stream source
      * @param {object} [ops] Options
      * @returns {AudioResource}
      */
-    createStream(src: Readable | Duplex | string, ops?: CreateStreamOps): AudioResource<Track>;
+    createStream(src: Readable, ops?: CreateStreamOps): Promise<AudioResource<Track>>;
     get resampler(): _discord_player_equalizer.PCMResampler | null;
     get filters(): _discord_player_equalizer.AudioFilter | null;
     get biquad(): _discord_player_equalizer.BiquadStream | null;
@@ -211,19 +213,48 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
 
 declare class GuildQueueHistory<Meta = unknown> {
     queue: GuildQueue<Meta>;
-    tracks: Queue$1<Track>;
+    tracks: Queue<Track>;
     constructor(queue: GuildQueue<Meta>);
+    /**
+     * Current track in the queue
+     */
     get currentTrack(): Track | null;
+    /**
+     * Next track in the queue
+     */
     get nextTrack(): Track | null;
+    /**
+     * Previous track in the queue
+     */
     get previousTrack(): Track | null;
+    /**
+     * If history is disabled
+     */
     get disabled(): boolean;
+    /**
+     * If history is empty
+     */
     isEmpty(): boolean;
+    /**
+     * Add track to track history
+     * @param track The track to add
+     */
     push(track: Track | Track[]): boolean;
+    /**
+     * Clear history
+     */
     clear(): void;
+    /**
+     * Play the next track in the queue
+     */
     next(): void;
+    /**
+     * Play the previous track in the queue
+     */
     previous(): void;
 }
 
+declare const FFMPEG_SRATE_REGEX: RegExp;
 interface ResourcePlayOptions {
     queue?: boolean;
     seek?: number;
@@ -244,83 +275,233 @@ declare class GuildQueuePlayerNode<Meta = unknown> {
     #private;
     queue: GuildQueue<Meta>;
     constructor(queue: GuildQueue<Meta>);
+    /**
+     * If the player is currently in idle mode
+     */
     isIdle(): boolean;
+    /**
+     * If the player is currently buffering the track
+     */
     isBuffering(): boolean;
+    /**
+     * If the player is currently playing a track
+     */
     isPlaying(): boolean;
+    /**
+     * If the player is currently paused
+     */
     isPaused(): boolean;
+    /**
+     * Reset progress history
+     */
     resetProgress(): void;
+    /**
+     * The stream time for current session
+     */
+    get streamTime(): number;
+    /**
+     * Current playback duration with history included
+     */
     get playbackTime(): number;
-    getTimestamp(): PlayerTimestamp | null;
+    /**
+     * Get duration multiplier
+     */
+    getDurationMultiplier(): number;
+    /**
+     * Estimated progress of the player
+     */
+    get estimatedPlaybackTime(): number;
+    /**
+     * Estimated total duration of the player
+     */
+    get estimatedDuration(): number;
+    /**
+     * Get stream progress
+     * @param ignoreFilters Ignore filters
+     */
+    getTimestamp(ignoreFilters?: boolean): PlayerTimestamp | null;
+    /**
+     * Create progress bar for current progress
+     * @param options Progress bar options
+     */
     createProgressBar(options?: PlayerProgressbarOptions): string | null;
+    /**
+     * Seek the player
+     * @param duration The duration to seek to
+     */
     seek(duration: number): Promise<boolean>;
+    /**
+     * Current volume
+     */
     get volume(): number;
+    /**
+     * Set volume
+     * @param vol Volume amount to set
+     */
     setVolume(vol: number): boolean;
+    /**
+     * Set bit rate
+     * @param rate The bit rate to set
+     */
     setBitrate(rate: number | 'auto'): void;
+    /**
+     * Set paused state
+     * @param state The state
+     */
     setPaused(state: boolean): boolean;
+    /**
+     * Pause the playback
+     */
     pause(): boolean;
+    /**
+     * Resume the playback
+     */
     resume(): boolean;
+    /**
+     * Skip current track
+     */
     skip(): boolean;
+    /**
+     * Remove the given track from queue
+     * @param track The track to remove
+     */
     remove(track: TrackResolvable): Track | null;
+    /**
+     * Jump to specific track on the queue
+     * @param track The track to jump to without removing other tracks
+     */
     jump(track: TrackResolvable): boolean;
+    /**
+     * Get track position
+     * @param track The track
+     */
     getTrackPosition(track: TrackResolvable): number;
+    /**
+     * Skip to the given track, removing others on the way
+     * @param track The track to skip to
+     */
     skipTo(track: TrackResolvable): boolean;
+    /**
+     * Insert a track on the given position in queue
+     * @param track The track to insert
+     * @param index The position to insert to, defaults to 0.
+     */
     insert(track: Track, index?: number): void;
+    /**
+     * Stop the playback
+     * @param force Whether or not to forcefully stop the playback
+     */
     stop(force?: boolean): boolean;
+    /**
+     * Play the given track
+     * @param res The track to play
+     * @param options Options for playing the track
+     */
     play(res?: Track, options?: ResourcePlayOptions): Promise<void>;
 }
 
+interface FFmpegStreamOptions {
+    fmt?: string;
+    encoderArgs?: string[];
+    seek?: number;
+    skip?: boolean;
+    cookies?: string;
+}
+declare function FFMPEG_ARGS_STRING(stream: string, fmt?: string, cookies?: string): string[];
+declare function FFMPEG_ARGS_PIPED(fmt?: string): string[];
+/**
+ * Creates FFmpeg stream
+ * @param stream The source stream
+ * @param options FFmpeg stream options
+ */
+declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable;
+
 type Filters = keyof typeof AudioFilters.filters;
 declare const EqualizerConfigurationPreset: {
-    readonly Jazz: {
-        band: number;
-        gain: number;
-    }[];
-    readonly EDM: {
-        band: number;
-        gain: number;
-    }[];
-    readonly HipHop: {
-        band: number;
-        gain: number;
-    }[];
-    readonly Rock: {
-        band: number;
-        gain: number;
-    }[];
-    readonly Metal: {
-        band: number;
-        gain: number;
-    }[];
-    readonly Folk: {
-        band: number;
-        gain: number;
-    }[];
-    readonly RnB: {
-        band: number;
-        gain: number;
-    }[];
-    readonly Country: {
-        band: number;
-        gain: number;
-    }[];
-    readonly Classical: {
-        band: number;
-        gain: number;
-    }[];
+    readonly Flat: EqualizerBand[];
+    readonly Classical: EqualizerBand[];
+    readonly Club: EqualizerBand[];
+    readonly Dance: EqualizerBand[];
+    readonly FullBass: EqualizerBand[];
+    readonly FullBassTreble: EqualizerBand[];
+    readonly FullTreble: EqualizerBand[];
+    readonly Headphones: EqualizerBand[];
+    readonly LargeHall: EqualizerBand[];
+    readonly Live: EqualizerBand[];
+    readonly Party: EqualizerBand[];
+    readonly Pop: EqualizerBand[];
+    readonly Reggae: EqualizerBand[];
+    readonly Rock: EqualizerBand[];
+    readonly Ska: EqualizerBand[];
+    readonly Soft: EqualizerBand[];
+    readonly SoftRock: EqualizerBand[];
+    readonly Techno: EqualizerBand[];
 };
 declare class FFmpegFilterer<Meta = unknown> {
     #private;
     af: GuildQueueAudioFilters<Meta>;
     constructor(af: GuildQueueAudioFilters<Meta>);
+    /**
+     * Create ffmpeg stream
+     * @param source The stream source
+     * @param options The stream options
+     */
+    createStream(source: string | Readable, options: FFmpegStreamOptions): Readable;
+    /**
+     * Set ffmpeg filters
+     * @param filters The filters
+     */
     setFilters(filters: Filters[] | Record<Filters, boolean> | boolean): Promise<boolean>;
+    /**
+     * Currently active ffmpeg filters
+     */
     get filters(): Filters[];
     set filters(filters: Filters[]);
+    /**
+     * Toggle given ffmpeg filter(s)
+     * @param filters The filter(s)
+     */
     toggle(filters: Filters[] | Filters): Promise<boolean>;
+    /**
+     * Set default filters
+     * @param ff Filters list
+     */
+    setDefaults(ff: Filters[]): void;
+    /**
+     * Get list of enabled filters
+     */
     getFiltersEnabled(): (keyof QueueFilters)[];
+    /**
+     * Get list of disabled filters
+     */
     getFiltersDisabled(): (keyof QueueFilters)[];
+    /**
+     * Check if the given filter is enabled
+     * @param filter The filter
+     */
     isEnabled<T extends Filters>(filter: T): boolean;
+    /**
+     * Check if the given filter is disabled
+     * @param filter The filter
+     */
     isDisabled<T extends Filters>(filter: T): boolean;
-    isValidFilter(filter: string): boolean;
+    /**
+     * Check if the given filter is a valid filter
+     * @param filter The filter to test
+     */
+    isValidFilter(filter: string): filter is FiltersName;
+    /**
+     * Convert current filters to array
+     */
+    toArray(): string[];
+    /**
+     * Convert current filters to JSON object
+     */
+    toJSON(): Record<keyof QueueFilters, string>;
+    /**
+     * String representation of current filters
+     */
+    toString(): string;
 }
 interface GuildQueueAFiltersCache {
     equalizer: EqualizerBand[];
@@ -334,50 +515,51 @@ declare class GuildQueueAudioFilters<Meta = unknown> {
     graph: AFilterGraph<Meta>;
     ffmpeg: FFmpegFilterer<Meta>;
     equalizerPresets: {
-        readonly Jazz: {
-            band: number;
-            gain: number;
-        }[];
-        readonly EDM: {
-            band: number;
-            gain: number;
-        }[];
-        readonly HipHop: {
-            band: number;
-            gain: number;
-        }[];
-        readonly Rock: {
-            band: number;
-            gain: number;
-        }[];
-        readonly Metal: {
-            band: number;
-            gain: number;
-        }[];
-        readonly Folk: {
-            band: number;
-            gain: number;
-        }[];
-        readonly RnB: {
-            band: number;
-            gain: number;
-        }[];
-        readonly Country: {
-            band: number;
-            gain: number;
-        }[];
-        readonly Classical: {
-            band: number;
-            gain: number;
-        }[];
+        readonly Flat: EqualizerBand[];
+        readonly Classical: EqualizerBand[];
+        readonly Club: EqualizerBand[];
+        readonly Dance: EqualizerBand[];
+        readonly FullBass: EqualizerBand[];
+        readonly FullBassTreble: EqualizerBand[];
+        readonly FullTreble: EqualizerBand[];
+        readonly Headphones: EqualizerBand[];
+        readonly LargeHall: EqualizerBand[];
+        readonly Live: EqualizerBand[];
+        readonly Party: EqualizerBand[];
+        readonly Pop: EqualizerBand[];
+        readonly Reggae: EqualizerBand[];
+        readonly Rock: EqualizerBand[];
+        readonly Ska: EqualizerBand[];
+        readonly Soft: EqualizerBand[];
+        readonly SoftRock: EqualizerBand[];
+        readonly Techno: EqualizerBand[];
     };
     _lastFiltersCache: GuildQueueAFiltersCache;
     constructor(queue: GuildQueue<Meta>);
+    /**
+     * Volume transformer
+     */
     get volume(): _discord_player_equalizer.VolumeTransformer | null;
+    /**
+     * 15 Band Equalizer
+     */
     get equalizer(): _discord_player_equalizer.EqualizerStream | null;
+    /**
+     * Digital biquad filters
+     */
     get biquad(): _discord_player_equalizer.BiquadStream | null;
+    /**
+     * DSP filters
+     */
     get filters(): _discord_player_equalizer.AudioFilter | null;
+    /**
+     * Audio resampler
+     */
     get resampler(): _discord_player_equalizer.PCMResampler | null;
+    /**
+     * Replay current track in transition mode
+     * @param seek The duration to seek to
+     */
     triggerReplay(seek?: number): Promise<boolean>;
 }
 declare class AFilterGraph<Meta = unknown> {
@@ -408,9 +590,11 @@ interface GuildNodeInit<Meta = unknown> {
     biquad: BiquadFilters | boolean | undefined;
     resampler: number | boolean;
     filterer: PCMFilters[] | boolean;
+    ffmpegFilters: FiltersName[];
     disableHistory: boolean;
     skipOnNoStream: boolean;
     onBeforeCreateStream?: OnBeforeCreateStreamHandler;
+    onAfterCreateStream?: OnAfterCreateStreamHandler;
     repeatMode?: QueueRepeatMode;
     leaveOnEmpty: boolean;
     leaveOnEmptyCooldown: number;
@@ -418,13 +602,22 @@ interface GuildNodeInit<Meta = unknown> {
     leaveOnEndCooldown: number;
     leaveOnStop: boolean;
     leaveOnStopCooldown: number;
+    connectionTimeout: number;
+    selfDeaf?: boolean;
     metadata?: Meta | null;
+    bufferingTimeout: number;
 }
 interface VoiceConnectConfig {
     deaf?: boolean;
     timeout?: number;
 }
+interface PostProcessedResult {
+    stream: Readable;
+    type: StreamType;
+}
 type OnBeforeCreateStreamHandler = (track: Track, queryType: SearchQueryType, queue: GuildQueue) => Promise<Readable | null>;
+type OnAfterCreateStreamHandler = (stream: Readable, queue: GuildQueue) => Promise<PostProcessedResult | null>;
+type PlayerTriggeredReason = 'filters' | 'normal';
 interface GuildQueueEvents<Meta = unknown> {
     /**
      * Emitted when audio track is added to the queue
@@ -496,8 +689,13 @@ interface GuildQueueEvents<Meta = unknown> {
      */
     playerSkip: (queue: GuildQueue<Meta>, track: Track) => unknown;
     /**
-     * Emitted when the voice state is updated.
-     * Consuming this event may disable default voice state update handler if `Player.isVoiceStateHandlerLocked()` returns `false`.
+     * Emitted when the audio player is triggered
+     * @param queue The queue where this event occurred
+     * @param track The track which was played in this event
+     */
+    playerTrigger: (queue: GuildQueue<Meta>, track: Track, reason: PlayerTriggeredReason) => unknown;
+    /**
+     * Emitted when the voice state is updated. Consuming this event may disable default voice state update handler if `Player.isVoiceStateHandlerLocked()` returns `false`.
      * @param queue The queue where this event occurred
      * @param oldState The old voice state
      * @param newState The new voice state
@@ -509,70 +707,137 @@ declare class GuildQueue<Meta = unknown> {
     player: Player;
     options: GuildNodeInit<Meta>;
     private __current;
-    tracks: Queue$1<Track>;
+    tracks: Queue<Track>;
     history: GuildQueueHistory<Meta>;
     dispatcher: StreamDispatcher | null;
     node: GuildQueuePlayerNode<Meta>;
     filters: GuildQueueAudioFilters<Meta>;
     onBeforeCreateStream: OnBeforeCreateStreamHandler;
+    onAfterCreateStream: OnAfterCreateStreamHandler;
     repeatMode: QueueRepeatMode;
     timeouts: Collection<string, NodeJS.Timeout>;
+    stats: GuildQueueStatistics<Meta>;
     constructor(player: Player, options: GuildNodeInit<Meta>);
+    /**
+     * Write a debug message to this queue
+     * @param m The message to write
+     */
     debug(m: string): void;
+    /**
+     * The metadata of this queue
+     */
     get metadata(): Meta | undefined | null;
     set metadata(m: Meta | undefined | null);
+    /**
+     * 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);
+    /**
+     * Indicates current track of this queue
+     */
     get currentTrack(): Track | null;
+    /**
+     * Indicates if this queue was deleted previously
+     */
     get deleted(): boolean;
+    /**
+     * The voice channel of this queue
+     */
     get channel(): VoiceBasedChannel | null;
     set channel(c: VoiceBasedChannel | null);
+    /**
+     * The voice connection of this queue
+     */
     get connection(): _discordjs_voice.VoiceConnection | null;
+    /**
+     * The guild this queue belongs to
+     */
     get guild(): Guild;
+    /**
+     * The id of this queue
+     */
     get id(): string;
+    /**
+     * Set transition mode for this queue
+     * @param state The state to set
+     */
     setTransitioning(state: boolean): void;
+    /**
+     * if this queue is currently under transition mode
+     */
     isTransitioning(): boolean;
+    /**
+     * Set repeat mode for this queue
+     * @param mode The repeat mode to apply
+     */
     setRepeatMode(mode: QueueRepeatMode): void;
+    /**
+     * Check if this queue has no tracks left in it
+     */
     isEmpty(): boolean;
+    /**
+     * Check if this queue currently holds active audio resource
+     */
     isPlaying(): boolean;
+    /**
+     * Add track to the queue
+     * @param track Track or playlist or array of tracks to add
+     */
     addTrack(track: Track | Track[] | Playlist): void;
+    /**
+     * Connect to a voice channel
+     * @param channelResolvable The voice channel to connect to
+     * @param options Join config
+     */
     connect(channelResolvable: GuildVoiceChannelResolvable, options?: VoiceConnectConfig): Promise<this>;
+    /**
+     * The voice connection latency of this queue
+     */
     get ping(): number;
+    /**
+     * Delete this queue
+     */
     delete(): void;
+    /**
+     * Wait for this queue to initialize
+     */
     awaitInitialization(): Promise<boolean>;
 }
 
-interface GuildNodeCreateOptions<T = unknown> {
-    strategy?: QueueStrategy;
-    volume?: number | boolean;
-    equalizer?: EqualizerBand[] | boolean;
-    a_filter?: PCMFilters[] | boolean;
-    biquad?: BiquadFilters | boolean;
-    resampler?: number | boolean;
-    disableHistory?: boolean;
-    skipOnNoStream?: boolean;
-    onBeforeCreateStream?: OnBeforeCreateStreamHandler;
-    repeatMode?: QueueRepeatMode;
-    leaveOnEmpty?: boolean;
-    leaveOnEmptyCooldown?: number;
-    leaveOnEnd?: boolean;
-    leaveOnEndCooldown?: number;
-    leaveOnStop?: boolean;
-    leaveOnStopCooldown?: number;
-    metadata?: T | null;
+interface GuildQueueStatisticsMetadata {
+    latency: {
+        eventLoop: number;
+        voiceConnection: number;
+    };
+    status: {
+        buffering: boolean;
+        playing: boolean;
+        paused: boolean;
+        idle: boolean;
+    };
+    tracksCount: number;
+    historySize: number;
+    extractors: number;
+    listeners: number;
+    memoryUsage: NodeJS.MemoryUsage;
+    versions: {
+        node: string;
+        player: string;
+    };
 }
-type NodeResolvable = GuildQueue | GuildResolvable;
-declare class GuildNodeManager<Meta = unknown> {
-    player: Player;
-    cache: Collection<string, GuildQueue<unknown>>;
-    constructor(player: Player);
-    create<T = Meta>(guild: GuildResolvable, options?: GuildNodeCreateOptions<T>): GuildQueue<T>;
-    get<T = Meta>(node: NodeResolvable): GuildQueue<T> | null;
-    has(node: NodeResolvable): boolean;
-    delete(node: NodeResolvable): boolean;
-    resolve<T = Meta>(node: NodeResolvable): GuildQueue<unknown> | undefined;
-    resolveId(node: NodeResolvable): string | null;
+declare class GuildQueueStatistics<Meta = unknown> {
+    queue: GuildQueue<Meta>;
+    constructor(queue: GuildQueue<Meta>);
+    /**
+     * Generate statistics of this queue
+     */
+    generate(): GuildQueueStatisticsMetadata;
 }
 
 declare class VoiceUtils {
@@ -591,6 +856,7 @@ declare class VoiceUtils {
     connect(channel: VoiceChannel | StageChannel, options?: {
         deaf?: boolean;
         maxTime?: number;
+        queue: GuildQueue;
     }): Promise<StreamDispatcher>;
     /**
      * Joins a voice channel
@@ -666,6 +932,12 @@ declare class BaseExtractor {
      * @param args The data to dispatch
      */
     emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
+    /**
+     * Create extractor response
+     * @param playlist The playlist
+     * @param tracks The track array
+     */
+    createResponse(playlist?: Playlist | null, tracks?: Track[]): ExtractorInfo;
 }
 type NextFunction = (error?: Error | null, stream?: Readable) => void;
 interface ExtractorInfo {
@@ -687,7 +959,7 @@ declare class ExtractorExecutionContext {
     register(_extractor: typeof BaseExtractor): Promise<void>;
     unregister<K extends string | BaseExtractor>(_extractor: K): Promise<void>;
     unregisterAll(): Promise<void>;
-    run<T = unknown>(fn: ExtractorExecutionFN<T>): Promise<ExtractorExecutionResult<T> | null>;
+    run<T = unknown>(fn: ExtractorExecutionFN<T>, filterBlocked?: boolean): Promise<ExtractorExecutionResult<T> | null>;
 }
 interface ExtractorExecutionResult<T = unknown> {
     extractor: BaseExtractor;
@@ -707,16 +979,49 @@ declare class SearchResult {
     player: Player;
     private _data;
     constructor(player: Player, _data: SearchResultData);
+    /**
+     * The search query
+     */
     get query(): string;
+    /**
+     * The search query type
+     */
     get queryType(): SearchQueryType | `ext:${string}`;
+    /**
+     * The extractor
+     */
     get extractor(): BaseExtractor | null;
+    /**
+     * Playlist result
+     */
     get playlist(): Playlist | null | undefined;
+    /**
+     * Tracks result
+     */
     get tracks(): Track[];
+    /**
+     * Requested by
+     */
     get requestedBy(): User | null;
+    /**
+     * Re-execute this search
+     */
     execute(): Promise<SearchResult>;
+    /**
+     * If this search result is empty
+     */
     isEmpty(): boolean;
+    /**
+     * If this search result has playlist
+     */
     hasPlaylist(): boolean;
+    /**
+     * If this search result has tracks
+     */
     hasTracks(): boolean;
+    /**
+     * JSON representation of this search
+     */
     toJSON(): {
         query: string;
         queryType: SearchQueryType | `ext:${string}`;
@@ -727,14 +1032,41 @@ declare class SearchResult {
     };
 }
 
+interface QueryCacheOptions {
+    checkInterval?: number;
+}
+declare class QueryCache {
+    #private;
+    player: Player;
+    options: QueryCacheOptions;
+    timer: NodeJS.Timer;
+    fuse: Fuse<Track>;
+    constructor(player: Player, options?: QueryCacheOptions);
+    get checkInterval(): number;
+    cleanup(): Promise<void>;
+    clear(): Promise<void>;
+    getData(): Promise<DiscordPlayerQueryResultCache<Track>[]>;
+    addData(data: SearchResult): Promise<void>;
+    resolve(context: QueryCacheResolverContext): Promise<SearchResult>;
+}
+declare class DiscordPlayerQueryResultCache<T = unknown> {
+    data: T;
+    expireAfter: number;
+    constructor(data: T, expireAfter?: number);
+    hasExpired(): boolean;
+}
+interface QueryCacheResolverContext {
+    query: string;
+    requestedBy?: User;
+    queryType?: SearchQueryType | `ext:${string}`;
+}
+
 declare class Player extends EventEmitter<PlayerEvents> {
     #private;
+    static _singletonKey: symbol;
+    readonly id: string;
     readonly client: Client;
     readonly options: PlayerInitOptions;
-    /**
-     * @deprecated
-     */
-    readonly queues: Collection<string, Queue<unknown>>;
     nodes: GuildNodeManager<unknown>;
     readonly voiceUtils: VoiceUtils;
     requiredEvents: string[];
@@ -747,35 +1079,45 @@ declare class Player extends EventEmitter<PlayerEvents> {
      */
     constructor(client: Client, options?: PlayerInitOptions);
     /**
-     * Event loop lag
-     * @type {number}
+     * Creates discord-player singleton instance.
+     * @param client The client that instantiated player
+     * @param options Player initializer options
      */
-    get eventLoopLag(): number;
+    static singleton(client: Client, options?: PlayerInitOptions): Player;
     /**
-     * Generates statistics
+     * Get all active player instances
      */
-    generateStatistics(): {
-        guild: string;
-        memory: NodeJS.MemoryUsage;
-        tracks: number;
-        os: {
-            cpuCount: number;
-            totalMem: number;
-            freeMem: number;
-            platform: NodeJS.Platform;
-        };
-        isShard: boolean;
-        latency: {
-            client: number;
-            udp: number | undefined;
-            ws: number | undefined;
-            eventLoop: number;
-        };
-        subscribers: number;
-        connections: number;
-        extractors: number;
-    }[];
-    private _handleVoiceStateLegacy;
+    static getAllPlayers(): Player[];
+    /**
+     * Clear all player instances
+     */
+    static clearAllPlayers(): void;
+    /**
+     * The current query cache provider
+     */
+    get queryCache(): QueryCache | null;
+    /**
+     * Alias to `Player.nodes`
+     */
+    get queues(): GuildNodeManager<unknown>;
+    /**
+     * Event loop lag
+     * @type {number}
+     */
+    get eventLoopLag(): number;
+    /**
+     * Generates statistics
+     */
+    generateStatistics(): {
+        instances: number;
+        queuesCount: number;
+        queryCacheEnabled: boolean;
+        queues: GuildQueueStatisticsMetadata[];
+    };
+    /**
+     * Destroy player
+     */
+    destroy(): Promise<void>;
     private _handleVoiceState;
     /**
      * Handles voice state update
@@ -784,48 +1126,23 @@ declare class Player extends EventEmitter<PlayerEvents> {
      * @returns {void}
      */
     handleVoiceState(oldState: VoiceState, newState: VoiceState): void;
-    lockVoiceStateHandler(): void;
-    unlockVoiceStateHandler(): void;
-    isVoiceStateHandlerLocked(): boolean;
     /**
-     * Creates a queue for a guild if not available, else returns existing queue
-     * @param {GuildResolvable} guild The guild
-     * @param {PlayerOptions} queueInitOptions Queue init options
-     * @returns {Queue}
+     * Lock voice state handler
      */
-    createQueue<T = unknown>(guild: GuildResolvable, queueInitOptions?: PlayerOptions & {
-        metadata?: T;
-    }): Queue<T>;
+    lockVoiceStateHandler(): void;
     /**
-     * Returns the queue if available
-     * @param {GuildResolvable} guild The guild id
-     * @returns {Queue | undefined}
+     * Unlock voice state handler
      */
-    getQueue<T = unknown>(guild: GuildResolvable): Queue<T> | undefined;
+    unlockVoiceStateHandler(): void;
     /**
-     * Deletes a queue and returns deleted queue object
-     * @param {GuildResolvable} guild The guild id to remove
-     * @returns {Queue}
+     * Checks if voice state handler is locked
      */
-    deleteQueue<T = unknown>(guild: GuildResolvable): Queue<T>;
+    isVoiceStateHandlerLocked(): boolean;
     /**
      * Initiate audio player
      * @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 ```js
-     * const client = new Discord.Client({ intents: ['GuildVoiceStates'] });
-     * const player = new Player(client);
-     *
-     * // play
-     * const query = message.getQuerySomehow();
-     *
-     * await player.play(message.member.voice.channel, query, {
-     *     nodeOptions: {
-     *         metadata: message
-     *     }
-     * });
-     * ```
      */
     play<T = unknown>(channel: GuildVoiceChannelResolvable, query: string | Track | SearchResult, options?: SearchOptions & {
         nodeOptions?: GuildNodeCreateOptions<T>;
@@ -854,14 +1171,7 @@ declare class Player extends EventEmitter<PlayerEvents> {
      */
     scanDeps(): string;
     emit<U extends keyof PlayerEvents>(eventName: U, ...args: Parameters<PlayerEvents[U]>): boolean;
-    /**
-     * Resolves queue
-     * @param {GuildResolvable|Queue} queueLike Queue like object
-     * @returns {Queue}
-     * @deprecated
-     */
-    resolveQueue<T>(queueLike: GuildResolvable | Queue): Queue<T>;
-    [Symbol.iterator](): Generator<Queue<unknown> | GuildQueue<unknown>, void, undefined>;
+    [Symbol.iterator](): Generator<GuildQueue<unknown>, void, undefined>;
     /**
      * Creates `Playlist` instance
      * @param data The data to initialize a playlist
@@ -869,297 +1179,97 @@ declare class Player extends EventEmitter<PlayerEvents> {
     createPlaylist(data: PlaylistInitData): Playlist;
 }
 
-/**
- * @deprecated use GuildQueue instead
- */
-declare class Queue<T = unknown> {
-    #private;
-    readonly guild: Guild;
-    readonly player: Player;
-    connection: StreamDispatcher;
-    tracks: Track[];
-    previousTracks: Track[];
-    options: PlayerOptions;
-    playing: boolean;
+interface GuildNodeCreateOptions<T = unknown> {
+    strategy?: QueueStrategy;
+    volume?: number | boolean;
+    equalizer?: EqualizerBand[] | boolean;
+    a_filter?: PCMFilters[] | boolean;
+    biquad?: BiquadFilters | boolean;
+    resampler?: number | boolean;
+    disableHistory?: boolean;
+    skipOnNoStream?: boolean;
+    onBeforeCreateStream?: OnBeforeCreateStreamHandler;
+    onAfterCreateStream?: OnAfterCreateStreamHandler;
+    repeatMode?: QueueRepeatMode;
+    leaveOnEmpty?: boolean;
+    leaveOnEmptyCooldown?: number;
+    leaveOnEnd?: boolean;
+    leaveOnEndCooldown?: number;
+    leaveOnStop?: boolean;
+    leaveOnStopCooldown?: number;
     metadata?: T | null;
-    repeatMode: QueueRepeatMode;
-    readonly id: string;
-    private _streamTime;
-    _cooldownsTimeout: Collection<string, NodeJS.Timeout>;
-    private _activeFilters;
-    private _filtersUpdate;
-    private _lastEQBands;
-    private _lastAudioFilters;
-    private _lastBiquadFilter;
-    onBeforeCreateStream: (track: Track, source: SearchQueryType, queue: Queue) => Promise<Readable | undefined>;
-    /**
-     * Queue constructor
-     * @param {Player} player The player that instantiated this queue
-     * @param {Guild} guild The guild that instantiated this queue
-     * @param {PlayerOptions} [options] Player options for the queue
-     */
-    constructor(player: Player, guild: Guild, options?: PlayerOptions);
-    /**
-     * The PCM filterer
-     */
-    get filters(): _discord_player_equalizer.AudioFilter | null;
-    get equalizer(): _discord_player_equalizer.EqualizerStream | null;
-    get biquad(): _discord_player_equalizer.BiquadStream | null;
-    /**
-     * Forces next play
-     * @returns {Promise<void>}
-     */
-    forceNext(): Promise<void>;
-    /**
-     * Returns current track
-     * @type {Track}
-     */
-    get current(): Track | undefined;
-    /**
-     * If this queue is destroyed
-     * @type {boolean}
-     */
-    get destroyed(): boolean;
-    /**
-     * Returns current track
-     * @returns {Track}
-     */
-    nowPlaying(): Track | undefined;
-    /**
-     * Connects to a voice channel
-     * @param {GuildChannelResolvable} channel The voice/stage channel
-     * @returns {Promise<Queue>}
-     */
-    connect(channel: GuildChannelResolvable): Promise<this | undefined>;
-    private emitEnd;
-    private refreshEndCooldown;
-    /**
-     * Destroys this queue
-     * @param {boolean} [disconnect=this.options.leaveOnStop] If it should leave on destroy
-     * @returns {void}
-     */
-    destroy(disconnect?: boolean | undefined): void;
-    /**
-     * Skips current track
-     * @returns {boolean}
-     */
-    skip(): boolean | undefined;
-    /**
-     * Adds single track to the queue
-     * @param {Track} track The track to add
-     * @returns {void}
-     */
-    addTrack(track: Track): void;
-    /**
-     * Adds multiple tracks to the queue
-     * @param {Track[]} tracks Array of tracks to add
-     */
-    addTracks(tracks: Track[]): void;
-    /**
-     * Sets paused state
-     * @param {boolean} paused The paused state
-     * @returns {boolean}
-     */
-    setPaused(paused?: boolean): boolean;
-    /**
-     * If the player is currently paused
-     */
-    get paused(): boolean;
-    set paused(val: boolean);
-    /**
-     * Pause the playback
-     */
-    pause(): boolean;
-    /**
-     * Resume the playback
-     */
-    resume(): boolean;
-    /**
-     * Sets bitrate
-     * @param  {number|auto} bitrate bitrate to set
-     * @returns {void}
-     */
-    setBitrate(bitrate: number | 'auto'): void;
-    /**
-     * Sets volume
-     * @param {number} amount The volume amount
-     * @returns {boolean}
-     */
-    setVolume(amount: number): boolean | undefined;
-    /**
-     * Sets repeat mode
-     * @param  {QueueRepeatMode} mode The repeat mode
-     * @returns {boolean}
-     */
-    setRepeatMode(mode: QueueRepeatMode): boolean | undefined;
-    /**
-     * The current volume amount
-     * @type {number}
-     */
-    get volume(): number;
-    set volume(amount: number);
-    /**
-     * The stream time of this queue
-     * @type {number}
-     */
-    get streamTime(): number;
-    set streamTime(time: number);
-    /**
-     * Returns enabled filters
-     * @returns {AudioFilters}
-     */
-    getFiltersEnabled(): (keyof QueueFilters)[] | undefined;
-    /**
-     * Returns disabled filters
-     * @returns {AudioFilters}
-     */
-    getFiltersDisabled(): (keyof QueueFilters)[] | undefined;
-    /**
-     * Sets filters
-     * @param {QueueFilters} filters Queue filters
-     * @returns {Promise<void>}
-     */
-    setFilters(filters?: QueueFilters): Promise<void>;
-    /**
-     * Seeks to the given time
-     * @param {number} position The position
-     * @returns {boolean}
-     */
-    seek(position: number): Promise<boolean | undefined>;
-    /**
-     * Plays previous track
-     * @returns {Promise<void>}
-     */
-    back(): Promise<void>;
-    /**
-     * Clear this queue
-     */
-    clear(): void;
-    /**
-     * Stops the player
-     * @returns {void}
-     */
-    stop(): void;
-    /**
-     * Shuffles this queue
-     * @returns {boolean}
-     */
-    shuffle(): boolean | undefined;
-    /**
-     * Removes a track from the queue
-     * @param {Track|string|number} track The track to remove
-     * @returns {Track}
-     */
-    remove(track: Track | string | number): Track | undefined;
-    /**
-     * Returns the index of the specified track. If found, returns the track index else returns -1.
-     * @param {number|Track|string} track The track
-     * @returns {number}
-     */
-    getTrackPosition(track: number | Track | string): number | undefined;
-    /**
-     * Jumps to particular track
-     * @param {Track|number} track The track
-     * @returns {void}
-     */
-    jump(track: Track | number): void;
-    /**
-     * Jumps to particular track, removing other tracks on the way
-     * @param {Track|number} track The track
-     * @returns {void}
-     */
-    skipTo(track: Track | number): void;
-    /**
-     * Inserts the given track to specified index
-     * @param {Track} track The track to insert
-     * @param {number} [index=0] The index where this track should be
-     */
-    insert(track: Track, index?: number): void;
-    /**
-     * @typedef {object} PlayerTimestamp
-     * @property {string} current The current progress
-     * @property {string} end The total time
-     * @property {number} progress Progress in %
-     */
-    /**
-     * Returns player stream timestamp
-     * @returns {PlayerTimestamp}
-     */
-    getPlayerTimestamp(): {
-        current: string;
-        end: string;
-        progress: number;
-    } | undefined;
-    /**
-     * Creates progress bar string
-     * @param {PlayerProgressbarOptions} options The progress bar options
-     * @returns {string}
-     */
-    createProgressBar(options?: PlayerProgressbarOptions): string | undefined;
+    selfDeaf?: boolean;
+    connectionTimeout?: number;
+    defaultFFmpegFilters?: FiltersName[];
+    bufferingTimeout?: number;
+}
+type NodeResolvable = GuildQueue | GuildResolvable;
+declare class GuildNodeManager<Meta = unknown> {
+    player: Player;
+    cache: Collection<string, GuildQueue<unknown>>;
+    constructor(player: Player);
     /**
-     * Total duration
-     * @type {Number}
+     * Create guild queue if it does not exist
+     * @param guild The guild which will be the owner of the queue
+     * @param options Queue initializer options
      */
-    get totalTime(): number;
+    create<T = Meta>(guild: GuildResolvable, options?: GuildNodeCreateOptions<T>): GuildQueue<T>;
     /**
-     * Generates statistics
+     * Get existing queue
+     * @param node Queue resolvable
      */
-    generateStatistics(): {
-        guild: string;
-        memory: NodeJS.MemoryUsage;
-        tracks: number;
-        os: {
-            cpuCount: number;
-            totalMem: number;
-            freeMem: number;
-            platform: NodeJS.Platform;
-        };
-        isShard: boolean;
-        latency: {
-            client: number;
-            udp: number | undefined;
-            ws: number | undefined;
-            eventLoop: number;
-        };
-        subscribers: number;
-        connections: number;
-        extractors: number;
-    };
+    get<T = Meta>(node: NodeResolvable): GuildQueue<T> | null;
     /**
-     * Voice connection latency in ms
-     * @type {number}
+     * Check if a queue exists
+     * @param node Queue resolvable
      */
-    get ping(): number | undefined;
+    has(node: NodeResolvable): boolean;
     /**
-     * Play stream in a voice/stage channel
-     * @param {Track} [src] The track to play (if empty, uses first track from the queue)
-     * @param {PlayOptions} [options] The options
-     * @returns {Promise<void>}
+     * Delete queue
+     * @param node Queue resolvable
      */
-    play(src?: Track, options?: PlayOptions): Promise<void>;
+    delete(node: NodeResolvable): boolean;
     /**
-     * Private method to handle autoplay
-     * @param {Track} track The source track to find its similar track for autoplay
-     * @returns {Promise<void>}
-     * @private
+     * Resolve queue
+     * @param node Queue resolvable
      */
-    private _handleAutoplay;
-    [Symbol.iterator](): Generator<Track, void, undefined>;
+    resolve<T = Meta>(node: NodeResolvable): GuildQueue<unknown> | undefined;
     /**
-     * JSON representation of this queue
-     * @returns {object}
+     * Resolve queue id
+     * @param node Queue resolvable
      */
+    resolveId(node: NodeResolvable): string | null;
+}
+
+declare enum ErrorStatusCode {
+    STREAM_ERROR = "StreamError",
+    AUDIO_PLAYER_ERROR = "AudioPlayerError",
+    PLAYER_ERROR = "PlayerError",
+    NO_AUDIO_RESOURCE = "NoAudioResource",
+    UNKNOWN_GUILD = "UnknownGuild",
+    INVALID_ARG_TYPE = "InvalidArgType",
+    UNKNOWN_EXTRACTOR = "UnknownExtractor",
+    INVALID_EXTRACTOR = "InvalidExtractor",
+    INVALID_CHANNEL_TYPE = "InvalidChannelType",
+    INVALID_TRACK = "InvalidTrack",
+    UNKNOWN_REPEAT_MODE = "UnknownRepeatMode",
+    TRACK_NOT_FOUND = "TrackNotFound",
+    NO_CONNECTION = "NoConnection",
+    DESTROYED_QUEUE = "DestroyedQueue"
+}
+declare class PlayerError extends Error {
+    message: string;
+    statusCode: ErrorStatusCode;
+    createdAt: Date;
+    constructor(message: string, code?: ErrorStatusCode);
+    get createdTimestamp(): number;
+    valueOf(): ErrorStatusCode;
     toJSON(): {
-        id: string;
-        guild: string;
-        voiceChannel: string;
-        options: PlayerOptions;
-        tracks: TrackJSON[];
-    } | undefined;
-    /**
-     * String representation of this queue
-     * @returns {string}
-     */
+        stack: string | undefined;
+        code: ErrorStatusCode;
+        message: string;
+        created: number;
+    };
     toString(): string | undefined;
 }
 
@@ -1205,6 +1315,7 @@ interface QueueFilters {
     fadein?: boolean;
     dim?: boolean;
     earrape?: boolean;
+    lofi?: boolean;
 }
 /**
  * The track source:
@@ -1276,107 +1387,6 @@ interface PlayerProgressbarOptions {
     indicator?: string;
     queue?: boolean;
 }
-/**
- * @typedef {object} PlayerOptions
- * @property {boolean} [leaveOnEnd=true] If it should leave on end
- * @property {boolean} [leaveOnStop=true] If it should leave on stop
- * @property {boolean} [leaveOnEmpty=true] If it should leave on empty
- * @property {number} [leaveOnEmptyCooldown=1000] The cooldown in ms
- * @property {number} [leaveOnEndCooldown=1000] The cooldown in ms
- * @property {boolean} [autoSelfDeaf=true] If it should set the bot in deaf mode
- * @property {YTDLDownloadOptions} [ytdlOptions] The youtube download options
- * @property {number} [initialVolume=100] The initial player volume
- * @property {number} [bufferingTimeout=3000] Buffering timeout for the stream
- * @property {boolean} [spotifyBridge=true] If player should bridge spotify source to youtube
- * @property {boolean} [disableVolume=false] If player should disable inline volume
- * @property {boolean} [disableEqualizer=false] If player should disable equalizer
- * @property {boolean} [disableBiquad=false] If player should disable biquad
- * @property {number} [volumeSmoothness=0] The volume transition smoothness between volume changes (lower the value to get better result)
- * Setting this or leaving this empty will disable this effect. Example: `volumeSmoothness: 0.1`
- * @property {EqualizerBand[]} [equalizerBands] The equalizer bands array for 15 band equalizer.
- * @property {BiquadFilters} [biquadFilter] The biquad filter initializer value
- * @property {boolean} [disableFilters] Disable/enable PCM filter
- * @property {PCMFilters[]} [defaultFilters] The PCM filters initializer
- * @property {Function} [onBeforeCreateStream] Runs before creating stream
- */
-interface PlayerOptions {
-    leaveOnEnd?: boolean;
-    leaveOnEndCooldown?: number;
-    leaveOnStop?: boolean;
-    leaveOnEmpty?: boolean;
-    leaveOnEmptyCooldown?: number;
-    autoSelfDeaf?: boolean;
-    ytdlOptions?: downloadOptions;
-    initialVolume?: number;
-    bufferingTimeout?: number;
-    spotifyBridge?: boolean;
-    disableVolume?: boolean;
-    disableEqualizer?: boolean;
-    disableBiquad?: boolean;
-    volumeSmoothness?: number;
-    equalizerBands?: EqualizerBand[];
-    biquadFilter?: BiquadFilters;
-    disableFilters?: boolean;
-    defaultFilters?: PCMFilters[];
-    onBeforeCreateStream?: (track: Track, source: SearchQueryType, queue: Queue) => Promise<Readable>;
-}
-/**
- * @typedef {object} ExtractorModelData
- * @property {object} [playlist] The playlist info (if any)
- * @property {string} [playlist.title] The playlist title
- * @property {string} [playlist.description] The playlist description
- * @property {string} [playlist.thumbnail] The playlist thumbnail
- * @property {album|playlist} [playlist.type] The playlist type: `album` | `playlist`
- * @property {TrackSource} [playlist.source] The playlist source
- * @property {object} [playlist.author] The playlist author
- * @property {string} [playlist.author.name] The author name
- * @property {string} [playlist.author.url] The author url
- * @property {string} [playlist.id] The playlist id
- * @property {string} [playlist.url] The playlist url
- * @property {any} [playlist.rawPlaylist] The raw data
- * @property {ExtractorData[]} data The data
- */
-/**
- * @typedef {object} ExtractorData
- * @property {string} title The title
- * @property {number} duration The duration
- * @property {string} thumbnail The thumbnail
- * @property {string|Readable|Duplex} engine The stream engine
- * @property {number} views The views count
- * @property {string} author The author
- * @property {string} description The description
- * @property {string} url The url
- * @property {string} [version] The extractor version
- * @property {TrackSource} [source="arbitrary"] The source
- */
-interface ExtractorModelData {
-    playlist?: {
-        title: string;
-        description: string;
-        thumbnail: string;
-        type: 'album' | 'playlist';
-        source: TrackSource;
-        author: {
-            name: string;
-            url: string;
-        };
-        id: string;
-        url: string;
-        rawPlaylist?: any;
-    };
-    data: {
-        title: string;
-        duration: number;
-        thumbnail: string;
-        engine: string | Readable | Duplex;
-        views: number;
-        author: string;
-        description: string;
-        url: string;
-        version?: string;
-        source?: TrackSource;
-    }[];
-}
 /**
  * The search query type
  * This can be one of:
@@ -1425,90 +1435,10 @@ declare const QueryType: {
     readonly FILE: "file";
 };
 type SearchQueryType = keyof typeof QueryType | (typeof QueryType)[keyof typeof QueryType];
-/**
- * Emitted when bot gets disconnected from a voice channel
- * @event Player#botDisconnect
- * @param {Queue} queue The queue
- */
-/**
- * Emitted when the voice channel is empty
- * @event Player#channelEmpty
- * @param {Queue} queue The queue
- */
-/**
- * Emitted when bot connects to a voice channel
- * @event Player#connectionCreate
- * @param {Queue} queue The queue
- * @param {StreamDispatcher} connection The discord player connection object
- */
-/**
- * Debug information
- * @event Player#debug
- * @param {Queue} queue The queue
- * @param {string} message The message
- */
-/**
- * Emitted on error
- * <warn>This event should handled properly otherwise it may crash your process!</warn>
- * @event Player#error
- * @param {Queue} queue The queue
- * @param {Error} error The error
- */
-/**
- * Emitted on connection error. Sometimes stream errors are emitted here as well.
- * @event Player#connectionError
- * @param {Queue} queue The queue
- * @param {Error} error The error
- */
-/**
- * Emitted when queue ends
- * @event Player#queueEnd
- * @param {Queue} queue The queue
- */
-/**
- * Emitted when a single track is added
- * @event Player#trackAdd
- * @param {Queue} queue The queue
- * @param {Track} track The track
- */
-/**
- * Emitted when multiple tracks are added
- * @event Player#tracksAdd
- * @param {Queue} queue The queue
- * @param {Track[]} tracks The tracks
- */
-/**
- * Emitted when a track starts playing
- * @event Player#trackStart
- * @param {Queue} queue The queue
- * @param {Track} track The track
- */
-/**
- * Emitted when a track ends
- * @event Player#trackEnd
- * @param {Queue} queue The queue
- * @param {Track} track The track
- */
-/**
- * Emitted when voice state updates. Listen to this event to modify internal voice state update handler.
- * @event Player#voiceStateUpdate
- * @param {Queue} queue The queue that this update belongs to
- * @param {VoiceState} oldState The old voice state
- * @param {VoiceState} newState The new voice state
- */
 interface PlayerEvents {
-    botDisconnect: (queue: Queue) => any;
-    channelEmpty: (queue: Queue) => any;
-    connectionCreate: (queue: Queue, connection: StreamDispatcher) => any;
-    debug: (queue: Queue, message: string) => any;
-    error: (queue: Queue, error: Error) => any;
-    connectionError: (queue: Queue, error: Error) => any;
-    queueEnd: (queue: Queue) => any;
-    trackAdd: (queue: Queue, track: Track) => any;
-    tracksAdd: (queue: Queue, track: Track[]) => any;
-    trackStart: (queue: Queue, track: Track) => any;
-    trackEnd: (queue: Queue, track: Track) => any;
-    voiceStateUpdate: (queue: Queue, oldState: VoiceState, newState: VoiceState) => any;
+    debug: (message: string) => any;
+    error: (error: Error) => any;
+    voiceStateUpdate: (queue: GuildQueue, oldState: VoiceState, newState: VoiceState) => any;
 }
 /**
  * @typedef {object} PlayOptions
@@ -1528,12 +1458,14 @@ 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 {boolean} [blockExtractors[]] List of the extractors to block
+ * @property {string[]} [blockExtractors[]] List of the extractors to block
+ * @property {boolean} [ignoreCache] If it should ignore query cache lookup
  */
 interface SearchOptions {
     requestedBy?: UserResolvable;
     searchEngine?: SearchQueryType | QueryExtractorSearch;
     blockExtractors?: string[];
+    ignoreCache?: boolean;
 }
 /**
  * The queue repeat mode. This can be one of:
@@ -1641,7 +1573,9 @@ interface PlaylistJSON {
  * @property {boolean} [smoothVolume=true] Toggle smooth volume transition
  * @property {boolean} [lagMonitor=30000] Time in ms to re-monitor event loop lag
  * @property {boolean} [lockVoiceStateHandler] Prevent voice state handler from being overridden
- * @property {string[]} [blockExtractors] List of extractors to block
+ * @property {string[]} [blockExtractors] List of extractors to disable querying metadata from
+ * @property {string[]} [blockStreamFrom] List of extractors to disable streaming from
+ * @property {QueryCache | null} [queryCache] Query cache provider
  */
 interface PlayerInitOptions {
     autoRegisterExtractor?: boolean;
@@ -1651,6 +1585,8 @@ interface PlayerInitOptions {
     lagMonitor?: number;
     lockVoiceStateHandler?: boolean;
     blockExtractors?: string[];
+    blockStreamFrom?: string[];
+    queryCache?: QueryCache | null;
 }
 
 declare class AudioFilters {
@@ -1687,70 +1623,6 @@ declare class AudioFilters {
     }[]): void;
 }
 
-declare enum ErrorStatusCode {
-    STREAM_ERROR = "StreamError",
-    AUDIO_PLAYER_ERROR = "AudioPlayerError",
-    PLAYER_ERROR = "PlayerError",
-    NO_AUDIO_RESOURCE = "NoAudioResource",
-    UNKNOWN_GUILD = "UnknownGuild",
-    INVALID_ARG_TYPE = "InvalidArgType",
-    UNKNOWN_EXTRACTOR = "UnknownExtractor",
-    INVALID_EXTRACTOR = "InvalidExtractor",
-    INVALID_CHANNEL_TYPE = "InvalidChannelType",
-    INVALID_TRACK = "InvalidTrack",
-    UNKNOWN_REPEAT_MODE = "UnknownRepeatMode",
-    TRACK_NOT_FOUND = "TrackNotFound",
-    NO_CONNECTION = "NoConnection",
-    DESTROYED_QUEUE = "DestroyedQueue"
-}
-declare class PlayerError extends Error {
-    message: string;
-    statusCode: ErrorStatusCode;
-    createdAt: Date;
-    constructor(message: string, code?: ErrorStatusCode);
-    get createdTimestamp(): number;
-    valueOf(): ErrorStatusCode;
-    toJSON(): {
-        stack: string | undefined;
-        code: ErrorStatusCode;
-        message: string;
-        created: number;
-    };
-    toString(): string | undefined;
-}
-
-declare class QueryResolver {
-    /**
-     * Query resolver
-     */
-    private constructor();
-    static get regex(): {
-        spotifyAlbumRegex: RegExp;
-        spotifyPlaylistRegex: RegExp;
-        spotifySongRegex: RegExp;
-        vimeoRegex: RegExp;
-        reverbnationRegex: RegExp;
-        attachmentRegex: RegExp;
-        appleMusicAlbumRegex: RegExp;
-        appleMusicPlaylistRegex: RegExp;
-        appleMusicSongRegex: RegExp;
-    };
-    /**
-     * Resolves the given search query
-     * @param {string} query The query
-     * @returns {QueryType}
-     */
-    static resolve(query: string): (typeof QueryType)[keyof typeof QueryType];
-    /**
-     * Parses vimeo id from url
-     * @param {string} query The query
-     * @returns {string}
-     */
-    static getVimeoID(query: string): string | null | undefined;
-    static validateId(q: string): boolean;
-    static validateURL(q: string): boolean;
-}
-
 declare class Util {
     /**
      * Utils
@@ -1803,21 +1675,6 @@ declare class Util {
     static warn(message: string, code?: string, detail?: string): void;
 }
 
-interface FFmpegStreamOptions {
-    fmt?: string;
-    encoderArgs?: string[];
-    seek?: number;
-    skip?: boolean;
-}
-declare function FFMPEG_ARGS_STRING(stream: string, fmt?: string): string[];
-declare function FFMPEG_ARGS_PIPED(fmt?: string): string[];
-/**
- * Creates FFmpeg stream
- * @param stream The source stream
- * @param options FFmpeg stream options
- */
-declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable;
-
 declare const version: string;
 
-export { AFilterGraph, AudioFilters, BaseExtractor, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorModelData, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvents, PlayerInitOptions, PlayerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, Playlist, PlaylistInitData, PlaylistJSON, QueryExtractorSearch, QueryResolver, QueryType, Queue, QueueFilters, QueueRepeatMode, RawTrackData, ResourcePlayOptions, SearchOptions, SearchQueryType, StreamDispatcher, TimeData, Track, TrackJSON, TrackResolvable, TrackSource, Util, VoiceConnectConfig, VoiceEvents, VoiceUtils, createFFmpegStream, version };
+export { AFilterGraph, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvents, PlayerInitOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamDispatcher, TimeData, Track, TrackJSON, TrackResolvable, TrackSource, Util, VoiceConnectConfig, VoiceEvents, VoiceUtils, createFFmpegStream, version };