discord-player 6.6.0-dev.0 → 6.6.0

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { ListenerSignature, DefaultListener, EventEmitter, Collection, Queue, QueueStrategy } from '@discord-player/utils';
+import { ListenerSignature, DefaultListener, EventEmitter, Queue, QueueStrategy, Collection } from '@discord-player/utils';
 import * as discord_js from 'discord.js';
-import { User, GuildVoiceChannelResolvable, VoiceChannel, StageChannel, UserResolvable, Guild, VoiceState, VoiceBasedChannel, Snowflake, Client, GuildResolvable } from 'discord.js';
-import { Readable, Duplex } from 'stream';
-import { RequestOptions } from 'http';
+import { VoiceChannel, StageChannel, UserResolvable, Guild, VoiceState, VoiceBasedChannel, GuildVoiceChannelResolvable, User, Snowflake, Client, GuildResolvable } from 'discord.js';
 import * as _discord_player_equalizer from '@discord-player/equalizer';
 import { EqualizerBand, BiquadFilters, PCMFilters, 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 { Readable, Duplex } from 'stream';
 import { StreamType, AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, EndBehaviorType } from '@discordjs/voice';
 export { AudioPlayer, CreateAudioPlayerOptions, createAudioPlayer } from '@discordjs/voice';
+import { RequestOptions } from 'http';
 import { downloadOptions } from 'ytdl-core';
 export * from '@discord-player/ffmpeg';
 
@@ -17,483 +17,190 @@ declare class PlayerEventsEmitter<L extends ListenerSignature<L> = DefaultListen
     emit<K extends keyof L>(name: K, ...args: Parameters<L[K]>): boolean;
 }
 
-declare class Playlist {
-    readonly player: Player;
-    tracks: Track[];
-    title: string;
-    description: string;
-    thumbnail: string;
-    type: 'album' | 'playlist';
-    source: TrackSource;
-    author: {
-        name: string;
-        url: string;
-    };
-    id: string;
-    url: string;
-    readonly rawPlaylist?: any;
+interface CreateStreamOps {
+    type?: StreamType;
+    data?: any;
+    disableVolume?: boolean;
+    disableEqualizer?: boolean;
+    disableBiquad?: boolean;
+    eq?: EqualizerBand[];
+    biquadFilter?: BiquadFilters;
+    disableFilters?: boolean;
+    defaultFilters?: PCMFilters[];
+    volume?: number;
+    disableResampler?: boolean;
+    sampleRate?: number;
+}
+interface VoiceEvents {
+    error: (error: AudioPlayerError) => any;
+    debug: (message: string) => any;
+    start: (resource: AudioResource<Track>) => any;
+    finish: (resource: AudioResource<Track>) => any;
+    dsp: (filters: PCMFilters[]) => any;
+    eqBands: (filters: EqualizerBand[]) => any;
+    sampleRate: (filters: number) => any;
+    biquad: (filters: BiquadFilters) => any;
+    volume: (volume: number) => any;
+    destroyed: () => any;
+}
+declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
+    queue: GuildQueue;
+    readonly connectionTimeout: number;
+    voiceConnection: VoiceConnection;
+    audioPlayer: AudioPlayer;
+    receiver: VoiceReceiverNode;
+    channel: VoiceChannel | StageChannel;
+    audioResource?: AudioResource<Track> | null;
+    dsp: FiltersChain;
     /**
-     * Playlist constructor
-     * @param {Player} player The player
-     * @param {PlaylistInitData} data The data
+     * Creates new connection object
+     * @param {VoiceConnection} connection The connection
+     * @param {VoiceChannel|StageChannel} channel The connected channel
+     * @private
      */
-    constructor(player: Player, data: PlaylistInitData);
-    [Symbol.iterator](): Generator<Track<unknown>, void, undefined>;
+    constructor(connection: VoiceConnection, channel: VoiceChannel | StageChannel, queue: GuildQueue, connectionTimeout?: number, audioPlayer?: AudioPlayer);
     /**
-     * Estimated duration of this playlist
+     * Check if the player has been paused manually
      */
-    get estimatedDuration(): number;
+    get paused(): boolean;
+    set paused(val: boolean);
     /**
-     * Formatted estimated duration of this playlist
+     * Whether or not the player is currently paused automatically or manually.
      */
-    get durationFormatted(): string;
+    isPaused(): boolean;
     /**
-     * JSON representation of this playlist
-     * @param {boolean} [withTracks=true] If it should build json with tracks
-     * @returns {PlaylistJSON}
+     * Whether or not the player is currently buffering
      */
-    toJSON(withTracks?: boolean): PlaylistJSON;
-}
-
-interface ExtractorExecutionEvents {
+    isBuffering(): boolean;
     /**
-     * Emitted when a extractor is registered
-     * @param context The context where extractor was registered
-     * @param extractor The extractor that was registered
+     * Whether or not the player is currently playing
      */
-    registered: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    isPlaying(): boolean;
     /**
-     * Emitted when a extractor is unregistered
-     * @param context The context where extractor was unregistered
-     * @param extractor The extractor that was unregistered
+     * Whether or not the player is currently idle
      */
-    unregistered: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    isIdle(): boolean;
     /**
-     * Emitted when a extractor is activated
-     * @param context The context where this event occurred
-     * @param extractor The extractor which was activated
+     * Whether or not the voice connection has been destroyed
      */
-    activate: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    isDestroyed(): boolean;
     /**
-     * Emitted when a extractor is deactivated
-     * @param context The context where this event occurred
-     * @param extractor The extractor which was deactivated
+     * Whether or not the voice connection has been destroyed
      */
-    deactivate: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    isDisconnected(): boolean;
     /**
-     * Emitted when a extractor fails to activate/deactivate
-     * @param context The context where this event occurred
-     * @param extractor The extractor which was deactivated
+     * Whether or not the voice connection is ready to play
      */
-    error: (context: ExtractorExecutionContext, extractor: BaseExtractor, error: Error) => unknown;
-}
-declare class ExtractorExecutionContext extends PlayerEventsEmitter<ExtractorExecutionEvents> {
-    player: Player;
-    store: Collection<string, BaseExtractor<object>>;
-    constructor(player: Player);
+    isReady(): boolean;
     /**
-     * Load default extractors from `@discord-player/extractor`
+     * Whether or not the voice connection is signalling
      */
-    loadDefault(): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
+    isSignalling(): boolean;
     /**
-     * Validate if the given extractor is registered
-     * @param identifier The extractor identifier
+     * Whether or not the voice connection is connecting
      */
-    isRegistered(identifier: string): boolean;
+    isConnecting(): boolean;
     /**
-     * The size of registered extractors
+     * Creates stream
+     * @param {Readable} src The stream source
+     * @param {object} [ops] Options
+     * @returns {AudioResource}
      */
-    get size(): number;
+    createStream(src: Readable, ops?: CreateStreamOps): Promise<AudioResource<Track<unknown>>>;
+    get resampler(): _discord_player_equalizer.PCMResampler | null;
+    get filters(): _discord_player_equalizer.AudioFilter | null;
+    get biquad(): _discord_player_equalizer.BiquadStream | null;
+    get equalizer(): _discord_player_equalizer.EqualizerStream | null;
     /**
-     * Get single extractor
-     * @param identifier The extractor to get
+     * The player status
+     * @type {AudioPlayerStatus}
      */
-    get(identifier: string): BaseExtractor<object> | undefined;
+    get status(): AudioPlayerStatus;
     /**
-     * Register single extractor
-     * @param _extractor The extractor to register
-     * @param options Options supplied to the extractor
+     * Disconnects from voice
+     * @returns {void}
      */
-    register<O extends object, T extends typeof BaseExtractor<O>>(_extractor: T, options: ConstructorParameters<T>['1']): Promise<void>;
+    disconnect(): void;
     /**
-     * Unregister single extractor
-     * @param _extractor The extractor to unregister
+     * Destroys this dispatcher
      */
-    unregister<K extends string | BaseExtractor>(_extractor: K): Promise<void>;
+    destroy(): void;
     /**
-     * Unregister all extractors
+     * Stops the player
+     * @returns {void}
      */
-    unregisterAll(): Promise<void>;
+    end(): void;
     /**
-     * Run all the extractors
-     * @param fn The runner function
-     * @param filterBlocked Filter blocked extractors
+     * Pauses the stream playback
+     * @param {boolean} [interpolateSilence=false] If true, the player will play 5 packets of silence after pausing to prevent audio glitches.
+     * @returns {boolean}
      */
-    run<T = unknown>(fn: ExtractorExecutionFN<T>, filterBlocked?: boolean): Promise<ExtractorExecutionResult<T> | ExtractorExecutionResult<false> | undefined>;
-}
-interface ExtractorExecutionResult<T = unknown> {
-    extractor: BaseExtractor;
-    error: Error | null;
-    result: T;
-}
-type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
-
-declare class BaseExtractor<T extends object = object> {
-    context: ExtractorExecutionContext;
-    options: T;
+    pause(interpolateSilence?: boolean): boolean;
     /**
-     * Identifier for this extractor
+     * Resumes the stream playback
+     * @returns {boolean}
      */
-    static identifier: string;
+    resume(): boolean;
     /**
-     * Handle bridge query creation
-     * @param track The track to build query for
+     * Play stream
+     * @param {AudioResource<Track>} [resource=this.audioResource] The audio resource to play
+     * @returns {Promise<StreamDispatcher>}
      */
-    createBridgeQuery: (track: Track) => string;
+    playStream(resource?: AudioResource<Track>): Promise<this | undefined>;
     /**
-     * Extractor constructor
-     * @param context Context that instantiated this extractor
-     * @param options Initialization options for this extractor
+     * Sets playback volume
+     * @param {number} value The volume amount
+     * @returns {boolean}
      */
-    constructor(context: ExtractorExecutionContext, options?: T);
+    setVolume(value: number): boolean;
     /**
-     * Identifier of this extractor
+     * The current volume
+     * @type {number}
      */
-    get identifier(): string;
+    get volume(): number;
     /**
-     * Reconfigures this extractor
-     * @param options The new options to apply
+     * The playback time
+     * @type {number}
      */
-    reconfigure(options: T): Promise<void>;
+    get streamTime(): number;
+}
+
+interface VoiceReceiverOptions {
+    mode?: 'opus' | 'pcm';
+    end?: EndBehaviorType;
+    silenceDuration?: number;
+    crc?: boolean;
+}
+type RawTrackInit = Partial<Omit<RawTrackData, 'author' | 'playlist' | 'source' | 'engine' | 'raw' | 'queryType' | 'description' | 'views'>>;
+declare class VoiceReceiverNode {
+    dispatcher: StreamDispatcher;
+    constructor(dispatcher: StreamDispatcher);
+    createRawTrack(stream: Readable, data?: RawTrackInit): Track<unknown>;
     /**
-     * This method will be executed when this extractor is activated
+     * Merge multiple streams together
+     * @param streams The array of streams to merge
      */
-    activate(): Promise<void>;
+    mergeRecordings(streams: Readable[]): void;
     /**
-     * This method will be executed when this extractor is deactivated
+     * Record a user in voice channel
+     * @param user The user to record
+     * @param options Recording options
      */
-    deactivate(): Promise<void>;
+    recordUser(user: UserResolvable, options?: VoiceReceiverOptions): Readable;
+}
+
+declare class GuildQueueHistory<Meta = unknown> {
+    queue: GuildQueue<Meta>;
+    tracks: Queue<Track<unknown>>;
+    constructor(queue: GuildQueue<Meta>);
     /**
-     * Validate incoming query
-     * @param query The query to validate
+     * Current track in the queue
      */
-    validate(query: string, type?: SearchQueryType | null): Promise<boolean>;
+    get currentTrack(): Track<unknown> | null;
     /**
-     * Stream the given track
-     * @param info The track to stream
+     * Next track in the queue
      */
-    stream(info: Track): Promise<Readable | string>;
-    /**
-     * Handle the given query
-     * @param query The query to handle
-     */
-    handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo>;
-    /**
-     * Get related tracks for the given track
-     * @param track The track source
-     */
-    getRelatedTracks(track: Track): 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;
-    /**
-     * Create extractor response
-     * @param playlist The playlist
-     * @param tracks The track array
-     */
-    createResponse(playlist?: Playlist | null, tracks?: Track[]): ExtractorInfo;
-    /**
-     * Write debug message
-     * @param message The debug message
-     */
-    debug(message: string): boolean;
-}
-type NextFunction = (error?: Error | null, stream?: Readable) => void;
-interface ExtractorInfo {
-    playlist: Playlist | null;
-    tracks: Track[];
-}
-interface ExtractorSearchContext {
-    type?: SearchQueryType | null;
-    requestedBy?: User | null;
-    requestOptions?: RequestOptions;
-}
-
-type TrackResolvable = Track | string | number;
-type WithMetadata<T extends object, M> = T & {
-    metadata: M;
-    requestMetadata(): Promise<M>;
-};
-declare class Track<T = unknown> {
-    readonly player: Player;
-    title: string;
-    description: string;
-    author: string;
-    url: string;
-    thumbnail: string;
-    duration: string;
-    views: number;
-    requestedBy: User | null;
-    playlist?: Playlist;
-    queryType: SearchQueryType | null | undefined;
-    raw: RawTrackData;
-    extractor: BaseExtractor | null;
-    readonly id: string;
-    private __metadata;
-    private __reqMetadataFn;
-    /**
-     * Track constructor
-     * @param player The player that instantiated this Track
-     * @param data Track data
-     */
-    constructor(player: Player, data: Partial<WithMetadata<RawTrackData, T>>);
-    /**
-     * Request metadata for this track
-     */
-    requestMetadata(): Promise<T | null>;
-    /**
-     * Set metadata for this track
-     */
-    setMetadata(m: T | null): void;
-    /**
-     * Metadata of this track
-     */
-    get metadata(): T | null;
-    /**
-     * If this track has metadata
-     */
-    get hasMetadata(): boolean;
-    /**
-     * The queue in which this track is located
-     */
-    get queue(): GuildQueue;
-    /**
-     * The track duration in millisecond
-     */
-    get durationMS(): number;
-    /**
-     * Returns source of this track
-     */
-    get source(): TrackSource;
-    /**
-     * String representation of this track
-     */
-    toString(): string;
-    /**
-     * Raw JSON representation of this track
-     */
-    toJSON(hidePlaylist?: boolean): TrackJSON;
-    /**
-     * Get belonging queues of this track
-     */
-    getBelongingQueues(): Collection<string, GuildQueue<unknown>>;
-    /**
-     * Play this track to the given voice channel. If queue exists and another track is being played, this track will be added to the queue.
-     * @param channel Voice channel on which this track shall be played
-     * @param options Node initialization options
-     */
-    play<T = unknown>(channel: GuildVoiceChannelResolvable, options?: PlayerNodeInitializerOptions<T>): Promise<PlayerNodeInitializationResult<T>>;
-}
-
-interface CreateStreamOps {
-    type?: StreamType;
-    data?: any;
-    disableVolume?: boolean;
-    disableEqualizer?: boolean;
-    disableBiquad?: boolean;
-    eq?: EqualizerBand[];
-    biquadFilter?: BiquadFilters;
-    disableFilters?: boolean;
-    defaultFilters?: PCMFilters[];
-    volume?: number;
-    disableResampler?: boolean;
-    sampleRate?: number;
-}
-interface VoiceEvents {
-    error: (error: AudioPlayerError) => any;
-    debug: (message: string) => any;
-    start: (resource: AudioResource<Track>) => any;
-    finish: (resource: AudioResource<Track>) => any;
-    dsp: (filters: PCMFilters[]) => any;
-    eqBands: (filters: EqualizerBand[]) => any;
-    sampleRate: (filters: number) => any;
-    biquad: (filters: BiquadFilters) => any;
-    volume: (volume: number) => any;
-    destroyed: () => any;
-}
-declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
-    queue: GuildQueue;
-    readonly connectionTimeout: number;
-    voiceConnection: VoiceConnection;
-    audioPlayer: AudioPlayer;
-    receiver: VoiceReceiverNode;
-    channel: VoiceChannel | StageChannel;
-    audioResource?: AudioResource<Track> | null;
-    dsp: FiltersChain;
-    /**
-     * Creates new connection object
-     * @param {VoiceConnection} connection The connection
-     * @param {VoiceChannel|StageChannel} channel The connected channel
-     * @private
-     */
-    constructor(connection: VoiceConnection, channel: VoiceChannel | StageChannel, queue: GuildQueue, connectionTimeout?: number, audioPlayer?: AudioPlayer);
-    /**
-     * 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;
-    /**
-     * Whether or not the voice connection has been destroyed
-     */
-    isDestroyed(): boolean;
-    /**
-     * Whether or not the voice connection has been destroyed
-     */
-    isDisconnected(): boolean;
-    /**
-     * Whether or not the voice connection is ready to play
-     */
-    isReady(): boolean;
-    /**
-     * Whether or not the voice connection is signalling
-     */
-    isSignalling(): boolean;
-    /**
-     * Whether or not the voice connection is connecting
-     */
-    isConnecting(): boolean;
-    /**
-     * Creates stream
-     * @param {Readable} src The stream source
-     * @param {object} [ops] Options
-     * @returns {AudioResource}
-     */
-    createStream(src: Readable, ops?: CreateStreamOps): Promise<AudioResource<Track<unknown>>>;
-    get resampler(): _discord_player_equalizer.PCMResampler | null;
-    get filters(): _discord_player_equalizer.AudioFilter | null;
-    get biquad(): _discord_player_equalizer.BiquadStream | null;
-    get equalizer(): _discord_player_equalizer.EqualizerStream | null;
-    /**
-     * The player status
-     * @type {AudioPlayerStatus}
-     */
-    get status(): AudioPlayerStatus;
-    /**
-     * Disconnects from voice
-     * @returns {void}
-     */
-    disconnect(): void;
-    /**
-     * Destroys this dispatcher
-     */
-    destroy(): void;
-    /**
-     * Stops the player
-     * @returns {void}
-     */
-    end(): void;
-    /**
-     * Pauses the stream playback
-     * @param {boolean} [interpolateSilence=false] If true, the player will play 5 packets of silence after pausing to prevent audio glitches.
-     * @returns {boolean}
-     */
-    pause(interpolateSilence?: boolean): boolean;
-    /**
-     * Resumes the stream playback
-     * @returns {boolean}
-     */
-    resume(): boolean;
-    /**
-     * Play stream
-     * @param {AudioResource<Track>} [resource=this.audioResource] The audio resource to play
-     * @returns {Promise<StreamDispatcher>}
-     */
-    playStream(resource?: AudioResource<Track>): Promise<this | undefined>;
-    /**
-     * Sets playback volume
-     * @param {number} value The volume amount
-     * @returns {boolean}
-     */
-    setVolume(value: number): boolean;
-    /**
-     * The current volume
-     * @type {number}
-     */
-    get volume(): number;
-    /**
-     * The playback time
-     * @type {number}
-     */
-    get streamTime(): number;
-}
-
-interface VoiceReceiverOptions {
-    mode?: 'opus' | 'pcm';
-    end?: EndBehaviorType;
-    silenceDuration?: number;
-    crc?: boolean;
-}
-type RawTrackInit = Partial<Omit<RawTrackData, 'author' | 'playlist' | 'source' | 'engine' | 'raw' | 'queryType' | 'description' | 'views'>>;
-declare class VoiceReceiverNode {
-    dispatcher: StreamDispatcher;
-    constructor(dispatcher: StreamDispatcher);
-    createRawTrack(stream: Readable, data?: RawTrackInit): Track<unknown>;
-    /**
-     * Merge multiple streams together
-     * @param streams The array of streams to merge
-     */
-    mergeRecordings(streams: Readable[]): void;
-    /**
-     * Record a user in voice channel
-     * @param user The user to record
-     * @param options Recording options
-     */
-    recordUser(user: UserResolvable, options?: VoiceReceiverOptions): Readable;
-}
-
-declare class GuildQueueHistory<Meta = unknown> {
-    queue: GuildQueue<Meta>;
-    tracks: Queue<Track<unknown>>;
-    constructor(queue: GuildQueue<Meta>);
-    /**
-     * Current track in the queue
-     */
-    get currentTrack(): Track<unknown> | null;
-    /**
-     * Next track in the queue
-     */
-    get nextTrack(): Track<unknown> | null;
+    get nextTrack(): Track<unknown> | null;
     /**
      * Previous track in the queue
      */
@@ -805,26 +512,27 @@ declare function FFMPEG_ARGS_PIPED(fmt?: string): string[];
 declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable;
 
 type Filters = keyof typeof AudioFilters.filters;
-declare const EqualizerConfigurationPreset: {
-    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[];
+type EQPreset = {
+    Flat: EqualizerBand[];
+    Classical: EqualizerBand[];
+    Club: EqualizerBand[];
+    Dance: EqualizerBand[];
+    FullBass: EqualizerBand[];
+    FullBassTreble: EqualizerBand[];
+    FullTreble: EqualizerBand[];
+    Headphones: EqualizerBand[];
+    LargeHall: EqualizerBand[];
+    Live: EqualizerBand[];
+    Party: EqualizerBand[];
+    Pop: EqualizerBand[];
+    Reggae: EqualizerBand[];
+    Rock: EqualizerBand[];
+    Ska: EqualizerBand[];
+    Soft: EqualizerBand[];
+    SoftRock: EqualizerBand[];
+    Techno: EqualizerBand[];
 };
+declare const EqualizerConfigurationPreset: Readonly<EQPreset>;
 declare class FFmpegFilterer<Meta = unknown> {
     #private;
     af: GuildQueueAudioFilters<Meta>;
@@ -918,26 +626,7 @@ declare class GuildQueueAudioFilters<Meta = unknown> {
     queue: GuildQueue<Meta>;
     graph: AFilterGraph<Meta>;
     ffmpeg: FFmpegFilterer<Meta>;
-    equalizerPresets: {
-        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[];
-    };
+    equalizerPresets: Readonly<EQPreset>;
     _lastFiltersCache: GuildQueueAFiltersCache;
     constructor(queue: GuildQueue<Meta>);
     /**
@@ -977,13 +666,43 @@ declare class AFilterGraph<Meta = unknown> {
     get resampler(): _discord_player_equalizer.PCMResampler | null;
     dump(): FilterGraph;
 }
-interface FilterGraph {
-    ffmpeg: Filters[];
-    equalizer: EqualizerBand[];
-    biquad: Exclude<BiquadFilters, number> | null;
-    filters: PCMFilters[];
-    volume: number;
-    sampleRate: number;
+interface FilterGraph {
+    ffmpeg: Filters[];
+    equalizer: EqualizerBand[];
+    biquad: Exclude<BiquadFilters, number> | null;
+    filters: PCMFilters[];
+    volume: number;
+    sampleRate: number;
+}
+
+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;
+    };
+}
+declare class GuildQueueStatistics<Meta = unknown> {
+    queue: GuildQueue<Meta>;
+    constructor(queue: GuildQueue<Meta>);
+    /**
+     * Generate statistics of this queue
+     */
+    generate(): GuildQueueStatisticsMetadata;
 }
 
 interface GuildNodeInit<Meta = unknown> {
@@ -1387,181 +1106,444 @@ declare class GuildQueue<Meta = unknown> {
      */
     setTransitioning(state: boolean): void;
     /**
-     * if this queue is currently under transition mode
+     * 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;
+    /**
+     * Max size of this queue
+     */
+    get maxSize(): number;
+    /**
+     * Max size of this queue
+     */
+    getMaxSize(): number;
+    /**
+     * Gets the size of the queue
+     */
+    get size(): number;
+    /**
+     * The size of this queue
+     */
+    getSize(): number;
+    /**
+     * Max history size of this queue
+     */
+    get maxHistorySize(): number;
+    /**
+     * Max history size of this queue
+     */
+    getMaxHistorySize(): number;
+    /**
+     * Set max history size for this queue
+     * @param size The size to set
+     */
+    setMaxHistorySize(size: number): void;
+    /**
+     * Set max size for this queue
+     * @param size The size to set
+     */
+    setMaxSize(size: number): void;
+    /**
+     * Clear this queue
+     */
+    clear(): void;
+    /**
+     * Check if this queue has no tracks left in it
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if this queue is full
+     */
+    isFull(): boolean;
+    /**
+     * Get queue capacity
+     */
+    getCapacity(): number;
+    /**
+     * Check if this queue currently holds active audio resource
+     */
+    isPlaying(): boolean;
+    /**
+     * Add track to the queue. This will emit `audioTracksAdd` when multiple tracks are added, otherwise `audioTrackAdd`.
+     * @param track Track or playlist or array of tracks to add
+     */
+    addTrack(track: Track | Track[] | Playlist): void;
+    /**
+     * Remove a track from queue
+     * @param track The track to remove
+     */
+    removeTrack(track: TrackResolvable): Track<unknown> | null;
+    /**
+     * Inserts the track to the given index
+     * @param track The track to insert
+     * @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;
+    /**
+     * Create stream dispatcher from the given connection
+     * @param connection The connection to use
+     */
+    createDispatcher(connection: VoiceConnection, options?: Pick<VoiceConnectConfig, 'audioPlayer' | 'timeout'>): 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;
+    /**
+     * Revives this queue
+     * @returns
+     */
+    revive(): void;
+    /**
+     * Set self deaf
+     * @param mode On/Off state
+     * @param reason Reason
+     */
+    setSelfDeaf(mode?: boolean, reason?: string): Promise<discord_js.GuildMember>;
+    /**
+     * Set self mute
+     * @param mode On/Off state
+     * @param reason Reason
+     */
+    setSelfMute(mode?: boolean, reason?: string): Promise<discord_js.GuildMember>;
+    /**
+     * Play a track in this queue
+     * @param track The track to be played
+     * @param options Player node initialization options
+     */
+    play(track: TrackLike, options?: PlayerNodeInitializerOptions<Meta>): Promise<PlayerNodeInitializationResult<Meta>>;
+    /**
+     * Emit an event on this queue
+     * @param event The event to emit
+     * @param args The args for the event
+     */
+    emit<K extends keyof GuildQueueEvents<Meta>>(event: K, ...args: Parameters<GuildQueueEvents<Meta>[K]>): boolean;
+    get hasDebugger(): boolean;
+}
+
+interface ExtractorExecutionEvents {
+    /**
+     * Emitted when a extractor is registered
+     * @param context The context where extractor was registered
+     * @param extractor The extractor that was registered
+     */
+    registered: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    /**
+     * Emitted when a extractor is unregistered
+     * @param context The context where extractor was unregistered
+     * @param extractor The extractor that was unregistered
+     */
+    unregistered: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    /**
+     * Emitted when a extractor is activated
+     * @param context The context where this event occurred
+     * @param extractor The extractor which was activated
+     */
+    activate: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    /**
+     * Emitted when a extractor is deactivated
+     * @param context The context where this event occurred
+     * @param extractor The extractor which was deactivated
+     */
+    deactivate: (context: ExtractorExecutionContext, extractor: BaseExtractor) => unknown;
+    /**
+     * Emitted when a extractor fails to activate/deactivate
+     * @param context The context where this event occurred
+     * @param extractor The extractor which was deactivated
+     */
+    error: (context: ExtractorExecutionContext, extractor: BaseExtractor, error: Error) => unknown;
+}
+declare class ExtractorExecutionContext extends PlayerEventsEmitter<ExtractorExecutionEvents> {
+    player: Player;
+    store: Collection<string, BaseExtractor<object>>;
+    constructor(player: Player);
+    /**
+     * Load default extractors from `@discord-player/extractor`
+     */
+    loadDefault(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    /**
+     * Validate if the given extractor is registered
+     * @param identifier The extractor identifier
+     */
+    isRegistered(identifier: string): boolean;
+    /**
+     * The size of registered extractors
+     */
+    get size(): number;
+    /**
+     * Get single extractor
+     * @param identifier The extractor to get
+     */
+    get(identifier: string): BaseExtractor<object> | undefined;
+    /**
+     * Register single extractor
+     * @param _extractor The extractor to register
+     * @param options Options supplied to the extractor
+     */
+    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
+     */
+    unregister<K extends string | BaseExtractor>(_extractor: K): Promise<void>;
+    /**
+     * Unregister all extractors
+     */
+    unregisterAll(): Promise<void>;
+    /**
+     * Run all the extractors
+     * @param fn The runner function
+     * @param filterBlocked Filter blocked extractors
+     */
+    run<T = unknown>(fn: ExtractorExecutionFN<T>, filterBlocked?: boolean): Promise<ExtractorExecutionResult<T> | ExtractorExecutionResult<false> | undefined>;
+}
+interface ExtractorExecutionResult<T = unknown> {
+    extractor: BaseExtractor;
+    error: Error | null;
+    result: T;
+}
+type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
+
+declare class BaseExtractor<T extends object = object> {
+    context: ExtractorExecutionContext;
+    options: T;
+    /**
+     * Identifier for this extractor
      */
-    isTransitioning(): boolean;
+    static identifier: string;
     /**
-     * Set repeat mode for this queue
-     * @param mode The repeat mode to apply
+     * Handle bridge query creation
+     * @param track The track to build query for
      */
-    setRepeatMode(mode: QueueRepeatMode): void;
+    createBridgeQuery: (track: Track) => string;
     /**
-     * Max size of this queue
+     * Extractor constructor
+     * @param context Context that instantiated this extractor
+     * @param options Initialization options for this extractor
      */
-    get maxSize(): number;
+    constructor(context: ExtractorExecutionContext, options?: T);
     /**
-     * Max size of this queue
+     * Identifier of this extractor
      */
-    getMaxSize(): number;
+    get identifier(): string;
     /**
-     * Gets the size of the queue
+     * Reconfigures this extractor
+     * @param options The new options to apply
      */
-    get size(): number;
+    reconfigure(options: T): Promise<void>;
     /**
-     * The size of this queue
+     * This method will be executed when this extractor is activated
      */
-    getSize(): number;
+    activate(): Promise<void>;
     /**
-     * Max history size of this queue
+     * This method will be executed when this extractor is deactivated
      */
-    get maxHistorySize(): number;
+    deactivate(): Promise<void>;
     /**
-     * Max history size of this queue
+     * Validate incoming query
+     * @param query The query to validate
      */
-    getMaxHistorySize(): number;
+    validate(query: string, type?: SearchQueryType | null): Promise<boolean>;
     /**
-     * Set max history size for this queue
-     * @param size The size to set
+     * Stream the given track
+     * @param info The track to stream
      */
-    setMaxHistorySize(size: number): void;
+    stream(info: Track): Promise<Readable | string>;
     /**
-     * Set max size for this queue
-     * @param size The size to set
+     * Handle the given query
+     * @param query The query to handle
      */
-    setMaxSize(size: number): void;
+    handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo>;
     /**
-     * Clear this queue
+     * Get related tracks for the given track
+     * @param track The track source
      */
-    clear(): void;
+    getRelatedTracks(track: Track): Promise<ExtractorInfo>;
     /**
-     * Check if this queue has no tracks left in it
+     * A stream middleware to handle streams before passing it to the player
+     * @param stream The incoming stream
+     * @param next The next function
      */
-    isEmpty(): boolean;
+    handlePostStream(stream: Readable, next: NextFunction): void;
     /**
-     * Check if this queue is full
+     * Dispatch an event to the player
+     * @param event The event to dispatch
+     * @param args The data to dispatch
      */
-    isFull(): boolean;
+    emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
     /**
-     * Get queue capacity
+     * Create extractor response
+     * @param playlist The playlist
+     * @param tracks The track array
      */
-    getCapacity(): number;
+    createResponse(playlist?: Playlist | null, tracks?: Track[]): ExtractorInfo;
     /**
-     * Check if this queue currently holds active audio resource
+     * Write debug message
+     * @param message The debug message
      */
-    isPlaying(): boolean;
+    debug(message: string): boolean;
+}
+type NextFunction = (error?: Error | null, stream?: Readable) => void;
+interface ExtractorInfo {
+    playlist: Playlist | null;
+    tracks: Track[];
+}
+interface ExtractorSearchContext {
+    type?: SearchQueryType | null;
+    requestedBy?: User | null;
+    requestOptions?: RequestOptions;
+}
+
+type TrackResolvable = Track | string | number;
+type WithMetadata<T extends object, M> = T & {
+    metadata: M;
+    requestMetadata(): Promise<M>;
+};
+declare class Track<T = unknown> {
+    readonly player: Player;
+    title: string;
+    description: string;
+    author: string;
+    url: string;
+    thumbnail: string;
+    duration: string;
+    views: number;
+    requestedBy: User | null;
+    playlist?: Playlist;
+    queryType: SearchQueryType | null | undefined;
+    raw: RawTrackData;
+    extractor: BaseExtractor | null;
+    readonly id: string;
+    private __metadata;
+    private __reqMetadataFn;
     /**
-     * Add track to the queue. This will emit `audioTracksAdd` when multiple tracks are added, otherwise `audioTrackAdd`.
-     * @param track Track or playlist or array of tracks to add
+     * Track constructor
+     * @param player The player that instantiated this Track
+     * @param data Track data
      */
-    addTrack(track: Track | Track[] | Playlist): void;
+    constructor(player: Player, data: Partial<WithMetadata<RawTrackData, T>>);
     /**
-     * Remove a track from queue
-     * @param track The track to remove
+     * Request metadata for this track
      */
-    removeTrack(track: TrackResolvable): Track<unknown> | null;
+    requestMetadata(): Promise<T | null>;
     /**
-     * Inserts the track to the given index
-     * @param track The track to insert
-     * @param index The index to insert the track at (defaults to 0)
+     * Set metadata for this track
      */
-    insertTrack(track: Track, index?: number): void;
+    setMetadata(m: T | null): void;
     /**
-     * Moves a track in the queue
-     * @param from The track to move
-     * @param to The position to move to
+     * Metadata of this track
      */
-    moveTrack(track: TrackResolvable, index?: number): void;
+    get metadata(): T | null;
     /**
-     * Copy a track in the queue
-     * @param from The track to clone
-     * @param to The position to clone at
+     * If this track has metadata
      */
-    copyTrack(track: TrackResolvable, index?: number): void;
+    get hasMetadata(): boolean;
     /**
-     * Swap two tracks in the queue
-     * @param src The first track to swap
-     * @param dest The second track to swap
+     * The queue in which this track is located
      */
-    swapTracks(src: TrackResolvable, dest: TrackResolvable): void;
+    get queue(): GuildQueue;
     /**
-     * Create stream dispatcher from the given connection
-     * @param connection The connection to use
+     * The track duration in millisecond
      */
-    createDispatcher(connection: VoiceConnection, options?: Pick<VoiceConnectConfig, 'audioPlayer' | 'timeout'>): void;
+    get durationMS(): number;
     /**
-     * Connect to a voice channel
-     * @param channelResolvable The voice channel to connect to
-     * @param options Join config
+     * Returns source of this track
      */
-    connect(channelResolvable: GuildVoiceChannelResolvable, options?: VoiceConnectConfig): Promise<this>;
+    get source(): TrackSource;
     /**
-     * The voice connection latency of this queue
+     * String representation of this track
      */
-    get ping(): number;
+    toString(): string;
     /**
-     * Delete this queue
+     * Raw JSON representation of this track
      */
-    delete(): void;
+    toJSON(hidePlaylist?: boolean): TrackJSON;
     /**
-     * Revives this queue
-     * @returns
+     * Get belonging queues of this track
      */
-    revive(): void;
+    getBelongingQueues(): Collection<string, GuildQueue<unknown>>;
     /**
-     * Set self deaf
-     * @param mode On/Off state
-     * @param reason Reason
+     * Play this track to the given voice channel. If queue exists and another track is being played, this track will be added to the queue.
+     * @param channel Voice channel on which this track shall be played
+     * @param options Node initialization options
      */
-    setSelfDeaf(mode?: boolean, reason?: string): Promise<discord_js.GuildMember>;
+    play<T = unknown>(channel: GuildVoiceChannelResolvable, options?: PlayerNodeInitializerOptions<T>): Promise<PlayerNodeInitializationResult<T>>;
+}
+
+declare class Playlist {
+    readonly player: Player;
+    tracks: Track[];
+    title: string;
+    description: string;
+    thumbnail: string;
+    type: 'album' | 'playlist';
+    source: TrackSource;
+    author: {
+        name: string;
+        url: string;
+    };
+    id: string;
+    url: string;
+    readonly rawPlaylist?: any;
     /**
-     * Set self mute
-     * @param mode On/Off state
-     * @param reason Reason
+     * Playlist constructor
+     * @param {Player} player The player
+     * @param {PlaylistInitData} data The data
      */
-    setSelfMute(mode?: boolean, reason?: string): Promise<discord_js.GuildMember>;
+    constructor(player: Player, data: PlaylistInitData);
+    [Symbol.iterator](): Generator<Track<unknown>, void, undefined>;
     /**
-     * Play a track in this queue
-     * @param track The track to be played
-     * @param options Player node initialization options
+     * Estimated duration of this playlist
      */
-    play(track: TrackLike, options?: PlayerNodeInitializerOptions<Meta>): Promise<PlayerNodeInitializationResult<Meta>>;
+    get estimatedDuration(): number;
     /**
-     * Emit an event on this queue
-     * @param event The event to emit
-     * @param args The args for the event
+     * Formatted estimated duration of this playlist
      */
-    emit<K extends keyof GuildQueueEvents<Meta>>(event: K, ...args: Parameters<GuildQueueEvents<Meta>[K]>): boolean;
-    get hasDebugger(): boolean;
-}
-
-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;
-    };
-}
-declare class GuildQueueStatistics<Meta = unknown> {
-    queue: GuildQueue<Meta>;
-    constructor(queue: GuildQueue<Meta>);
+    get durationFormatted(): string;
     /**
-     * Generate statistics of this queue
+     * JSON representation of this playlist
+     * @param {boolean} [withTracks=true] If it should build json with tracks
+     * @returns {PlaylistJSON}
      */
-    generate(): GuildQueueStatisticsMetadata;
+    toJSON(withTracks?: boolean): PlaylistJSON;
 }
 
 interface SearchResultData {
@@ -2514,4 +2496,4 @@ declare function createHook<T extends HookDeclaration<(...args: any[]) => any>>(
 
 declare const version: string;
 
-export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AudioFilters, BaseExtractor, CreateStreamOps, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, 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, HookDeclaration, HookDeclarationContext, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamConfig, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceStateHandler, VoiceUtils, WithMetadata, createFFmpegStream, createHook, onAfterCreateStream, onBeforeCreateStream, useHistory, useMainPlayer, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };
+export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AudioFilters, BaseExtractor, CreateStreamOps, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, 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, GuildQueueStatistics, GuildQueueStatisticsMetadata, HookDeclaration, HookDeclarationContext, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamConfig, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceStateHandler, VoiceUtils, WithMetadata, createFFmpegStream, createHook, onAfterCreateStream, onBeforeCreateStream, useHistory, useMainPlayer, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };