discord-player 5.3.2 → 5.4.1-dev.0

package/dist/index.d.ts

@@ -1,8 +1,10 @@
-/// <reference types="node" />
-import { User, VoiceChannel, StageChannel, Collection, Snowflake, Client, GuildResolvable, Guild, GuildChannelResolvable, UserResolvable } from 'discord.js';
+import { User, VoiceChannel, StageChannel, Snowflake, Client, GuildResolvable, Guild, GuildChannelResolvable, VoiceState, UserResolvable } from 'discord.js';
 import { Readable, Duplex, TransformOptions, Transform } from 'stream';
+import * as _discord_player_equalizer from '@discord-player/equalizer';
+import { PCMFilters, EqualizerStream, BiquadStream, AudioFilter, EqualizerBand, BiquadFilters } from '@discord-player/equalizer';
 import { TypedEmitter } from 'tiny-typed-emitter';
-import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, StreamType, AudioPlayerStatus } from '@discordjs/voice';
+import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, StreamType } from '@discordjs/voice';
+import { Collection } from '@discord-player/utils';
 import { downloadOptions } from 'ytdl-core';
 
 declare class Playlist {
@@ -11,7 +13,7 @@ declare class Playlist {
     title: string;
     description: string;
     thumbnail: string;
-    type: "album" | "playlist";
+    type: 'album' | 'playlist';
     source: TrackSource;
     author: {
         name: string;
@@ -44,8 +46,9 @@ declare class Track {
     thumbnail: string;
     duration: string;
     views: number;
-    requestedBy: User;
+    requestedBy: User | null;
     playlist?: Playlist;
+    queryType: SearchQueryType | null | undefined;
     readonly raw: RawTrackData;
     readonly id: string;
     /**
@@ -82,20 +85,34 @@ declare class Track {
     toJSON(hidePlaylist?: boolean): TrackJSON;
 }
 
+interface CreateStreamOps {
+    type?: StreamType;
+    data?: any;
+    disableVolume?: boolean;
+    disableEqualizer?: boolean;
+    disableBiquad?: boolean;
+    eq?: EqualizerBand[];
+    biquadFilter?: BiquadFilters;
+    disableFilters?: boolean;
+    defaultFilters?: PCMFilters[];
+}
 interface VoiceEvents {
     error: (error: AudioPlayerError) => any;
     debug: (message: string) => any;
     start: (resource: AudioResource<Track>) => any;
     finish: (resource: AudioResource<Track>) => any;
+    audioFilters: (filters: PCMFilters[]) => any;
 }
 declare class StreamDispatcher extends TypedEmitter<VoiceEvents> {
     readonly connectionTimeout: number;
     readonly voiceConnection: VoiceConnection;
     readonly audioPlayer: AudioPlayer;
     channel: VoiceChannel | StageChannel;
-    audioResource?: AudioResource<Track>;
+    audioResource?: AudioResource<Track> | null;
     private readyLock;
-    paused: boolean;
+    equalizer: EqualizerStream | null;
+    biquad: BiquadStream | null;
+    audioFilters: AudioFilter | null;
     /**
      * Creates new connection object
      * @param {VoiceConnection} connection The connection
@@ -103,17 +120,34 @@ declare class StreamDispatcher extends TypedEmitter<VoiceEvents> {
      * @private
      */
     constructor(connection: VoiceConnection, channel: VoiceChannel | StageChannel, connectionTimeout?: number);
+    /**
+     * Check if the player has been paused manually
+     */
+    get paused(): boolean;
+    set paused(val: boolean);
+    /**
+     * Whether or not the player is currently paused automatically or manually.
+     */
+    isPaused(): boolean;
+    /**
+     * Whether or not the player is currently buffering
+     */
+    isBuffering(): boolean;
+    /**
+     * Whether or not the player is currently playing
+     */
+    isPlaying(): boolean;
+    /**
+     * Whether or not the player is currently idle
+     */
+    isIdle(): boolean;
     /**
      * Creates stream
      * @param {Readable|Duplex|string} src The stream source
      * @param {object} [ops] Options
      * @returns {AudioResource}
      */
-    createStream(src: Readable | Duplex | string, ops?: {
-        type?: StreamType;
-        data?: any;
-        disableVolume?: boolean;
-    }): AudioResource<Track>;
+    createStream(src: Readable | Duplex | string, ops?: CreateStreamOps): AudioResource<Track>;
     /**
      * The player status
      * @type {AudioPlayerStatus}
@@ -145,7 +179,7 @@ declare class StreamDispatcher extends TypedEmitter<VoiceEvents> {
      * @param {AudioResource<Track>} [resource=this.audioResource] The audio resource to play
      * @returns {Promise<StreamDispatcher>}
      */
-    playStream(resource?: AudioResource<Track>): Promise<this>;
+    playStream(resource?: AudioResource<Track>): Promise<this | undefined>;
     /**
      * Sets playback volume
      * @param {number} value The volume amount
@@ -202,35 +236,118 @@ declare class VoiceUtils {
      * @param {Snowflake} guild The guild id
      * @returns {StreamDispatcher}
      */
-    getConnection(guild: Snowflake): StreamDispatcher;
+    getConnection(guild: Snowflake): StreamDispatcher | undefined;
 }
 
-declare class ExtractorModel {
-    name: string;
-    private _raw;
+declare class BaseExtractor {
+    context: ExtractorExecutionContext;
     /**
-     * Model for raw Discord Player extractors
-     * @param {string} extractorName Name of the extractor
-     * @param {object} data Extractor object
+     * Identifier for this extractor
      */
-    constructor(extractorName: string, data: any);
+    static identifier: string;
     /**
-     * Method to handle requests from `Player.play()`
-     * @param {string} query Query to handle
-     * @returns {Promise<ExtractorModelData>}
+     * Extractor constructor
+     * @param context Context that instantiated this extractor
      */
-    handle(query: string): Promise<ExtractorModelData>;
+    constructor(context: ExtractorExecutionContext);
     /**
-     * Method used by Discord Player to validate query with this extractor
-     * @param {string} query The query to validate
-     * @returns {boolean}
+     * Identifier of this extractor
      */
-    validate(query: string): boolean;
+    get identifier(): string;
     /**
-     * The extractor version
-     * @type {string}
+     * This method will be executed when this extractor is activated
      */
-    get version(): string;
+    activate(): Promise<void>;
+    /**
+     * This method will be executed when this extractor is deactivated
+     */
+    deactivate(): Promise<void>;
+    /**
+     * Validate incoming query
+     * @param query The query to validate
+     */
+    validate(query: string, type?: SearchQueryType | null): Promise<boolean>;
+    /**
+     * Stream the given track
+     * @param info The track to stream
+     */
+    stream(info: Track): Promise<Readable | string>;
+    /**
+     * Handle the given query
+     * @param query The query to handle
+     */
+    handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo>;
+    /**
+     * A stream middleware to handle streams before passing it to the player
+     * @param stream The incoming stream
+     * @param next The next function
+     */
+    handlePostStream(stream: Readable, next: NextFunction): void;
+    /**
+     * Dispatch an event to the player
+     * @param event The event to dispatch
+     * @param args The data to dispatch
+     */
+    emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
+}
+type NextFunction = (error?: Error | null, stream?: Readable) => void;
+interface ExtractorInfo {
+    playlist: Playlist | null;
+    tracks: Track[];
+}
+interface ExtractorSearchContext {
+    type?: SearchQueryType | null;
+    requestedBy?: User | null;
+}
+
+declare class ExtractorExecutionContext {
+    player: Player;
+    store: Collection<string, BaseExtractor>;
+    constructor(player: Player);
+    isRegistered(identifier: string): boolean;
+    get size(): number;
+    get(identifier: string): BaseExtractor | undefined;
+    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>;
+}
+interface ExtractorExecutionResult<T = unknown> {
+    extractor: BaseExtractor;
+    result: T;
+}
+type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
+
+interface SearchResultData {
+    query: string;
+    queryType?: SearchQueryType | QueryExtractorSearch | null;
+    extractor?: BaseExtractor | null;
+    playlist?: Playlist | null;
+    tracks?: Track[];
+    requestedBy?: User | null;
+}
+declare class SearchResult {
+    player: Player;
+    private _data;
+    constructor(player: Player, _data: SearchResultData);
+    get query(): string;
+    get queryType(): SearchQueryType | `ext:${string}`;
+    get extractor(): BaseExtractor | null;
+    get playlist(): Playlist | null | undefined;
+    get tracks(): Track[];
+    get requestedBy(): User | null;
+    execute(): Promise<SearchResult>;
+    isEmpty(): boolean;
+    hasPlaylist(): boolean;
+    hasTracks(): boolean;
+    toJSON(): {
+        query: string;
+        queryType: SearchQueryType | `ext:${string}`;
+        playlist: PlaylistJSON | null;
+        tracks: TrackJSON[];
+        extractor: string | null;
+        requestedBy: {} | null;
+    };
 }
 
 declare class Player extends TypedEmitter<PlayerEvents> {
@@ -239,8 +356,8 @@ declare class Player extends TypedEmitter<PlayerEvents> {
     readonly options: PlayerInitOptions;
     readonly queues: Collection<string, Queue<unknown>>;
     readonly voiceUtils: VoiceUtils;
-    readonly extractors: Collection<string, ExtractorModel>;
     requiredEvents: string[];
+    extractors: ExtractorExecutionContext;
     /**
      * Creates new Discord Player
      * @param {Client} client The Discord Client
@@ -268,8 +385,8 @@ declare class Player extends TypedEmitter<PlayerEvents> {
         isShard: boolean;
         latency: {
             client: number;
-            udp: number;
-            ws: number;
+            udp: number | undefined;
+            ws: number | undefined;
             eventLoop: number;
         };
         subscribers: number;
@@ -314,23 +431,9 @@ declare class Player extends TypedEmitter<PlayerEvents> {
      * Search tracks
      * @param {string|Track} query The search query
      * @param {SearchOptions} options The search options
-     * @returns {Promise<PlayerSearchResult>}
+     * @returns {Promise<SearchResult>}
      */
-    search(query: string | Track, options: SearchOptions): Promise<PlayerSearchResult>;
-    /**
-     * Registers extractor
-     * @param {string} extractorName The extractor name
-     * @param {ExtractorModel|any} extractor The extractor object
-     * @param {boolean} [force=false] Overwrite existing extractor with this name (if available)
-     * @returns {ExtractorModel}
-     */
-    use(extractorName: string, extractor: ExtractorModel | any, force?: boolean): ExtractorModel;
-    /**
-     * Removes registered extractor
-     * @param {string} extractorName The extractor name
-     * @returns {ExtractorModel}
-     */
-    unuse(extractorName: string): ExtractorModel;
+    search(query: string | Track, options: SearchOptions): Promise<SearchResult>;
     /**
      * Generates a report of the dependencies used by the `@discordjs/voice` module. Useful for debugging.
      * @returns {string}
@@ -360,14 +463,17 @@ declare class Queue<T = unknown> {
     previousTracks: Track[];
     options: PlayerOptions;
     playing: boolean;
-    metadata?: T;
+    metadata?: T | null;
     repeatMode: QueueRepeatMode;
     readonly id: string;
     private _streamTime;
     _cooldownsTimeout: Collection<string, NodeJS.Timeout>;
     private _activeFilters;
     private _filtersUpdate;
-    onBeforeCreateStream: (track: Track, source: TrackSource, queue: Queue) => Promise<Readable | undefined>;
+    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
@@ -375,6 +481,106 @@ declare class Queue<T = unknown> {
      * @param {PlayerOptions} [options] Player options for the queue
      */
     constructor(player: Player, guild: Guild, options?: PlayerOptions);
+    /**
+     * Whether or not the PCM filterer is available
+     */
+    isFiltersAvailable(): boolean;
+    /**
+     * The PCM filterer
+     */
+    get filters(): _discord_player_equalizer.AudioFilter | null;
+    /**
+     * Check if biquad filter is available
+     */
+    isBiquadEnabled(): boolean;
+    /**
+     * Check if the equalizer is turned off
+     */
+    isBiquadOff(): boolean;
+    /**
+     * Toggles biquad on/off
+     */
+    toggleBiquad(): boolean;
+    /**
+     * Enables biquad
+     */
+    enableBiquad(): boolean;
+    /**
+     * Disables biquad
+     */
+    disableBiquad(): boolean;
+    /**
+     * Biquad filter setter
+     */
+    setBiquadFilter(filter: BiquadFilters): void;
+    /**
+     * Get active biquad filter name
+     */
+    getBiquadFilterName(): BiquadFilters | null | undefined;
+    /**
+     * Returns current biquad filter
+     */
+    getBiquadFilter(): BiquadFilters | undefined;
+    /**
+     * Set biquad filter gain value
+     * @param gain The gain to set
+     */
+    setBiquadGain(gain: number): void | undefined;
+    /**
+     * Set biquad cutoff frequency value
+     * @param val The value to set
+     */
+    setBiquadCutoff(val: number): void | undefined;
+    /**
+     * Set biquad sample rate value
+     * @param val The value to set
+     */
+    setBiquadSampleRate(val: number): void | undefined;
+    /**
+     * Set biquad Q value
+     * @param val The value to set
+     */
+    setBiquadQ(val: number): void | undefined;
+    /**
+     * Set equalizer bands
+     * @param bands Equalizer band multiplier array
+     */
+    setEqualizer(bands?: EqualizerBand[]): boolean;
+    /**
+     * Set particular equalizer band multiplier
+     * @param band The band to update
+     * @param gain The gain
+     */
+    setEqualizerBand(band: number, gain: number): true | null;
+    /**
+     * Returns gain value of specific equalizer band
+     * @param band The band to get value of
+     */
+    getEqualizerBand(band: number): number | null;
+    /**
+     * Returns entire equalizer bands
+     */
+    getEqualizer(): EqualizerBand[];
+    /**
+     * Check if equalizer is enabled
+     */
+    isEqualizerEnabled(): boolean;
+    /**
+     * Check if the equalizer is turned off
+     */
+    isEqualizerOff(): boolean;
+    /**
+     * Toggles equalizer on/off
+     */
+    toggleEqualizer(): boolean;
+    /**
+     * Enables equalizer
+     */
+    enableEqualizer(): boolean;
+    /**
+     * Disables equalizer
+     */
+    disableEqualizer(): boolean;
     /**
      * Forces next play
      * @returns {Promise<void>}
@@ -384,7 +590,7 @@ declare class Queue<T = unknown> {
      * Returns current track
      * @type {Track}
      */
-    get current(): Track;
+    get current(): Track | undefined;
     /**
      * If this queue is destroyed
      * @type {boolean}
@@ -394,13 +600,13 @@ declare class Queue<T = unknown> {
      * Returns current track
      * @returns {Track}
      */
-    nowPlaying(): Track;
+    nowPlaying(): Track | undefined;
     /**
      * Connects to a voice channel
      * @param {GuildChannelResolvable} channel The voice/stage channel
      * @returns {Promise<Queue>}
      */
-    connect(channel: GuildChannelResolvable): Promise<this>;
+    connect(channel: GuildChannelResolvable): Promise<this | undefined>;
     private emitEnd;
     private refreshEndCooldown;
     /**
@@ -408,12 +614,12 @@ declare class Queue<T = unknown> {
      * @param {boolean} [disconnect=this.options.leaveOnStop] If it should leave on destroy
      * @returns {void}
      */
-    destroy(disconnect?: boolean): void;
+    destroy(disconnect?: boolean | undefined): void;
     /**
      * Skips current track
      * @returns {boolean}
      */
-    skip(): boolean;
+    skip(): boolean | undefined;
     /**
      * Adds single track to the queue
      * @param {Track} track The track to add
@@ -431,24 +637,37 @@ declare class Queue<T = unknown> {
      * @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;
+    setBitrate(bitrate: number | 'auto'): void;
     /**
      * Sets volume
      * @param {number} amount The volume amount
      * @returns {boolean}
      */
-    setVolume(amount: number): boolean;
+    setVolume(amount: number): boolean | undefined;
     /**
      * Sets repeat mode
      * @param  {QueueRepeatMode} mode The repeat mode
      * @returns {boolean}
      */
-    setRepeatMode(mode: QueueRepeatMode): boolean;
+    setRepeatMode(mode: QueueRepeatMode): boolean | undefined;
     /**
      * The current volume amount
      * @type {number}
@@ -465,12 +684,12 @@ declare class Queue<T = unknown> {
      * Returns enabled filters
      * @returns {AudioFilters}
      */
-    getFiltersEnabled(): (keyof QueueFilters)[];
+    getFiltersEnabled(): (keyof QueueFilters)[] | undefined;
     /**
      * Returns disabled filters
      * @returns {AudioFilters}
      */
-    getFiltersDisabled(): (keyof QueueFilters)[];
+    getFiltersDisabled(): (keyof QueueFilters)[] | undefined;
     /**
      * Sets filters
      * @param {QueueFilters} filters Queue filters
@@ -482,7 +701,7 @@ declare class Queue<T = unknown> {
      * @param {number} position The position
      * @returns {boolean}
      */
-    seek(position: number): Promise<boolean>;
+    seek(position: number): Promise<boolean | undefined>;
     /**
      * Plays previous track
      * @returns {Promise<void>}
@@ -501,19 +720,19 @@ declare class Queue<T = unknown> {
      * Shuffles this queue
      * @returns {boolean}
      */
-    shuffle(): 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;
+    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;
+    getTrackPosition(track: number | Track | string): number | undefined;
     /**
      * Jumps to particular track
      * @param {Track|number} track The track
@@ -546,13 +765,13 @@ declare class Queue<T = unknown> {
         current: string;
         end: string;
         progress: number;
-    };
+    } | undefined;
     /**
      * Creates progress bar string
      * @param {PlayerProgressbarOptions} options The progress bar options
      * @returns {string}
      */
-    createProgressBar(options?: PlayerProgressbarOptions): string;
+    createProgressBar(options?: PlayerProgressbarOptions): string | undefined;
     /**
      * Total duration
      * @type {Number}
@@ -574,8 +793,8 @@ declare class Queue<T = unknown> {
         isShard: boolean;
         latency: {
             client: number;
-            udp: number;
-            ws: number;
+            udp: number | undefined;
+            ws: number | undefined;
             eventLoop: number;
         };
         subscribers: number;
@@ -586,7 +805,7 @@ declare class Queue<T = unknown> {
      * Voice connection latency in ms
      * @type {number}
      */
-    get ping(): number;
+    get ping(): number | undefined;
     /**
      * Play stream in a voice/stage channel
      * @param {Track} [src] The track to play (if empty, uses first track from the queue)
@@ -612,15 +831,15 @@ declare class Queue<T = unknown> {
         voiceChannel: string;
         options: PlayerOptions;
         tracks: TrackJSON[];
-    };
+    } | undefined;
     /**
      * String representation of this queue
      * @returns {string}
      */
-    toString(): string;
+    toString(): string | undefined;
 }
 
-declare type FiltersName = keyof QueueFilters;
+type FiltersName = keyof QueueFilters;
 interface PlayerSearchResult {
     playlist: Playlist | null;
     tracks: Track[];
@@ -632,7 +851,7 @@ interface QueueFilters {
     bassboost_low?: boolean;
     bassboost?: boolean;
     bassboost_high?: boolean;
-    "8D"?: boolean;
+    '8D'?: boolean;
     vaporwave?: boolean;
     nightcore?: boolean;
     phaser?: boolean;
@@ -668,10 +887,11 @@ interface QueueFilters {
  * - soundcloud
  * - youtube
  * - spotify
+ * - apple_music
  * - arbitrary
  * @typedef {string} TrackSource
  */
-declare type TrackSource = "soundcloud" | "youtube" | "spotify" | "arbitrary";
+type TrackSource = 'soundcloud' | 'youtube' | 'spotify' | 'apple_music' | 'arbitrary';
 /**
  * @typedef {object} RawTrackData
  * @property {string} title The title
@@ -696,12 +916,13 @@ interface RawTrackData {
     thumbnail: string;
     duration: string;
     views: number;
-    requestedBy: User;
+    requestedBy?: User | null;
     playlist?: Playlist;
     source?: TrackSource;
     engine?: any;
     live?: boolean;
     raw?: any;
+    queryType?: SearchQueryType;
 }
 /**
  * @typedef {object} TimeData
@@ -744,8 +965,14 @@ interface PlayerProgressbarOptions {
  * @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 {
@@ -760,8 +987,14 @@ interface PlayerOptions {
     bufferingTimeout?: number;
     spotifyBridge?: boolean;
     disableVolume?: boolean;
+    disableEqualizer?: boolean;
+    disableBiquad?: boolean;
     volumeSmoothness?: number;
-    onBeforeCreateStream?: (track: Track, source: TrackSource, queue: Queue) => Promise<Readable>;
+    equalizerBands?: EqualizerBand[];
+    biquadFilter?: BiquadFilters;
+    disableFilters?: boolean;
+    defaultFilters?: PCMFilters[];
+    onBeforeCreateStream?: (track: Track, source: SearchQueryType, queue: Queue) => Promise<Readable>;
 }
 /**
  * @typedef {object} ExtractorModelData
@@ -797,7 +1030,7 @@ interface ExtractorModelData {
         title: string;
         description: string;
         thumbnail: string;
-        type: "album" | "playlist";
+        type: 'album' | 'playlist';
         source: TrackSource;
         author: {
             name: string;
@@ -839,26 +1072,35 @@ interface ExtractorModelData {
  * - YOUTUBE_SEARCH
  * - YOUTUBE_VIDEO
  * - SOUNDCLOUD_SEARCH
+ * - APPLE_MUSIC_SONG
+ * - APPLE_MUSIC_ALBUM
+ * - APPLE_MUSIC_PLAYLIST
+ * - FILE
  * @typedef {number} QueryType
  */
-declare enum QueryType {
-    AUTO = 0,
-    YOUTUBE = 1,
-    YOUTUBE_PLAYLIST = 2,
-    SOUNDCLOUD_TRACK = 3,
-    SOUNDCLOUD_PLAYLIST = 4,
-    SOUNDCLOUD = 5,
-    SPOTIFY_SONG = 6,
-    SPOTIFY_ALBUM = 7,
-    SPOTIFY_PLAYLIST = 8,
-    FACEBOOK = 9,
-    VIMEO = 10,
-    ARBITRARY = 11,
-    REVERBNATION = 12,
-    YOUTUBE_SEARCH = 13,
-    YOUTUBE_VIDEO = 14,
-    SOUNDCLOUD_SEARCH = 15
-}
+declare const QueryType: {
+    readonly AUTO: "auto";
+    readonly YOUTUBE: "youtube";
+    readonly YOUTUBE_PLAYLIST: "youtubePlaylist";
+    readonly SOUNDCLOUD_TRACK: "soundcloudTrack";
+    readonly SOUNDCLOUD_PLAYLIST: "soundcloudPlaylist";
+    readonly SOUNDCLOUD: "soundcloud";
+    readonly SPOTIFY_SONG: "spotifySong";
+    readonly SPOTIFY_ALBUM: "spotifyAlbum";
+    readonly SPOTIFY_PLAYLIST: "spotifyPlaylist";
+    readonly FACEBOOK: "facebook";
+    readonly VIMEO: "vimeo";
+    readonly ARBITRARY: "arbitrary";
+    readonly REVERBNATION: "reverbnation";
+    readonly YOUTUBE_SEARCH: "youtubeSearch";
+    readonly YOUTUBE_VIDEO: "youtubeVideo";
+    readonly SOUNDCLOUD_SEARCH: "soundcloudSearch";
+    readonly APPLE_MUSIC_SONG: "appleMusicSong";
+    readonly APPLE_MUSIC_ALBUM: "appleMusicAlbum";
+    readonly APPLE_MUSIC_PLAYLIST: "appleMusicPlaylist";
+    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
@@ -923,6 +1165,13 @@ declare enum QueryType {
  * @param {Queue} queue The queue
  * @param {Track} track The track
  */
+/**
+ * Emitted when a track ends
+ * @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;
@@ -935,6 +1184,7 @@ interface PlayerEvents {
     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;
 }
 /**
  * @typedef {object} PlayOptions
@@ -949,15 +1199,16 @@ interface PlayOptions {
     seek?: number;
     immediate?: boolean;
 }
+type QueryExtractorSearch = `ext:${string}`;
 /**
  * @typedef {object} SearchOptions
  * @property {UserResolvable} requestedBy The user who requested this search
- * @property {QueryType|string} [searchEngine=QueryType.AUTO] The query search engine, can be extractor name to target specific one (custom)
+ * @property {typeof QueryType|string} [searchEngine=QueryType.AUTO] The query search engine, can be extractor name to target specific one (custom)
  * @property {boolean} [blockExtractor=false] If it should block custom extractors
  */
 interface SearchOptions {
-    requestedBy: UserResolvable;
-    searchEngine?: QueryType | string;
+    requestedBy?: UserResolvable;
+    searchEngine?: SearchQueryType | QueryExtractorSearch;
     blockExtractor?: boolean;
 }
 /**
@@ -994,7 +1245,7 @@ interface PlaylistInitData {
     title: string;
     description: string;
     thumbnail: string;
-    type: "album" | "playlist";
+    type: 'album' | 'playlist';
     source: TrackSource;
     author: {
         name: string;
@@ -1050,7 +1301,7 @@ interface PlaylistJSON {
     title: string;
     description: string;
     thumbnail: string;
-    type: "album" | "playlist";
+    type: 'album' | 'playlist';
     source: TrackSource;
     author: {
         name: string;
@@ -1132,12 +1383,12 @@ declare class PlayerError extends Error {
     get createdTimestamp(): number;
     valueOf(): ErrorStatusCode;
     toJSON(): {
-        stack: string;
+        stack: string | undefined;
         code: ErrorStatusCode;
         message: string;
         created: number;
     };
-    toString(): string;
+    toString(): string | undefined;
 }
 
 declare class QueryResolver {
@@ -1145,22 +1396,35 @@ 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): 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;
+    static getVimeoID(query: string): string | null | undefined;
+    static validateId(q: string): boolean;
+    static validateURL(q: string): boolean;
 }
 
 interface VolumeTransformerOptions extends TransformOptions {
-    type?: "s16le" | "s16be" | "s32le" | "s32be";
+    type?: 's16le' | 's16be' | 's32le' | 's32be';
     smoothness?: number;
     volume?: number;
 }
@@ -1172,13 +1436,13 @@ declare class VolumeTransformer extends Transform {
     private _chunk;
     volume: number;
     private _targetVolume;
-    type: "s16le" | "s32le" | "s16be" | "s32be";
+    type: 's16le' | 's32le' | 's16be' | 's32be';
     constructor(options?: VolumeTransformerOptions);
     _readInt(buffer: Buffer, index: number): number;
     _writeInt(buffer: Buffer, int: number, index: number): number;
     _applySmoothness(): void;
     _transform(chunk: Buffer, encoding: BufferEncoding, done: () => unknown): unknown;
-    _destroy(err: Error, cb: (error: Error) => void): void;
+    _destroy(err: Error, cb: (error: Error | null) => void): void;
     setVolume(volume: number): void;
     setVolumeDecibels(db: number): void;
     setVolumeLogarithmic(value: number): void;
@@ -1237,7 +1501,7 @@ declare class Util {
      * @param {number} time The time in ms to wait
      * @returns {Promise<unknown>}
      */
-    static wait(time: number): Promise<any>;
+    static wait(time: number): Promise<undefined>;
     static noop(): void;
     static getFetch(): Promise<any>;
 }
@@ -1255,8 +1519,8 @@ declare function FFMPEG_ARGS_PIPED(fmt?: string): string[];
  * @param stream The source stream
  * @param options FFmpeg stream options
  */
-declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable | Duplex;
+declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable;
 
 declare const version: string;
 
-export { AudioFilters, ErrorStatusCode, ExtractorModel, ExtractorModelData, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFmpegStreamOptions, FiltersName, PlayOptions, Player, PlayerError, PlayerEvents, PlayerInitOptions, PlayerOptions, PlayerProgressbarOptions, PlayerSearchResult, Playlist, PlaylistInitData, PlaylistJSON, QueryResolver, QueryType, Queue, QueueFilters, QueueRepeatMode, RawTrackData, SearchOptions, StreamDispatcher, TimeData, Track, TrackJSON, TrackSource, Util, VoiceEvents, VoiceUtils, VolumeTransformer, VolumeTransformerOptions, createFFmpegStream, version };
+export { AudioFilters, BaseExtractor, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorModelData, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFmpegStreamOptions, FiltersName, NextFunction, PlayOptions, Player, PlayerError, PlayerEvents, PlayerInitOptions, PlayerOptions, PlayerProgressbarOptions, PlayerSearchResult, Playlist, PlaylistInitData, PlaylistJSON, QueryExtractorSearch, QueryResolver, QueryType, Queue, QueueFilters, QueueRepeatMode, RawTrackData, SearchOptions, SearchQueryType, StreamDispatcher, TimeData, Track, TrackJSON, TrackSource, Util, VoiceEvents, VoiceUtils, VolumeTransformer, VolumeTransformerOptions, createFFmpegStream, version };