discord-player 7.0.0 → 7.1.1-dev.0

package/dist/index.d.ts

@@ -2,13 +2,13 @@ import * as discord_js from 'discord.js';
 import { Client, User, UserResolvable, GuildVoiceChannelResolvable, VoiceChannel, StageChannel, Guild, VoiceState, VoiceBasedChannel, GuildResolvable, Snowflake } from 'discord.js';
 import Eris from 'eris';
 import { ListenerSignature, DefaultListener, EventEmitter, Collection, Queue, QueueStrategy } from '@discord-player/utils';
-import * as stream from 'stream';
 import { Readable, Duplex } from 'stream';
 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 { AudioResource, StreamType, AudioPlayerError, VoiceConnection, AudioPlayer, AudioPlayerStatus } from 'discord-voip';
-export { AudioPlayer, CreateAudioPlayerOptions, JoinConfig, JoinVoiceChannelOptions, createAudioPlayer, getVoiceConnection, getVoiceConnections, joinVoiceChannel } from 'discord-voip';
+export { AudioPlayer, CreateAudioPlayerOptions, JoinConfig, JoinVoiceChannelOptions, StreamType, createAudioPlayer, createAudioResource, getVoiceConnection, getVoiceConnections, joinVoiceChannel } from 'discord-voip';
+import { Transform, Writable, TransformCallback } from 'node:stream';
 import { RequestOptions } from 'http';
 import { FFmpegLib } from '@discord-player/ffmpeg';
 export * from '@discord-player/ffmpeg';
@@ -585,7 +585,7 @@ declare class Track<T = unknown> {
 
 interface CreateStreamOps {
     type?: StreamType;
-    data?: any;
+    data: Track;
     disableVolume?: boolean;
     disableEqualizer?: boolean;
     disableBiquad?: boolean;
@@ -611,6 +611,7 @@ interface VoiceEvents {
     destroyed: () => any;
 }
 declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
+    #private;
     queue: GuildQueue;
     readonly connectionTimeout: number;
     voiceConnection: VoiceConnection;
@@ -672,7 +673,7 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
      * @param {object} [ops] Options
      * @returns {AudioResource}
      */
-    createStream(src: Readable, ops?: CreateStreamOps): Promise<AudioResource<Track<unknown>>>;
+    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;
@@ -732,7 +733,7 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
     get streamTime(): number;
 }
 
-declare class GuildQueueHistory<Meta = unknown> {
+declare class GuildQueueHistory<Meta = any> {
     queue: GuildQueue<Meta>;
     tracks: Queue<Track<unknown>>;
     constructor(queue: GuildQueue<Meta>);
@@ -911,7 +912,7 @@ interface StreamConfig {
     dispatcherConfig: CreateStreamOps;
     playerConfig: ResourcePlayOptions;
 }
-declare class GuildQueuePlayerNode<Meta = unknown> {
+declare class GuildQueuePlayerNode<Meta = any> {
     #private;
     queue: GuildQueue<Meta>;
     tasksQueue: AsyncQueue;
@@ -1082,7 +1083,7 @@ declare function FFMPEG_ARGS_PIPED(fmt?: string): string[];
  * @param stream The source stream
  * @param options FFmpeg stream options
  */
-declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable | Duplex;
+declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable;
 
 type Filters = keyof typeof AudioFilters.filters;
 type EQPreset = {
@@ -1106,7 +1107,7 @@ type EQPreset = {
     Techno: EqualizerBand[];
 };
 declare const EqualizerConfigurationPreset: Readonly<EQPreset>;
-declare class FFmpegFilterer<Meta = unknown> {
+declare class FFmpegFilterer<Meta = any> {
     #private;
     af: GuildQueueAudioFilters<Meta>;
     constructor(af: GuildQueueAudioFilters<Meta>);
@@ -1135,7 +1136,7 @@ declare class FFmpegFilterer<Meta = unknown> {
      * @param source The stream source
      * @param options The stream options
      */
-    createStream(source: string | Readable, options: FFmpegStreamOptions): Readable | stream.Duplex;
+    createStream(source: string | Readable, options: FFmpegStreamOptions): Readable;
     /**
      * Set ffmpeg filters
      * @param filters The filters
@@ -1199,7 +1200,7 @@ interface GuildQueueAFiltersCache {
     volume: number;
     sampleRate: number;
 }
-declare class GuildQueueAudioFilters<Meta = unknown> {
+declare class GuildQueueAudioFilters<Meta = any> {
     queue: GuildQueue<Meta>;
     graph: AFilterGraph<Meta>;
     ffmpeg: FFmpegFilterer<Meta>;
@@ -1232,7 +1233,7 @@ declare class GuildQueueAudioFilters<Meta = unknown> {
      */
     triggerReplay(seek?: number): Promise<boolean>;
 }
-declare class AFilterGraph<Meta = unknown> {
+declare class AFilterGraph<Meta = any> {
     af: GuildQueueAudioFilters<Meta>;
     constructor(af: GuildQueueAudioFilters<Meta>);
     get ffmpeg(): (keyof QueueFilters)[];
@@ -1273,7 +1274,7 @@ interface GuildQueueStatisticsMetadata {
         player: string;
     };
 }
-declare class GuildQueueStatistics<Meta = unknown> {
+declare class GuildQueueStatistics<Meta = any> {
     queue: GuildQueue<Meta>;
     constructor(queue: GuildQueue<Meta>);
     /**
@@ -1472,7 +1473,7 @@ declare class SyncedLyricsProvider {
     resume(): boolean;
 }
 
-interface GuildNodeInit<Meta = unknown> {
+interface GuildNodeInit<Meta = any> {
     guild: Guild;
     queueStrategy: QueueStrategy;
     equalizer: EqualizerBand[] | boolean;
@@ -1506,6 +1507,8 @@ interface GuildNodeInit<Meta = unknown> {
     disableBiquad: boolean;
     disableResampler: boolean;
     disableFallbackStream: boolean;
+    enableStreamInterceptor: boolean;
+    verifyFallbackStream: boolean;
 }
 interface VoiceConnectConfig {
     deaf?: boolean;
@@ -1518,7 +1521,7 @@ interface PostProcessedResult {
     type: StreamType;
 }
 type OnBeforeCreateStreamHandler = (track: Track, queryType: SearchQueryType, queue: GuildQueue) => Promise<Readable | null>;
-type OnAfterCreateStreamHandler = (stream: Readable, queue: GuildQueue) => Promise<PostProcessedResult | null>;
+type OnAfterCreateStreamHandler<T = unknown> = (stream: Readable, queue: GuildQueue, track: Track<T>) => Promise<PostProcessedResult | null>;
 type PlayerTriggeredReason = 'filters' | 'normal';
 declare const GuildQueueEvent: {
     /**
@@ -1637,6 +1640,10 @@ declare const GuildQueueEvent: {
      * Emitted when a queue is trying to add similar track for autoplay
      */
     readonly WillAutoPlay: "willAutoPlay";
+    /**
+     * Emitted when sample rate is updated
+     */
+    readonly SampleRateUpdate: "sampleRateUpdate";
 };
 type GuildQueueEvent = (typeof GuildQueueEvent)[keyof typeof GuildQueueEvent];
 declare enum TrackSkipReason {
@@ -1825,6 +1832,13 @@ interface GuildQueueEvents<Meta = any> {
      * @param done Done callback
      */
     [GuildQueueEvent.WillAutoPlay]: (queue: GuildQueue<Meta>, tracks: Track[], done: (track: Track | null) => void) => unknown;
+    /**
+     * Emitted when sample rate is updated
+     * @param queue The queue where this event occurred
+     * @param oldRate The old sample rate
+     * @param newRate The new sample rate
+     */
+    [GuildQueueEvent.SampleRateUpdate]: (queue: GuildQueue<Meta>, oldRate: number, newRate: number) => unknown;
 }
 /**
  * The queue repeat mode. This can be one of:
@@ -1852,7 +1866,7 @@ declare const QueueRepeatMode: {
     readonly AUTOPLAY: 3;
 };
 type QueueRepeatMode = (typeof QueueRepeatMode)[keyof typeof QueueRepeatMode];
-declare class GuildQueue<Meta = unknown> {
+declare class GuildQueue<Meta = any> {
     #private;
     player: Player;
     options: GuildNodeInit<Meta>;
@@ -1870,6 +1884,10 @@ declare class GuildQueue<Meta = unknown> {
     tasksQueue: AsyncQueue;
     syncedLyricsProvider: SyncedLyricsProvider;
     constructor(player: Player, options: GuildNodeInit<Meta>);
+    /**
+     * Whether this queue can intercept streams
+     */
+    canIntercept(): boolean;
     /**
      * Estimated duration of this queue in ms
      */
@@ -2010,6 +2028,18 @@ declare class GuildQueue<Meta = unknown> {
      * @param track The track to remove
      */
     removeTrack(track: TrackResolvable): Track<unknown> | null;
+    /**
+     * Prepends a track or track resolvable to the queue
+     * @param track The track resolvable to insert
+     * @param index The index to insert the track at (defaults to 0). If > 0, the inserted track will be placed before the track at the given index.
+     */
+    prepend(track: Track | Queue<Track> | Array<Track>, index?: number): void;
+    /**
+     * Appends a track or track resolvable to the queue
+     * @param track The track resolvable to insert
+     * @param index The index to insert the track at (defaults to 0). If > 0, the inserted track will be placed after the track at the given index.
+     */
+    append(track: Track | Queue<Track> | Array<Track>, index?: number): void;
     /**
      * Inserts the track to the given index
      * @param track The track to insert
@@ -2106,7 +2136,7 @@ declare class GuildQueue<Meta = unknown> {
     get hasDebugger(): boolean;
 }
 
-interface GuildNodeCreateOptions<T = unknown> {
+interface GuildNodeCreateOptions<T = any> {
     strategy?: QueueStrategy;
     volume?: number;
     equalizer?: EqualizerBand[];
@@ -2139,11 +2169,13 @@ interface GuildNodeCreateOptions<T = unknown> {
     disableBiquad?: boolean;
     disableResampler?: boolean;
     disableFallbackStream?: boolean;
+    enableStreamInterceptor?: boolean;
+    verifyFallbackStream?: boolean;
 }
 type NodeResolvable = GuildQueue | GuildResolvable;
-declare class GuildNodeManager<Meta = unknown> {
+declare class GuildNodeManager<Meta = any> {
     player: Player;
-    cache: Collection<string, GuildQueue<unknown>>;
+    cache: Collection<string, GuildQueue<any>>;
     constructor(player: Player);
     /**
      * Create guild queue if it does not exist
@@ -2311,7 +2343,10 @@ declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta
 declare function useMainPlayer(): Player;
 
 type SetterFN$1<T, P> = (previous: P) => T;
-type MetadataDispatch<T> = readonly [() => T, (metadata: T | SetterFN$1<T, T>) => void];
+type MetadataDispatch<T> = readonly [
+    () => T,
+    (metadata: T | SetterFN$1<T, T>) => void
+];
 /**
  * Fetch or manipulate guild queue metadata
  * @param node Guild queue node resolvable
@@ -2353,7 +2388,10 @@ declare function onAfterCreateStream(handler: OnAfterCreateStreamHandler): void;
 declare function onBeforeCreateStream(handler: OnBeforeCreateStreamHandler): void;
 
 type SetterFN = (previous: number) => number;
-type VolumeDispatch = readonly [() => number, (volume: number | SetterFN) => boolean | undefined];
+type VolumeDispatch = readonly [
+    () => number,
+    (volume: number | SetterFN) => boolean | undefined
+];
 /**
  * Fetch or manipulate player volume
  * @param node Guild queue node resolvable
@@ -2535,6 +2573,80 @@ interface HooksCtx {
     guild: Guild;
 }
 
+/**
+ * Represents a stream that can be intercepted and consumed without affecting the original consumer.
+ * @example const stream = new InterceptedStream();
+ *
+ * // real consumer
+ * stream.pipe(fs.createWriteStream('file.txt'));
+ *
+ * // man in the middle consumer
+ * const manInTheMiddle = new Writable({
+ *  write(chunk, encoding, callback) {
+ *   console.log(chunk.toString());
+ *   callback();
+ *  }
+ * });
+ *
+ * // stream.interceptors is a Set of Writable streams
+ * stream.interceptors.add(manInTheMiddle);
+ */
+declare class InterceptedStream extends Transform {
+    #private;
+    readonly interceptors: Set<Writable>;
+    /**
+     * Start intercepting the stream. This is the default state of InterceptedStream.
+     */
+    startIntercepting(): void;
+    /**
+     * Stop intercepting the stream. This will prevent the stream from being consumed by the interceptors.
+     * This can be useful when you want to temporarily stop the interception. The stopped state can be resumed by calling startIntercepting again.
+     */
+    stopIntercepting(): void;
+    /**
+     * Whether the stream is being intercepted
+     */
+    isIntercepting(): boolean;
+    _transform(chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback): void;
+    _final(callback: TransformCallback): void;
+    _destroy(error: Error, callback: TransformCallback): void;
+}
+
+type Awaitable<T> = T | PromiseLike<T>;
+type ShouldInterceptFunction = <T = any>(queue: GuildQueue<T>, track: Track, format: StreamType, stream: InterceptedStream) => Awaitable<boolean>;
+type OnInterceptedStreamHandler = <T = any>(queue: GuildQueue<T>, track: Track, format: StreamType, stream: InterceptedStream) => Awaitable<void>;
+interface PlayerStreamInterceptorOptions {
+    /**
+     * Determines whether the stream should be intercepted.
+     */
+    shouldIntercept?: ShouldInterceptFunction;
+}
+declare class PlayerStreamInterceptor {
+    #private;
+    readonly player: Player;
+    private readonly options;
+    /**
+     * Creates a new PlayerStreamInterceptor instance.
+     * @param player The player instance
+     * @param options The interceptor options
+     */
+    constructor(player: Player, options: PlayerStreamInterceptorOptions);
+    /**
+     * Handles the intercepted stream.
+     * @param queue The guild queue
+     * @param track The track
+     * @param stream The intercepted stream
+     * @returns Whether the stream was intercepted
+     */
+    handle<T = unknown>(queue: GuildQueue<T>, track: Track, type: StreamType, stream: InterceptedStream): Promise<boolean>;
+    /**
+     * Adds a new intercepted stream listener.
+     * @param handler The handler
+     * @returns A function to remove the listener
+     */
+    onStream(handler: OnInterceptedStreamHandler): () => void;
+}
+
 interface PlayerEvents {
     debug: (message: string) => any;
     error: (error: Error) => any;
@@ -2549,7 +2661,7 @@ declare const PlayerEvent: {
     readonly VoiceStateUpdate: "voiceStateUpdate";
 };
 type PlayerEvent = (typeof PlayerEvent)[keyof typeof PlayerEvent];
-interface PlayerNodeInitializationResult<T = unknown> {
+interface PlayerNodeInitializationResult<T = any> {
     track: Track;
     extractor: BaseExtractor | null;
     searchResult: SearchResult;
@@ -2627,7 +2739,7 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
     /**
      * The player nodes (queue) manager
      */
-    nodes: GuildNodeManager<unknown>;
+    nodes: GuildNodeManager<any>;
     /**
      * The voice api utilities
      */
@@ -2677,7 +2789,7 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
     /**
      * Alias to `Player.nodes`.
      */
-    get queues(): GuildNodeManager<unknown>;
+    get queues(): GuildNodeManager<any>;
     /**
      * Event loop latency in ms. If your bot is laggy and this returns a number above 20ms for example,
      * some expensive task is being executed on the current thread which is slowing down the event loop.
@@ -2789,7 +2901,7 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * @returns {string}
      */
     scanDeps(): string;
-    [Symbol.iterator](): Generator<GuildQueue<unknown>, void, undefined>;
+    [Symbol.iterator](): Generator<GuildQueue<any>, void, undefined>;
     /**
      * Creates `Playlist` instance
      * @param data The data to initialize a playlist
@@ -2800,6 +2912,16 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * @param resource The audio resource
      */
     createTrackFromAudioResource(resource: AudioResource): Track<Record<string, unknown>>;
+    /**
+     * Handles intercepting streams
+     * @param stream The stream to intercept
+     */
+    handleInterceptingStream(queue: GuildQueue, track: Track, format: StreamType, stream: InterceptedStream): Promise<boolean | undefined>;
+    /**
+     * Creates a global stream interceptor
+     * @param options The stream interceptor options
+     */
+    createStreamInterceptor(options: PlayerStreamInterceptorOptions): PlayerStreamInterceptor;
 }
 
 type SerializedPlaylist = ReturnType<Playlist['serialize']>;
@@ -3204,7 +3326,7 @@ declare class Util {
     static randomChoice<T>(src: T[]): T;
     static arrayCloneShuffle<T>(src: T[]): T[];
 }
-declare const VALIDATE_QUEUE_CAP: (queue: GuildQueue, items: Playlist | Track | Track[]) => void;
+declare const VALIDATE_QUEUE_CAP: (queue: GuildQueue, items: Playlist | Track | Track[] | number) => void;
 
 declare class DiscordPlayerError extends Error {
     readonly code: ErrorCodes;
@@ -3318,4 +3440,4 @@ declare const DependencyReportGenerator: {
 
 declare const version: string;
 
-export { AFilterGraph, AsyncQueue, type AsyncQueueAcquisitionOptions, AsyncQueueEntry, type AsyncQueueExceptionHandler, AudioFilters, BaseExtractor, Context, type ContextReceiver, type CreateStreamOps, type DependenciesReport, DependencyReportGenerator, DiscordPlayerQueryResultCache, type Encodable, EqualizerConfigurationPreset, ExtractorExecutionContext, type ExtractorExecutionEvents, type ExtractorExecutionFN, type ExtractorExecutionResult, type ExtractorInfo, type ExtractorResolvable, type ExtractorSearchContext, type ExtractorSession, type ExtractorStreamable, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, type FFmpegReport, type FFmpegStreamOptions, type FilterGraph, type FiltersName, type GuildNodeCreateOptions, type GuildNodeInit, GuildNodeManager, GuildQueue, type GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, type GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, GuildQueueStatistics, type GuildQueueStatisticsMetadata, type GuildQueueTimeline, type LrcGetParams, type LrcGetResult, LrcLib, type LrcSearchParams, type LrcSearchResult, type MaybeNull, type MetadataDispatch, type NextFunction, type NodeResolvable, type OnAfterCreateStreamHandler, type OnBeforeCreateStreamHandler, type PackageJSON, type PlayOptions, Player, PlayerEvent, type PlayerEvents, PlayerEventsEmitter, type PlayerInitOptions, type PlayerNodeInitializationResult, type PlayerNodeInitializerOptions, type PlayerProgressbarOptions, type PlayerSearchResult, type PlayerTimestamp, type PlayerTriggeredReason, Playlist, type PlaylistInitData, type PlaylistJSON, type PostProcessedResult, QueryCache, type QueryCacheOptions, type QueryCacheProvider, type QueryCacheResolverContext, type QueryExtractorSearch, QueryResolver, QueryType, type QueueFilters, QueueRepeatMode, type RawTrackData, type RequestEntity, type ResolvedQuery, type ResourcePlayOptions, type Runtime, type RuntimeType, type SearchOptions, type SearchQueryType, SearchResult, type SearchResultData, SequentialBucket, type SerializedPlaylist, type SerializedTrack, SerializedType, type SetterFN$1 as SetterFN, type SkipOptions, type StreamConfig, StreamDispatcher, type TimeData, type TimelineDispatcherOptions, Track, type TrackJSON, type TrackLike, type TrackResolvable, TrackSkipReason, type TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, type VoiceConnectConfig, type VoiceEvents, type VoiceStateHandler, VoiceUtils, type WithMetadata, createContext, createErisCompat, createFFmpegStream, decode, deserialize, encode, isErisProxy, onAfterCreateStream, onBeforeCreateStream, serialize, tryIntoThumbnailString, useContext, useHistory, useMainPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };
+export { AFilterGraph, AsyncQueue, type AsyncQueueAcquisitionOptions, AsyncQueueEntry, type AsyncQueueExceptionHandler, AudioFilters, BaseExtractor, Context, type ContextReceiver, type CreateStreamOps, type DependenciesReport, DependencyReportGenerator, DiscordPlayerQueryResultCache, type Encodable, EqualizerConfigurationPreset, ExtractorExecutionContext, type ExtractorExecutionEvents, type ExtractorExecutionFN, type ExtractorExecutionResult, type ExtractorInfo, type ExtractorResolvable, type ExtractorSearchContext, type ExtractorSession, type ExtractorStreamable, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, type FFmpegReport, type FFmpegStreamOptions, type FilterGraph, type FiltersName, type GuildNodeCreateOptions, type GuildNodeInit, GuildNodeManager, GuildQueue, type GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, type GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, GuildQueueStatistics, type GuildQueueStatisticsMetadata, type GuildQueueTimeline, InterceptedStream, type LrcGetParams, type LrcGetResult, LrcLib, type LrcSearchParams, type LrcSearchResult, type MaybeNull, type MetadataDispatch, type NextFunction, type NodeResolvable, type OnAfterCreateStreamHandler, type OnBeforeCreateStreamHandler, type OnInterceptedStreamHandler, type PackageJSON, type PlayOptions, Player, PlayerEvent, type PlayerEvents, PlayerEventsEmitter, type PlayerInitOptions, type PlayerNodeInitializationResult, type PlayerNodeInitializerOptions, type PlayerProgressbarOptions, type PlayerSearchResult, PlayerStreamInterceptor, type PlayerStreamInterceptorOptions, type PlayerTimestamp, type PlayerTriggeredReason, Playlist, type PlaylistInitData, type PlaylistJSON, type PostProcessedResult, QueryCache, type QueryCacheOptions, type QueryCacheProvider, type QueryCacheResolverContext, type QueryExtractorSearch, QueryResolver, QueryType, type QueueFilters, QueueRepeatMode, type RawTrackData, type RequestEntity, type ResolvedQuery, type ResourcePlayOptions, type Runtime, type RuntimeType, type SearchOptions, type SearchQueryType, SearchResult, type SearchResultData, SequentialBucket, type SerializedPlaylist, type SerializedTrack, SerializedType, type SetterFN$1 as SetterFN, type ShouldInterceptFunction, type SkipOptions, type StreamConfig, StreamDispatcher, type TimeData, type TimelineDispatcherOptions, Track, type TrackJSON, type TrackLike, type TrackResolvable, TrackSkipReason, type TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, type VoiceConnectConfig, type VoiceEvents, type VoiceStateHandler, VoiceUtils, type WithMetadata, createContext, createErisCompat, createFFmpegStream, decode, deserialize, encode, isErisProxy, onAfterCreateStream, onBeforeCreateStream, serialize, tryIntoThumbnailString, useContext, useHistory, useMainPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };