discord-player 6.5.0 → 6.6.0-dev.0

package/README.md

@@ -1,85 +1,89 @@
 # 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.
-It provides easy set of customizable tools to develop Discord Music bots.
+Discord Player is a robust framework for developing Discord Music bots using JavaScript and TypeScript. It is built on top of the [@discordjs/voice](https://npm.im/@discordjs/voice) library and offers a comprehensive set of customizable tools, making it one of the most feature enrich framework in town.
 
 [![downloadsBadge](https://img.shields.io/npm/dt/discord-player?style=for-the-badge)](https://npmjs.com/discord-player)
 [![versionBadge](https://img.shields.io/npm/v/discord-player?style=for-the-badge)](https://npmjs.com/discord-player)
 [![discordBadge](https://img.shields.io/discord/558328638911545423?style=for-the-badge&color=7289da)](https://androz2091.fr/discord)
 
-# Why Discord Player?
+# Why Choose Discord Player?
 
--   Beginner friendly, easy to understand
+-   Beginner-friendly with easy-to-understand features
 -   TypeScript support
+-   Offers hackable APIs.
 -   Supports audio player sharing
--   Quick and easy to set up
+-   Quick and easy setup process
 -   Wide range of player management features
--   64+ built-in audio filter presets
--   Highly customizable
+-   Offers 64+ built-in audio filter presets
+-   Highly customizable according to your needs
 -   Automatic queue management
 -   Query caching support
--   Wide range of extendable sources via Extractors API
--   Object oriented
--   Built in stats tracker
+-   Extensible sources through the Extractors API
+-   Object-oriented design
+-   Built-in stats tracker
+-   Offers easy debugging methods
+-   Out-of-the-box voice states handling
 
 ## Installation
 
 ### Before you start
 
-Discord Player requires Discord.js 14.0 or higher. PLease make sure you have a compatible version using `npm list discord.js` in your terminal. If you're using an earlier version please update it. The [Discord.JS Guide](https://discordjs.guide/) has resources to help with that.
+Discord Player requires Discord.js 14.0 or higher. Please ensure that you have a compatible version by running `npm list discord.js` in your terminal. If you're using an earlier version, please update it. The [discord.js Guide](https://discordjs.guide) provides resources to assist you with the update process.
 
 #### Main Library
 
 ```bash
-$ yarn add discord-player # main library
-$ yarn add @discord-player/extractor # extractors provider
+$ npm install --save discord-player # main library
+$ npm install --save @discord-player/extractor # extractors provider
 ```
 
-> Discord Player recognizes `@discord-player/extractor` and loads it automatically by default.
+> Discord Player recognizes `@discord-player/extractor` and loads it automatically by default. Just invoke `await player.extractors.loadDefault()`.
 
 #### Opus Library
 
-Discord Player is a high level framework for Discord VoIP. Discord only accepts opus packets, thus you need to install opus library. You can install any of these:
+Since Discord only accepts opus packets, you need to install the opus library. Choose one of the following options:
 
 ```bash
-$ yarn add @discordjs/opus
+$ npm install --save @discordjs/opus
 # or
-$ yarn add opusscript
+$ npm install --save opusscript
 ```
 
 #### FFmpeg or Avconv
 
-FFmpeg or Avconv is required for media transcoding. You can get it from [https://ffmpeg.org](https://www.ffmpeg.org/download.html) or by installing it from npm (ffmpeg-static or other binaries are not recommended):
+FFmpeg or Avconv is required for media transcoding. You can obtain it from [https://ffmpeg.org](https://ffmpeg.org) or install it via npm (we recommend against using ffmpeg-static or other binaries):
 
 ```bash
-$ yarn add ffmpeg-static
+$ npm install --save ffmpeg-static
 # or
-$ yarn add @ffmpeg-installer/ffmpeg
+$ npm install --save @ffmpeg-installer/ffmpeg
 # or
-$ yarn add @node-ffmpeg/node-ffmpeg-installer
+$ npm install --save @node-ffmpeg/node-ffmpeg-installer
 # or
-$ yarn add ffmpeg-binaries
+$ npm install --save ffmpeg-binaries
 ```
 
 > Use `FFMPEG_PATH` environment variable to load ffmpeg from custom path.
 
 #### Streaming Library
 
-You also need to install streaming library if you want to add support for youtube playback. You can install one of these libraries:
+If you want to add support for YouTube playback, you need to install a streaming library. Choose one of the following options:
 
 ```bash
-$ yarn add ytdl-core
+$ npm install --save ytdl-core
 # or
-$ yarn add play-dl
+$ npm install --save play-dl
 # or
-$ yarn add @distube/ytdl-core
+$ npm install --save @distube/ytdl-core
+# or
+$ npm install --save yt-stream
 ```
 
-Done with all these? Let's write a simple music bot then.
+Once you have completed these installations, let's proceed with writing a simple music bot.
 
 ### Setup
 
-Let's create a master player instance.
+Let's create a main player instance. This instance handles and keeps track of all the queues and its components.
 
 ```js
 const { Player } = require('discord-player');
@@ -92,7 +96,6 @@ const client = new Discord.Client({
     intents: ['GuildVoiceStates' /* Other intents */]
 });
 
-
 // this is the entrypoint for discord-player based application
 const player = new Player(client);
 
@@ -104,9 +107,7 @@ await player.extractors.register(SpotifyExtractor, {});
 await player.extractors.register(SoundCloudExtractor, {});
 ```
 
-> **Did You Know?** _Discord Player is by default a singleton._
-
-Now, let's add some event listeners:
+Discord Player is mostly events based. It emits different events based on the context and actions. Let's add a basic event listener to notify the user when a track starts to play:
 
 ```js
 // this event is emitted whenever discord-player starts to play a track
@@ -116,7 +117,7 @@ player.events.on('playerStart', (queue, track) => {
 });
 ```
 
-Let's write the command part. You can define the command as you desire. We will only check the command handler part:
+Let's move on to the command part. You can define the command as per your requirements. We will only focus on the command handler part:
 
 ```js
 async function execute(interaction) {
@@ -143,11 +144,8 @@ async function execute(interaction) {
 }
 ```
 
-That's all it takes to build your own music bot.
-
-#### Check out the [Documentation](https://discord-player.js.org) for more info.
+That's all it takes to build your own music bot. Please check out the [Documentation](https://discord-player.js.org) for more features/functionalities.
 
 ## Community Resources
 
-A curated list of resources (such as open source music bots, extractors, etc.) built by Discord Player community.
-[https://discord-player.js.org/docs/guides/community-resources](https://discord-player.js.org/docs/guides/community-resources)
+Explore a curated list of resources built by the Discord Player community, including open-source music bots and extractors. Visit [https://discord-player.js.org/docs/guides/community-resources](https://discord-player.js.org/docs/guides/community-resources) for more information.

package/dist/index.d.ts

@@ -1,17 +1,15 @@
 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 { 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 { 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>;
@@ -336,16 +334,16 @@ interface VoiceEvents {
     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;
-    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
@@ -416,6 +414,10 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
      * @returns {void}
      */
     disconnect(): void;
+    /**
+     * Destroys this dispatcher
+     */
+    destroy(): void;
     /**
      * Stops the player
      * @returns {void}
@@ -827,6 +829,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
@@ -1000,6 +1018,7 @@ interface GuildNodeInit<Meta = unknown> {
 interface VoiceConnectConfig {
     deaf?: boolean;
     timeout?: number;
+    group?: string;
     audioPlayer?: AudioPlayer;
 }
 interface PostProcessedResult {
@@ -1013,7 +1032,7 @@ declare const GuildQueueEvent: {
     /**
      * Emitted when audio track is added to the queue
      */
-    readonly audioTrackAdd: "audioTrackadd";
+    readonly audioTrackAdd: "audioTrackAdd";
     /**
      * Emitted when audio tracks were added to the queue
      */
@@ -1030,6 +1049,10 @@ declare const GuildQueueEvent: {
      * Emitted when a connection is created
      */
     readonly connection: "connection";
+    /**
+     * Emitted when a voice connection is destroyed
+     */
+    readonly connectionDestroyed: "connectionDestroyed";
     /**
      * Emitted when the bot is disconnected from the channel
      */
@@ -1106,6 +1129,18 @@ declare const GuildQueueEvent: {
      * 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> {
     /**
@@ -1137,6 +1172,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
@@ -1256,6 +1296,21 @@ interface GuildQueueEvents<Meta = unknown> {
      * @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;
@@ -1317,7 +1372,7 @@ declare class GuildQueue<Meta = unknown> {
     /**
      * The voice connection of this queue
      */
-    get connection(): _discordjs_voice.VoiceConnection | null;
+    get connection(): VoiceConnection | null;
     /**
      * The guild this queue belongs to
      */
@@ -1428,6 +1483,11 @@ declare class GuildQueue<Meta = unknown> {
      * @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
@@ -1465,6 +1525,13 @@ 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;
+    get hasDebugger(): boolean;
 }
 
 interface GuildQueueStatisticsMetadata {
@@ -1587,6 +1654,7 @@ declare class VoiceUtils {
         maxTime?: number;
         queue: GuildQueue;
         audioPlayer?: AudioPlayer;
+        group?: string;
     }): Promise<StreamDispatcher>;
     /**
      * Joins a voice channel
@@ -1597,6 +1665,7 @@ declare class VoiceUtils {
     join(channel: VoiceChannel | StageChannel, options?: {
         deaf?: boolean;
         maxTime?: number;
+        group?: string;
     }): Promise<VoiceConnection>;
     /**
      * Disconnects voice connection
@@ -1609,7 +1678,7 @@ declare class VoiceUtils {
      * @param {Snowflake} guild The guild id
      * @returns {StreamDispatcher}
      */
-    getConnection(guild: Snowflake): StreamDispatcher | VoiceConnection | undefined;
+    getConnection(guild: Snowflake, group?: string): StreamDispatcher | VoiceConnection | undefined;
 }
 
 interface QueryCacheOptions {
@@ -1653,6 +1722,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;
@@ -1670,6 +1740,12 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * @param {PlayerInitOptions} [options] The player init options
      */
     constructor(client: Client, options?: PlayerInitOptions);
+    get hasDebugger(): boolean;
+    /**
+     * Override default voice state update handler
+     * @param handler The handler callback
+     */
+    onVoiceStateUpdate(handler: VoiceStateHandler): void;
     debug(m: string): boolean;
     /**
      * Creates discord-player singleton instance.
@@ -2351,93 +2427,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;
@@ -2449,10 +2481,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, CreateStreamOps, 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, StreamConfig, 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 };