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

package/dist/index.d.ts

@@ -1,14 +1,22 @@
-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 { RequestOptions } from 'http';
 import Fuse from 'fuse.js';
 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[];
@@ -39,6 +47,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 +158,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 +225,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;
@@ -211,6 +319,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>;
@@ -247,11 +379,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(): Promise<void>;
+    /**
+     * Alias to [GuildQueueHistory].previous()
+     */
+    back(): Promise<void>;
 }
 
 declare const FFMPEG_SRATE_REGEX: RegExp;
@@ -392,6 +528,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
@@ -718,6 +859,10 @@ declare class GuildQueue<Meta = unknown> {
     timeouts: Collection<string, NodeJS.Timeout>;
     stats: GuildQueueStatistics<Meta>;
     constructor(player: Player, options: GuildNodeInit<Meta>);
+    /**
+     * The voice receiver for this queue
+     */
+    get voiceReceiver(): VoiceReceiverNode | null;
     /**
      * Write a debug message to this queue
      * @param m The message to write
@@ -790,6 +935,17 @@ declare class GuildQueue<Meta = unknown> {
      * @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 +960,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 +1055,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;
@@ -1061,7 +1149,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 +1157,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 +1258,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
@@ -1663,7 +1750,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
@@ -1677,4 +1777,4 @@ declare class Util {
 
 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, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamDispatcher, TimeData, Track, TrackJSON, TrackResolvable, TrackSource, Util, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, createFFmpegStream, version };