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

package/dist/index.d.ts

@@ -1,14 +1,21 @@
-import { User, VoiceChannel, StageChannel, Guild, VoiceState, VoiceBasedChannel, GuildVoiceChannelResolvable, Snowflake, Client, GuildResolvable, UserResolvable } from 'discord.js';
+import { ListenerSignature, DefaultListener, EventEmitter, Collection, Queue, QueueStrategy } from '@discord-player/utils';
+import * as discord_js from 'discord.js';
+import { User, VoiceChannel, StageChannel, UserResolvable, Guild, VoiceState, VoiceBasedChannel, GuildVoiceChannelResolvable, Snowflake, Client, GuildResolvable } from 'discord.js';
 import * as _discordjs_voice from '@discordjs/voice';
-import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, StreamType } from '@discordjs/voice';
+import { AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, StreamType, EndBehaviorType } from '@discordjs/voice';
+import { Readable, Duplex } from 'stream';
 import * as _discord_player_equalizer from '@discord-player/equalizer';
 import { PCMFilters, EqualizerBand, BiquadFilters, FiltersChain } from '@discord-player/equalizer';
 export { AF_NIGHTCORE_RATE, AF_VAPORWAVE_RATE, BASS_EQ_BANDS, FilterType as BiquadFilterType, BiquadFilters, FiltersChain, AudioFilters as PCMAudioFilters, PCMFilters, Q_BUTTERWORTH, VolumeTransformer } from '@discord-player/equalizer';
-import { EventEmitter, Queue, QueueStrategy, Collection } from '@discord-player/utils';
-import { Readable, Duplex } from 'stream';
-import Fuse from 'fuse.js';
+import { RequestOptions } from 'http';
 import { downloadOptions } from 'ytdl-core';
 
+declare class PlayerEventsEmitter<L extends ListenerSignature<L> = DefaultListener> extends EventEmitter<L> {
+    requiredEvents: Array<keyof L>;
+    constructor(requiredEvents?: Array<keyof L>);
+    emit<K extends keyof L>(name: K, ...args: Parameters<L[K]>): boolean;
+}
+
 declare class Playlist {
     readonly player: Player;
     tracks: Track[];
@@ -31,6 +38,14 @@ declare class Playlist {
      */
     constructor(player: Player, data: PlaylistInitData);
     [Symbol.iterator](): Generator<Track, void, undefined>;
+    /**
+     * Estimated duration of this playlist
+     */
+    get estimatedDuration(): number;
+    /**
+     * Formatted estimated duration of this playlist
+     */
+    get durationFormatted(): string;
     /**
      * JSON representation of this playlist
      * @param {boolean} [withTracks=true] If it should build json with tracks
@@ -39,6 +54,104 @@ declare class Playlist {
     toJSON(withTracks?: boolean): PlaylistJSON;
 }
 
+declare class ExtractorExecutionContext {
+    player: Player;
+    store: Collection<string, BaseExtractor>;
+    constructor(player: Player);
+    loadDefault(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    isRegistered(identifier: string): boolean;
+    get size(): number;
+    get(identifier: string): BaseExtractor | undefined;
+    register(_extractor: typeof BaseExtractor): Promise<void>;
+    unregister<K extends string | BaseExtractor>(_extractor: K): Promise<void>;
+    unregisterAll(): Promise<void>;
+    run<T = unknown>(fn: ExtractorExecutionFN<T>, filterBlocked?: boolean): Promise<ExtractorExecutionResult<T> | null>;
+}
+interface ExtractorExecutionResult<T = unknown> {
+    extractor: BaseExtractor;
+    result: T;
+}
+type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
+
+declare class BaseExtractor {
+    context: ExtractorExecutionContext;
+    /**
+     * Identifier for this extractor
+     */
+    static identifier: string;
+    /**
+     * Extractor constructor
+     * @param context Context that instantiated this extractor
+     */
+    constructor(context: ExtractorExecutionContext);
+    /**
+     * Identifier of this extractor
+     */
+    get identifier(): string;
+    /**
+     * This method will be executed when this extractor is activated
+     */
+    activate(): Promise<void>;
+    /**
+     * This method will be executed when this extractor is deactivated
+     */
+    deactivate(): Promise<void>;
+    /**
+     * Validate incoming query
+     * @param query The query to validate
+     */
+    validate(query: string, type?: SearchQueryType | null): Promise<boolean>;
+    /**
+     * Stream the given track
+     * @param info The track to stream
+     */
+    stream(info: Track): Promise<Readable | string>;
+    /**
+     * Handle the given query
+     * @param query The query to handle
+     */
+    handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo>;
+    /**
+     * A stream middleware to handle streams before passing it to the player
+     * @param stream The incoming stream
+     * @param next The next function
+     */
+    handlePostStream(stream: Readable, next: NextFunction): void;
+    /**
+     * Dispatch an event to the player
+     * @param event The event to dispatch
+     * @param args The data to dispatch
+     */
+    emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
+    /**
+     * 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;
 declare class Track {
     player: Player;
@@ -52,7 +165,8 @@ declare class Track {
     requestedBy: User | null;
     playlist?: Playlist;
     queryType: SearchQueryType | null | undefined;
-    readonly raw: RawTrackData;
+    raw: RawTrackData;
+    extractor: BaseExtractor | null;
     readonly id: string;
     /**
      * Track constructor
@@ -118,6 +232,7 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
     readonly connectionTimeout: number;
     readonly voiceConnection: VoiceConnection;
     readonly audioPlayer: AudioPlayer;
+    receiver: VoiceReceiverNode;
     channel: VoiceChannel | StageChannel;
     audioResource?: AudioResource<Track> | null;
     private readyLock;
@@ -150,6 +265,26 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
      * 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
@@ -211,6 +346,30 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
     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;
+    /**
+     * 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>;
@@ -231,6 +390,11 @@ declare class GuildQueueHistory<Meta = unknown> {
      * If history is disabled
      */
     get disabled(): boolean;
+    /**
+     * Gets the size of the queue
+     */
+    get size(): number;
+    getSize(): number;
     /**
      * If history is empty
      */
@@ -247,11 +411,15 @@ declare class GuildQueueHistory<Meta = unknown> {
     /**
      * Play the next track in the queue
      */
-    next(): void;
+    next(): Promise<void>;
     /**
      * Play the previous track in the queue
      */
-    previous(): void;
+    previous(preserveCurrent?: boolean): Promise<void>;
+    /**
+     * Alias to [GuildQueueHistory].previous()
+     */
+    back(): Promise<void>;
 }
 
 declare const FFMPEG_SRATE_REGEX: RegExp;
@@ -392,6 +560,11 @@ declare class GuildQueuePlayerNode<Meta = unknown> {
      * @param force Whether or not to forcefully stop the playback
      */
     stop(force?: boolean): boolean;
+    /**
+     * Play raw audio resource
+     * @param resource The audio resource to play
+     */
+    playRaw(resource: AudioResource): Promise<void>;
     /**
      * Play the given track
      * @param res The track to play
@@ -631,6 +804,18 @@ interface GuildQueueEvents<Meta = unknown> {
      * @param tracks The tracks array
      */
     audioTracksAdd: (queue: GuildQueue<Meta>, track: Track[]) => unknown;
+    /**
+     * Emitted when audio track is removed from the queue
+     * @param queue The queue where this event occurred
+     * @param track The track
+     */
+    audioTrackRemove: (queue: GuildQueue<Meta>, track: Track) => unknown;
+    /**
+     * Emitted when audio tracks are removed from the queue
+     * @param queue The queue where this event occurred
+     * @param track The track
+     */
+    audioTracksRemove: (queue: GuildQueue<Meta>, track: Track[]) => unknown;
     /**
      * Emitted when a connection is created
      * @param queue The queue where this event occurred
@@ -718,6 +903,18 @@ declare class GuildQueue<Meta = unknown> {
     timeouts: Collection<string, NodeJS.Timeout>;
     stats: GuildQueueStatistics<Meta>;
     constructor(player: Player, options: GuildNodeInit<Meta>);
+    /**
+     * Estimated duration of this queue in ms
+     */
+    get estimatedDuration(): number;
+    /**
+     * Formatted duration of this queue
+     */
+    get durationFormatted(): string;
+    /**
+     * The voice receiver for this queue
+     */
+    get voiceReceiver(): VoiceReceiverNode | null;
     /**
      * Write a debug message to this queue
      * @param m The message to write
@@ -777,6 +974,18 @@ declare class GuildQueue<Meta = unknown> {
      * @param mode The repeat mode to apply
      */
     setRepeatMode(mode: QueueRepeatMode): void;
+    /**
+     * Gets the size of the queue
+     */
+    get size(): number;
+    /**
+     * The size of this queue
+     */
+    getSize(): number;
+    /**
+     * Clear this queue
+     */
+    clear(): void;
     /**
      * Check if this queue has no tracks left in it
      */
@@ -786,10 +995,21 @@ declare class GuildQueue<Meta = unknown> {
      */
     isPlaying(): boolean;
     /**
-     * Add track to the queue
+     * 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 | 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;
     /**
      * Connect to a voice channel
      * @param channelResolvable The voice channel to connect to
@@ -804,10 +1024,27 @@ declare class GuildQueue<Meta = unknown> {
      * Delete this queue
      */
     delete(): void;
+    /**
+     * Revives this queue
+     * @returns
+     */
+    revive(): void;
     /**
      * Wait for this queue to initialize
      */
     awaitInitialization(): Promise<boolean>;
+    /**
+     * 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>;
 }
 
 interface GuildQueueStatisticsMetadata {
@@ -882,91 +1119,6 @@ declare class VoiceUtils {
     getConnection(guild: Snowflake): StreamDispatcher | VoiceConnection | undefined;
 }
 
-declare class BaseExtractor {
-    context: ExtractorExecutionContext;
-    /**
-     * Identifier for this extractor
-     */
-    static identifier: string;
-    /**
-     * Extractor constructor
-     * @param context Context that instantiated this extractor
-     */
-    constructor(context: ExtractorExecutionContext);
-    /**
-     * Identifier of this extractor
-     */
-    get identifier(): string;
-    /**
-     * This method will be executed when this extractor is activated
-     */
-    activate(): Promise<void>;
-    /**
-     * This method will be executed when this extractor is deactivated
-     */
-    deactivate(): Promise<void>;
-    /**
-     * Validate incoming query
-     * @param query The query to validate
-     */
-    validate(query: string, type?: SearchQueryType | null): Promise<boolean>;
-    /**
-     * Stream the given track
-     * @param info The track to stream
-     */
-    stream(info: Track): Promise<Readable | string>;
-    /**
-     * Handle the given query
-     * @param query The query to handle
-     */
-    handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo>;
-    /**
-     * A stream middleware to handle streams before passing it to the player
-     * @param stream The incoming stream
-     * @param next The next function
-     */
-    handlePostStream(stream: Readable, next: NextFunction): void;
-    /**
-     * Dispatch an event to the player
-     * @param event The event to dispatch
-     * @param args The data to dispatch
-     */
-    emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
-    /**
-     * Create extractor response
-     * @param playlist The playlist
-     * @param tracks The track array
-     */
-    createResponse(playlist?: Playlist | null, tracks?: Track[]): ExtractorInfo;
-}
-type NextFunction = (error?: Error | null, stream?: Readable) => void;
-interface ExtractorInfo {
-    playlist: Playlist | null;
-    tracks: Track[];
-}
-interface ExtractorSearchContext {
-    type?: SearchQueryType | null;
-    requestedBy?: User | null;
-}
-
-declare class ExtractorExecutionContext {
-    player: Player;
-    store: Collection<string, BaseExtractor>;
-    constructor(player: Player);
-    isRegistered(identifier: string): boolean;
-    get size(): number;
-    get(identifier: string): BaseExtractor | undefined;
-    register(_extractor: typeof BaseExtractor): Promise<void>;
-    unregister<K extends string | BaseExtractor>(_extractor: K): Promise<void>;
-    unregisterAll(): Promise<void>;
-    run<T = unknown>(fn: ExtractorExecutionFN<T>, filterBlocked?: boolean): Promise<ExtractorExecutionResult<T> | null>;
-}
-interface ExtractorExecutionResult<T = unknown> {
-    extractor: BaseExtractor;
-    result: T;
-}
-type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
-
 interface SearchResultData {
     query: string;
     queryType?: SearchQueryType | QueryExtractorSearch | null;
@@ -979,6 +1131,12 @@ declare class SearchResult {
     player: Player;
     private _data;
     constructor(player: Player, _data: SearchResultData);
+    setQueryType(type: SearchQueryType | QueryExtractorSearch): this;
+    setRequestedBy(user: User): this;
+    setExtractor(extractor: BaseExtractor): this;
+    setTracks(tracks: Track[]): this;
+    setQuery(query: string): this;
+    setPlaylist(playlist: Playlist): this;
     /**
      * The search query
      */
@@ -1040,7 +1198,6 @@ declare class QueryCache {
     player: Player;
     options: QueryCacheOptions;
     timer: NodeJS.Timer;
-    fuse: Fuse<Track>;
     constructor(player: Player, options?: QueryCacheOptions);
     get checkInterval(): number;
     cleanup(): Promise<void>;
@@ -1061,7 +1218,7 @@ interface QueryCacheResolverContext {
     queryType?: SearchQueryType | `ext:${string}`;
 }
 
-declare class Player extends EventEmitter<PlayerEvents> {
+declare class Player extends PlayerEventsEmitter<PlayerEvents> {
     #private;
     static _singletonKey: symbol;
     readonly id: string;
@@ -1069,15 +1226,15 @@ declare class Player extends EventEmitter<PlayerEvents> {
     readonly options: PlayerInitOptions;
     nodes: GuildNodeManager<unknown>;
     readonly voiceUtils: VoiceUtils;
-    requiredEvents: string[];
     extractors: ExtractorExecutionContext;
-    events: EventEmitter<GuildQueueEvents<unknown>>;
+    events: PlayerEventsEmitter<GuildQueueEvents<unknown>>;
     /**
      * Creates new Discord Player
      * @param {Client} client The Discord Client
      * @param {PlayerInitOptions} [options] The player init options
      */
     constructor(client: Client, options?: PlayerInitOptions);
+    debug(m: string): boolean;
     /**
      * Creates discord-player singleton instance.
      * @param client The client that instantiated player
@@ -1170,7 +1327,6 @@ declare class Player extends EventEmitter<PlayerEvents> {
      * @returns {string}
      */
     scanDeps(): string;
-    emit<U extends keyof PlayerEvents>(eventName: U, ...args: Parameters<PlayerEvents[U]>): boolean;
     [Symbol.iterator](): Generator<GuildQueue<unknown>, void, undefined>;
     /**
      * Creates `Playlist` instance
@@ -1576,6 +1732,7 @@ interface PlaylistJSON {
  * @property {string[]} [blockExtractors] List of extractors to disable querying metadata from
  * @property {string[]} [blockStreamFrom] List of extractors to disable streaming from
  * @property {QueryCache | null} [queryCache] Query cache provider
+ * @property {boolean} [ignoreInstance] Ignore player instance
  */
 interface PlayerInitOptions {
     autoRegisterExtractor?: boolean;
@@ -1587,6 +1744,7 @@ interface PlayerInitOptions {
     blockExtractors?: string[];
     blockStreamFrom?: string[];
     queryCache?: QueryCache | null;
+    ignoreInstance?: boolean;
 }
 
 declare class AudioFilters {
@@ -1663,7 +1821,20 @@ declare class Util {
      * @param {string} id Node require id
      * @returns {any}
      */
-    static require(id: string): any;
+    static require(id: string): {
+        module: any;
+        error: null;
+    } | {
+        module: null;
+        error: unknown;
+    };
+    static import(id: string): Promise<{
+        module: any;
+        error: null;
+    } | {
+        module: null;
+        error: unknown;
+    }>;
     /**
      * Asynchronous timeout
      * @param {number} time The time in ms to wait
@@ -1675,6 +1846,44 @@ declare class Util {
     static warn(message: string, code?: string, detail?: string): void;
 }
 
+declare class QueryResolver {
+    /**
+     * Query resolver
+     */
+    private constructor();
+    static get regex(): {
+        spotifyAlbumRegex: RegExp;
+        spotifyPlaylistRegex: RegExp;
+        spotifySongRegex: RegExp;
+        vimeoRegex: RegExp;
+        reverbnationRegex: RegExp;
+        attachmentRegex: RegExp;
+        appleMusicAlbumRegex: RegExp;
+        appleMusicPlaylistRegex: RegExp;
+        appleMusicSongRegex: RegExp;
+    };
+    /**
+     * Resolves the given search query
+     * @param {string} query The query
+     * @returns {QueryType}
+     */
+    static resolve(query: string): (typeof QueryType)[keyof typeof QueryType];
+    /**
+     * Parses vimeo id from url
+     * @param {string} query The query
+     * @returns {string}
+     */
+    static getVimeoID(query: string): string | null | undefined;
+    static validateId(q: string): boolean;
+    static validateURL(q: string): boolean;
+}
+
+declare function useHistory<Meta = unknown>(node: NodeResolvable): GuildQueueHistory<Meta> | null;
+
+declare function usePlayer<Meta = unknown>(node: NodeResolvable): GuildQueuePlayerNode<Meta> | null;
+
+declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta> | null;
+
 declare const version: string;
 
-export { AFilterGraph, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvents, PlayerInitOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamDispatcher, TimeData, Track, TrackJSON, TrackResolvable, TrackSource, Util, VoiceConnectConfig, VoiceEvents, VoiceUtils, createFFmpegStream, version };
+export { AFilterGraph, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, 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, Track, TrackJSON, TrackResolvable, TrackSource, Util, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, createFFmpegStream, useHistory, usePlayer, useQueue, version };