discord-player 6.4.0 → 6.6.0-dev

package/README.md

@@ -1,6 +1,6 @@
 # Discord Player
 
-Discord Player is a powerful framework for JavaScript and TypeScript, built on top of **[@discord.js/voice](https://npm.im/@discordjs/voice)** library.
+Discord Player is a powerful framework for JavaScript and TypeScript, built on top of **[@discordjs/voice](https://npm.im/@discordjs/voice)** library.
 It provides easy set of customizable tools to develop Discord Music bots.
 
 [![downloadsBadge](https://img.shields.io/npm/dt/discord-player?style=for-the-badge)](https://npmjs.com/discord-player)
@@ -73,6 +73,8 @@ $ yarn add ytdl-core
 $ yarn add play-dl
 # or
 $ yarn add @distube/ytdl-core
+# or
+$ yarn add yt-stream
 ```
 
 Done with all these? Let's write a simple music bot then.

package/dist/index.d.ts

@@ -1,17 +1,16 @@
 import { ListenerSignature, DefaultListener, EventEmitter, Collection, Queue, QueueStrategy } 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 * as stream from 'stream';
-import { Readable, Duplex, DuplexOptions } from 'stream';
+import { Readable, Duplex } from 'stream';
 import { RequestOptions } from 'http';
 import * as _discord_player_equalizer from '@discord-player/equalizer';
-import { PCMFilters, EqualizerBand, BiquadFilters, FiltersChain } 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 * as _discordjs_voice from '@discordjs/voice';
-import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, StreamType, EndBehaviorType } from '@discordjs/voice';
+import { StreamType, AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, EndBehaviorType } from '@discordjs/voice';
 export { AudioPlayer, CreateAudioPlayerOptions, createAudioPlayer } from '@discordjs/voice';
 import { downloadOptions } from 'ytdl-core';
-import childProcess from 'child_process';
+export * from '@discord-player/ffmpeg';
 
 declare class PlayerEventsEmitter<L extends ListenerSignature<L> = DefaultListener> extends EventEmitter<L> {
     requiredEvents: Array<keyof L>;
@@ -267,15 +266,15 @@ declare class Track<T = unknown> {
     /**
      * Request metadata for this track
      */
-    requestMetadata(): Promise<T>;
+    requestMetadata(): Promise<T | null>;
     /**
      * Set metadata for this track
      */
-    setMetadata(m: T): void;
+    setMetadata(m: T | null): void;
     /**
      * Metadata of this track
      */
-    get metadata(): T | undefined;
+    get metadata(): T | null;
     /**
      * If this track has metadata
      */
@@ -340,12 +339,11 @@ interface VoiceEvents {
 declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
     queue: GuildQueue;
     readonly connectionTimeout: number;
-    readonly voiceConnection: VoiceConnection;
-    readonly audioPlayer: AudioPlayer;
+    voiceConnection: VoiceConnection;
+    audioPlayer: AudioPlayer;
     receiver: VoiceReceiverNode;
     channel: VoiceChannel | StageChannel;
     audioResource?: AudioResource<Track> | null;
-    private readyLock;
     dsp: FiltersChain;
     /**
      * Creates new connection object
@@ -529,7 +527,11 @@ declare class GuildQueueHistory<Meta = unknown> {
     /**
      * Alias to [GuildQueueHistory].previous()
      */
-    back(): Promise<void>;
+    back(preserveCurrent?: boolean): Promise<void>;
+    /**
+     * Resize history store
+     */
+    resize(): void;
 }
 
 interface AsyncQueueAcquisitionOptions {
@@ -616,6 +618,10 @@ interface PlayerTimestamp {
     };
     progress: number;
 }
+interface StreamConfig {
+    dispatcherConfig: CreateStreamOps;
+    playerConfig: ResourcePlayOptions;
+}
 declare class GuildQueuePlayerNode<Meta = unknown> {
     #private;
     queue: GuildQueue<Meta>;
@@ -665,6 +671,10 @@ declare class GuildQueuePlayerNode<Meta = unknown> {
      * Estimated total duration of the player
      */
     get estimatedDuration(): number;
+    /**
+     * Total duration of the current audio track
+     */
+    get totalDuration(): number;
     /**
      * Get stream progress
      * @param ignoreFilters Ignore filters
@@ -815,6 +825,22 @@ declare class FFmpegFilterer<Meta = unknown> {
     #private;
     af: GuildQueueAudioFilters<Meta>;
     constructor(af: GuildQueueAudioFilters<Meta>);
+    /**
+     * Set input args for FFmpeg
+     */
+    setInputArgs(args: string[]): void;
+    /**
+     * Get input args
+     */
+    get inputArgs(): string[];
+    /**
+     * Get encoder args
+     */
+    get encoderArgs(): string[];
+    /**
+     * Get final ffmpeg args
+     */
+    get args(): string[];
     /**
      * Create ffmpeg stream
      * @param source The stream source
@@ -982,6 +1008,8 @@ interface GuildNodeInit<Meta = unknown> {
     bufferingTimeout: number;
     noEmitInsert: boolean;
     maxSize?: number;
+    maxHistorySize?: number;
+    preferBridgedMetadata: boolean;
 }
 interface VoiceConnectConfig {
     deaf?: boolean;
@@ -995,100 +1023,120 @@ interface PostProcessedResult {
 type OnBeforeCreateStreamHandler = (track: Track, queryType: SearchQueryType, queue: GuildQueue) => Promise<Readable | null>;
 type OnAfterCreateStreamHandler = (stream: Readable, queue: GuildQueue) => Promise<PostProcessedResult | null>;
 type PlayerTriggeredReason = 'filters' | 'normal';
-declare enum GuildQueueEvent {
+declare const GuildQueueEvent: {
     /**
      * Emitted when audio track is added to the queue
      */
-    audioTrackAdd = "audioTrackadd",
+    readonly audioTrackAdd: "audioTrackAdd";
     /**
      * Emitted when audio tracks were added to the queue
      */
-    audioTracksAdd = "audioTracksAdd",
+    readonly audioTracksAdd: "audioTracksAdd";
     /**
      * Emitted when audio track is removed from the queue
      */
-    audioTrackRemove = "audioTrackRemove",
+    readonly audioTrackRemove: "audioTrackRemove";
     /**
      * Emitted when audio tracks are removed from the queue
      */
-    audioTracksRemove = "audioTracksRemove",
+    readonly audioTracksRemove: "audioTracksRemove";
     /**
      * Emitted when a connection is created
      */
-    connection = "connection",
+    readonly connection: "connection";
+    /**
+     * Emitted when a voice connection is destroyed
+     */
+    readonly connectionDestroyed: "connectionDestroyed";
     /**
      * Emitted when the bot is disconnected from the channel
      */
-    disconnect = "disconnect",
+    readonly disconnect: "disconnect";
     /**
      * Emitted when the queue sends a debug info
      */
-    debug = "debug",
+    readonly debug: "debug";
     /**
      * Emitted when the queue encounters error
      */
-    error = "error",
+    readonly error: "error";
     /**
      * Emitted when the voice channel is empty
      */
-    emptyChannel = "emptyChannel",
+    readonly emptyChannel: "emptyChannel";
     /**
      * Emitted when the queue is empty
      */
-    emptyQueue = "emptyQueue",
+    readonly emptyQueue: "emptyQueue";
     /**
      * Emitted when the audio player starts streaming audio track
      */
-    playerStart = "playerStart",
+    readonly playerStart: "playerStart";
     /**
      * Emitted when the audio player errors while streaming audio track
      */
-    playerError = "playerError",
+    readonly playerError: "playerError";
     /**
      * Emitted when the audio player finishes streaming audio track
      */
-    playerFinish = "playerFinish",
+    readonly playerFinish: "playerFinish";
     /**
      * Emitted when the audio player skips current track
      */
-    playerSkip = "playerSkip",
+    readonly playerSkip: "playerSkip";
     /**
      * Emitted when the audio player is triggered
      */
-    playerTrigger = "playerTrigger",
+    readonly playerTrigger: "playerTrigger";
     /**
      * Emitted when the voice state is updated. Consuming this event may disable default voice state update handler if `Player.isVoiceStateHandlerLocked()` returns `false`.
      */
-    voiceStateUpdate = "voiceStateUpdate",
+    readonly voiceStateUpdate: "voiceStateUpdate";
     /**
      * Emitted when volume is updated
      */
-    volumeChange = "volumeChange",
+    readonly volumeChange: "volumeChange";
     /**
      * Emitted when player is paused
      */
-    playerPause = "playerPause",
+    readonly playerPause: "playerPause";
     /**
      * Emitted when player is resumed
      */
-    playerResume = "playerResume",
+    readonly playerResume: "playerResume";
     /**
      * Biquad Filters Update
      */
-    biquadFiltersUpdate = "biquadFiltersUpdate",
+    readonly biquadFiltersUpdate: "biquadFiltersUpdate";
     /**
      * Equalizer Update
      */
-    equalizerUpdate = "equalizerUpdate",
+    readonly equalizerUpdate: "equalizerUpdate";
     /**
      * DSP update
      */
-    dspUpdate = "dspUpdate",
+    readonly dspUpdate: "dspUpdate";
     /**
      * Audio Filters Update
      */
-    audioFiltersUpdate = "audioFiltersUpdate"
-}
+    readonly audioFiltersUpdate: "audioFiltersUpdate";
+    /**
+     * Audio player will play next track
+     */
+    readonly willPlayTrack: "willPlayTrack";
+    /**
+     * Emitted when a voice channel is repopulated
+     */
+    readonly channelPopulate: "channelPopulate";
+    /**
+     * Emitted when a queue is successfully created
+     */
+    readonly queueCreate: "queueCreate";
+    /**
+     * Emitted when a queue is deleted
+     */
+    readonly queueDelete: "queueDelete";
+};
 interface GuildQueueEvents<Meta = unknown> {
     /**
      * Emitted when audio track is added to the queue
@@ -1119,6 +1167,11 @@ interface GuildQueueEvents<Meta = unknown> {
      * @param queue The queue where this event occurred
      */
     connection: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when a connection is destroyed
+     * @param queue The queue where this event occurred
+     */
+    connectionDestroyed: (queue: GuildQueue<Meta>) => unknown;
     /**
      * Emitted when the bot is disconnected from the channel
      * @param queue The queue where this event occurred
@@ -1229,6 +1282,30 @@ interface GuildQueueEvents<Meta = unknown> {
      * @param newFilters New filters
      */
     audioFiltersUpdate: (queue: GuildQueue<Meta>, oldFilters: FiltersName[], newFilters: FiltersName[]) => unknown;
+    /**
+     * Emitted before streaming an audio track. This event can be used to modify stream config before playing a track.
+     * Listening to this event will pause the execution of audio player until `done()` is invoked.
+     * @param queue The queue where this event occurred
+     * @param track The track that will be streamed
+     * @param config Configurations for streaming
+     * @param done Done callback
+     */
+    willPlayTrack: (queue: GuildQueue<Meta>, track: Track<unknown>, config: StreamConfig, done: () => void) => unknown;
+    /**
+     * Emitted when a voice channel is populated
+     * @param queue The queue where this event occurred
+     */
+    channelPopulate: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when a queue is successfully created
+     * @param queue The queue where this event occurred
+     */
+    queueCreate: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when a queue is successfully deleted
+     * @param queue The queue where this event occurred
+     */
+    queueDelete: (queue: GuildQueue<Meta>) => unknown;
 }
 declare class GuildQueue<Meta = unknown> {
     #private;
@@ -1329,6 +1406,24 @@ declare class GuildQueue<Meta = unknown> {
      * 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
      */
@@ -1420,6 +1515,12 @@ declare class GuildQueue<Meta = unknown> {
      * @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;
 }
 
 interface GuildQueueStatisticsMetadata {
@@ -1608,6 +1709,7 @@ interface PlayerNodeInitializerOptions<T> extends SearchOptions {
     audioPlayerOptions?: ResourcePlayOptions;
     afterSearch?: (result: SearchResult) => Promise<SearchResult>;
 }
+type VoiceStateHandler = (player: Player, queue: GuildQueue, oldVoiceState: VoiceState, newVoiceState: VoiceState) => Awaited<void>;
 declare class Player extends PlayerEventsEmitter<PlayerEvents> {
     #private;
     static readonly version: string;
@@ -1625,6 +1727,11 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * @param {PlayerInitOptions} [options] The player init options
      */
     constructor(client: Client, options?: PlayerInitOptions);
+    /**
+     * Override default voice state update handler
+     * @param handler The handler callback
+     */
+    onVoiceStateUpdate(handler: VoiceStateHandler): void;
     debug(m: string): boolean;
     /**
      * Creates discord-player singleton instance.
@@ -1789,6 +1896,9 @@ interface GuildNodeCreateOptions<T = unknown> {
     defaultFFmpegFilters?: FiltersName[];
     bufferingTimeout?: number;
     noEmitInsert?: boolean;
+    maxSize?: number;
+    maxHistorySize?: number;
+    preferBridgedMetadata?: boolean;
 }
 type NodeResolvable = GuildQueue | GuildResolvable;
 declare class GuildNodeManager<Meta = unknown> {
@@ -2286,6 +2396,7 @@ declare class QueryResolver {
         appleMusicSongRegex: RegExp;
         soundcloudTrackRegex: RegExp;
         soundcloudPlaylistRegex: RegExp;
+        youtubePlaylistRegex: RegExp;
     };
     /**
      * Resolves the given search query
@@ -2302,93 +2413,49 @@ declare class QueryResolver {
     static validateURL(q: string): boolean;
 }
 
-type Callback<Args extends Array<unknown>> = (...args: Args) => unknown;
-interface FFmpegInfo {
-    command: string | null;
-    metadata: string | null;
-    version: string | null;
-    isStatic: boolean;
-}
-interface FFmpegOptions extends DuplexOptions {
-    args?: string[];
-    shell?: boolean;
-}
-declare class FFmpeg extends Duplex {
-    /**
-     * FFmpeg version regex
-     */
-    static VersionRegex: RegExp;
-    /**
-     * Spawns ffmpeg process
-     * @param options Spawn options
-     */
-    static spawn({ args, shell }?: {
-        args?: string[] | undefined;
-        shell?: boolean | undefined;
-    }): childProcess.ChildProcessWithoutNullStreams;
-    /**
-     * Check if ffmpeg is available
-     */
-    static isAvailable(): boolean;
-    /**
-     * Safe locate ffmpeg
-     * @param force if it should relocate the command
-     */
-    static locateSafe(force?: boolean): FFmpegInfo | null | undefined;
-    /**
-     * Locate ffmpeg command. Throws error if ffmpeg is not found.
-     * @param force Forcefully reload
-     */
-    static locate(force?: boolean): FFmpegInfo | undefined;
-    /**
-     * Current FFmpeg process
-     */
-    process: childProcess.ChildProcessWithoutNullStreams;
-    /**
-     * Create FFmpeg duplex stream
-     * @param options Options to initialize ffmpeg
-     * @example ```typescript
-     * const ffmpeg = new FFmpeg({
-     *   args: [
-     *     '-analyzeduration', '0',
-     *     '-loglevel', '0',
-     *     '-f', 's16le',
-     *     '-ar', '48000',
-     *     '-ac', '2',
-     *     '-af', 'bass=g=10,acompressor'
-     *   ]
-     * });
-     *
-     * const pcm = input.pipe(ffmpeg);
-     *
-     * pcm.pipe(fs.createWriteStream('./audio.pcm'));
-     * ```
-     */
-    constructor(options?: FFmpegOptions);
-    get _reader(): stream.Readable;
-    get _writer(): stream.Writable;
-    private _copy;
-    _destroy(err: Error | null, cb: Callback<[Error | null]>): unknown;
-    _final(cb: Callback<[]>): void;
-    private _cleanup;
-    toString(): string;
-}
-declare const findFFmpeg: typeof FFmpeg.locate;
-
+/**
+ * Fetch guild queue history
+ * @param node guild queue node resolvable
+ */
 declare function useHistory<Meta = unknown>(node: NodeResolvable): GuildQueueHistory<Meta> | null;
 
+/**
+ * Fetch guild queue player node
+ * @param node Guild queue node resolvable
+ */
 declare function usePlayer<Meta = unknown>(node: NodeResolvable): GuildQueuePlayerNode<Meta> | null;
 
+/**
+ * Fetch guild queue
+ * @param node Guild queue node resolvable
+ */
 declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta> | null;
 
-declare function useMasterPlayer(): Player | null;
+/**
+ * Fetch main player instance
+ * @deprecated
+ */
+declare function useMasterPlayer(): Player | null;
+/**
+ * Fetch main player instance
+ */
+declare function useMainPlayer(): Player | null;
 
-type SetterFN<T, P> = (previous: P) => T;
-declare function useMetadata<T = unknown>(node: NodeResolvable): readonly [() => T, (metadata: T | SetterFN<T, T>) => void];
+type SetterFN$1<T, P> = (previous: P) => T;
+/**
+ * Fetch or manipulate guild queue metadata
+ * @param node Guild queue node resolvable
+ */
+declare function useMetadata<T = unknown>(node: NodeResolvable): readonly [() => T, (metadata: T | SetterFN$1<T, T>) => void];
 
 interface TimelineDispatcherOptions {
     ignoreFilters: boolean;
 }
+/**
+ * Fetch or manipulate current track
+ * @param node Guild queue node resolvable
+ * @param options Options for timeline dispatcher
+ */
 declare function useTimeline(node: NodeResolvable, options?: Partial<TimelineDispatcherOptions>): {
     readonly timestamp: PlayerTimestamp;
     readonly volume: number;
@@ -2400,10 +2467,37 @@ declare function useTimeline(node: NodeResolvable, options?: Partial<TimelineDis
     setPosition(time: number): Promise<boolean>;
 } | null;
 
+/**
+ * Global onAfterCreateStream handler
+ * @param handler The handler callback
+ */
 declare function onAfterCreateStream(handler: OnAfterCreateStreamHandler): void;
 
+/**
+ * Global onBeforeCreateStream handler
+ * @param handler The handler callback
+ */
 declare function onBeforeCreateStream(handler: OnBeforeCreateStreamHandler): void;
 
+type SetterFN = (previous: number) => number;
+/**
+ * Fetch or manipulate player volume
+ * @param node Guild queue node resolvable
+ */
+declare function useVolume(node: NodeResolvable): readonly [() => number, (volume: number | SetterFN) => boolean | undefined];
+
+declare const instances: Collection<string, Player>;
+
+declare const getPlayer: () => Player | null;
+declare const getQueue: <T = unknown>(node: NodeResolvable) => GuildQueue<T> | null;
+interface HookDeclarationContext {
+    getQueue: typeof getQueue;
+    getPlayer: typeof getPlayer;
+    instances: typeof instances;
+}
+type HookDeclaration<T extends (...args: any[]) => any> = (context: HookDeclarationContext) => T;
+declare function createHook<T extends HookDeclaration<(...args: any[]) => any>>(hook: T): ReturnType<T>;
+
 declare const version: string;
 
-export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpeg, FFmpegFilterer, FFmpegInfo, FFmpegOptions, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, 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, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, WithMetadata, createFFmpegStream, findFFmpeg, onAfterCreateStream, onBeforeCreateStream, useHistory, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, 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, 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 };