discord-player 6.6.3 → 6.6.5-dev.0

package/dist/index.d.ts

@@ -31,6 +31,7 @@ interface CreateStreamOps {
     volume?: number;
     disableResampler?: boolean;
     sampleRate?: number;
+    skipFFmpeg?: boolean;
 }
 interface VoiceEvents {
     error: (error: AudioPlayerError) => any;
@@ -145,6 +146,7 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
     /**
      * Play stream
      * @param {AudioResource<Track>} [resource=this.audioResource] The audio resource to play
+     * @param {boolean} [opus=false] Whether or not to use opus
      * @returns {Promise<StreamDispatcher>}
      */
     playStream(resource?: AudioResource<Track>): Promise<this | undefined>;
@@ -172,7 +174,7 @@ interface VoiceReceiverOptions {
     silenceDuration?: number;
     crc?: boolean;
 }
-type RawTrackInit = Partial<Omit<RawTrackData, 'author' | 'playlist' | 'source' | 'engine' | 'raw' | 'queryType' | 'description' | 'views'>>;
+declare type RawTrackInit = Partial<Omit<RawTrackData, 'author' | 'playlist' | 'source' | 'engine' | 'raw' | 'queryType' | 'description' | 'views'>>;
 declare class VoiceReceiverNode {
     dispatcher: StreamDispatcher;
     constructor(dispatcher: StreamDispatcher);
@@ -252,7 +254,7 @@ interface AsyncQueueAcquisitionOptions {
      */
     signal?: AbortSignal;
 }
-type AsyncQueueExceptionHandler = (exception: Error) => void;
+declare type AsyncQueueExceptionHandler = (exception: Error) => void;
 declare class AsyncQueue {
     /**
      * The queued entries
@@ -513,8 +515,8 @@ declare function FFMPEG_ARGS_PIPED(fmt?: string): string[];
  */
 declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable;
 
-type Filters = keyof typeof AudioFilters.filters;
-type EQPreset = {
+declare type Filters = keyof typeof AudioFilters.filters;
+declare type EQPreset = {
     Flat: EqualizerBand[];
     Classical: EqualizerBand[];
     Club: EqualizerBand[];
@@ -539,6 +541,10 @@ declare class FFmpegFilterer<Meta = unknown> {
     #private;
     af: GuildQueueAudioFilters<Meta>;
     constructor(af: GuildQueueAudioFilters<Meta>);
+    /**
+     * Indicates whether ffmpeg may be skipped
+     */
+    get skippable(): boolean;
     /**
      * Set input args for FFmpeg
      */
@@ -736,6 +742,11 @@ interface GuildNodeInit<Meta = unknown> {
     maxHistorySize?: number;
     preferBridgedMetadata: boolean;
     pauseOnEmpty?: boolean;
+    disableVolume: boolean;
+    disableEqualizer: boolean;
+    disableFilterer: boolean;
+    disableBiquad: boolean;
+    disableResampler: boolean;
 }
 interface VoiceConnectConfig {
     deaf?: boolean;
@@ -747,9 +758,9 @@ interface PostProcessedResult {
     stream: Readable;
     type: StreamType;
 }
-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 type OnBeforeCreateStreamHandler = (track: Track, queryType: SearchQueryType, queue: GuildQueue) => Promise<Readable | null>;
+declare type OnAfterCreateStreamHandler = (stream: Readable, queue: GuildQueue) => Promise<PostProcessedResult | null>;
+declare type PlayerTriggeredReason = 'filters' | 'normal';
 declare const GuildQueueEvent: {
     /**
      * Emitted when audio track is added to the queue
@@ -1267,11 +1278,23 @@ declare class GuildQueue<Meta = unknown> {
     get hasDebugger(): boolean;
 }
 
-type TrackResolvable = Track | string | number;
-type WithMetadata<T extends object, M> = T & {
+declare enum SerializedType {
+    Track = "track",
+    Playlist = "playlist"
+}
+declare type Encodable = SerializedTrack | SerializedPlaylist;
+declare function serialize(data: Track | Playlist | any): any;
+declare function deserialize(player: Player, data: Encodable): Track<unknown> | Playlist;
+declare function encode(data: Encodable): string;
+declare function decode(data: string): any;
+declare function tryIntoThumbnailString(data: any): any;
+
+declare type TrackResolvable = Track | string | number;
+declare type WithMetadata<T extends object, M> = T & {
     metadata: M;
     requestMetadata(): Promise<M>;
 };
+declare type SerializedTrack = ReturnType<Track['serialize']>;
 declare class Track<T = unknown> {
     readonly player: Player;
     title: string;
@@ -1335,6 +1358,32 @@ declare class Track<T = unknown> {
      * Raw JSON representation of this track
      */
     toJSON(hidePlaylist?: boolean): TrackJSON;
+    /**
+     * Serialized track data that can be reconstructed
+     */
+    serialize(): {
+        title: string;
+        description: string;
+        author: string;
+        url: string;
+        thumbnail: any;
+        duration: string;
+        views: number;
+        requested_by: unknown;
+        source: TrackSource;
+        live: boolean;
+        query_type: SearchQueryType | null | undefined;
+        extractor: string | null;
+        metadata: T | null;
+        $type: SerializedType;
+        $encoder_version: string;
+    };
+    /**
+     * Construct a track from serialized data
+     * @param player Player instance
+     * @param data Serialized data
+     */
+    static fromSerialized(player: Player, data: ReturnType<Track['serialize']>): Track<unknown>;
     /**
      * Get belonging queues of this track
      */
@@ -1347,6 +1396,7 @@ declare class Track<T = unknown> {
     play<T = unknown>(channel: GuildVoiceChannelResolvable, options?: PlayerNodeInitializerOptions<T>): Promise<PlayerNodeInitializationResult<T>>;
 }
 
+declare type SerializedPlaylist = ReturnType<Playlist['serialize']>;
 declare class Playlist {
     readonly player: Player;
     tracks: Track[];
@@ -1383,6 +1433,51 @@ declare class Playlist {
      * @returns {PlaylistJSON}
      */
     toJSON(withTracks?: boolean): PlaylistJSON;
+    /**
+     * Serialize this playlist into reconstructable data
+     */
+    serialize(): {
+        tracks: {
+            title: string;
+            description: string;
+            author: string;
+            url: string;
+            thumbnail: any;
+            duration: string; /**
+             * Play this playlist to the given voice channel. If queue exists and another track is being played, this playlist will be added to the queue.
+             * @param channel Voice channel on which this playlist shall be played
+             * @param options Node initialization options
+             */
+            views: number;
+            requested_by: unknown;
+            source: TrackSource;
+            live: boolean;
+            query_type: SearchQueryType | null | undefined;
+            extractor: string | null;
+            metadata: unknown;
+            $type: SerializedType;
+            $encoder_version: string;
+        }[];
+        title: string;
+        description: string;
+        thumbnail: any;
+        type: "playlist" | "album";
+        source: TrackSource;
+        author: {
+            name: string;
+            url: string;
+        };
+        id: string;
+        url: string;
+        $type: SerializedType;
+        $encoder_version: string;
+    };
+    /**
+     * Deserialize this playlist from serialized data
+     * @param player Player instance
+     * @param data Serialized data
+     */
+    static fromSerialized(player: Player, data: SerializedPlaylist): Playlist;
     /**
      * Play this playlist to the given voice channel. If queue exists and another track is being played, this playlist will be added to the queue.
      * @param channel Voice channel on which this playlist shall be played
@@ -1479,8 +1574,12 @@ interface ExtractorExecutionResult<T = unknown> {
     error: Error | null;
     result: T;
 }
-type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
+declare type ExtractorExecutionFN<T = unknown> = (extractor: BaseExtractor) => Promise<T | boolean>;
 
+declare type ExtractorStreamable = Readable | string | {
+    $fmt: string;
+    stream: Readable;
+};
 declare class BaseExtractor<T extends object = object> {
     context: ExtractorExecutionContext;
     options: T;
@@ -1525,7 +1624,7 @@ declare class BaseExtractor<T extends object = object> {
      * Stream the given track
      * @param info The track to stream
      */
-    stream(info: Track): Promise<Readable | string>;
+    stream(info: Track): Promise<ExtractorStreamable>;
     /**
      * Handle the given query
      * @param query The query to handle
@@ -1563,8 +1662,12 @@ declare class BaseExtractor<T extends object = object> {
      * IP rotator instance, if available
      */
     get routePlanner(): IPRotator | null;
+    /**
+     * A flag to indicate `Demuxable` stream support for `opus`/`ogg/opus`/`webm/opus` formats.
+     */
+    get supportsDemux(): boolean;
 }
-type NextFunction = (error?: Error | null, stream?: Readable) => void;
+declare type NextFunction = (error?: Error | null, stream?: Readable) => void;
 interface ExtractorInfo {
     playlist: Playlist | null;
     tracks: Track[];
@@ -1642,7 +1745,7 @@ declare class SearchResult {
         playlist: PlaylistJSON | null;
         tracks: TrackJSON[];
         extractor: string | null;
-        requestedBy: {} | null;
+        requestedBy: unknown;
     };
 }
 
@@ -1774,7 +1877,7 @@ interface PlayerNodeInitializationResult<T = unknown> {
     searchResult: SearchResult;
     queue: GuildQueue<T>;
 }
-type TrackLike = string | Track | SearchResult | Track[] | Playlist;
+declare type TrackLike = string | Track | SearchResult | Track[] | Playlist;
 interface PlayerNodeInitializerOptions<T> extends SearchOptions {
     nodeOptions?: GuildNodeCreateOptions<T>;
     connectionOptions?: VoiceConnectConfig;
@@ -1782,7 +1885,7 @@ interface PlayerNodeInitializerOptions<T> extends SearchOptions {
     signal?: AbortSignal;
     afterSearch?: (result: SearchResult) => Promise<SearchResult>;
 }
-type VoiceStateHandler = (player: Player, queue: GuildQueue, oldVoiceState: VoiceState, newVoiceState: VoiceState) => Awaited<void>;
+declare type VoiceStateHandler = (player: Player, queue: GuildQueue, oldVoiceState: VoiceState, newVoiceState: VoiceState) => Awaited<void>;
 declare class Player extends PlayerEventsEmitter<PlayerEvents> {
     #private;
     static readonly version: string;
@@ -1955,11 +2058,11 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
 
 interface GuildNodeCreateOptions<T = unknown> {
     strategy?: QueueStrategy;
-    volume?: number | boolean;
-    equalizer?: EqualizerBand[] | boolean;
-    a_filter?: PCMFilters[] | boolean;
-    biquad?: BiquadFilters | boolean;
-    resampler?: number | boolean;
+    volume?: number;
+    equalizer?: EqualizerBand[];
+    a_filter?: PCMFilters[];
+    biquad?: BiquadFilters;
+    resampler?: number;
     disableHistory?: boolean;
     skipOnNoStream?: boolean;
     onBeforeCreateStream?: OnBeforeCreateStreamHandler;
@@ -1981,8 +2084,13 @@ interface GuildNodeCreateOptions<T = unknown> {
     maxSize?: number;
     maxHistorySize?: number;
     preferBridgedMetadata?: boolean;
+    disableVolume?: boolean;
+    disableEqualizer?: boolean;
+    disableFilterer?: boolean;
+    disableBiquad?: boolean;
+    disableResampler?: boolean;
 }
-type NodeResolvable = GuildQueue | GuildResolvable;
+declare type NodeResolvable = GuildQueue | GuildResolvable;
 declare class GuildNodeManager<Meta = unknown> {
     player: Player;
     cache: Collection<string, GuildQueue<unknown>>;
@@ -2020,13 +2128,13 @@ declare class GuildNodeManager<Meta = unknown> {
     resolveId(node: NodeResolvable): string | null;
 }
 
-type FiltersName = keyof QueueFilters;
+declare type FiltersName = keyof QueueFilters;
 interface PlayerSearchResult {
     playlist: Playlist | null;
     tracks: Track[];
 }
 /**
- * @typedef {AudioFilters} QueueFilters
+ * Represents FFmpeg filters
  */
 interface QueueFilters {
     bassboost_low?: boolean;
@@ -2072,71 +2180,112 @@ interface QueueFilters {
  * - spotify
  * - apple_music
  * - arbitrary
- * @typedef {string} TrackSource
- */
-type TrackSource = 'soundcloud' | 'youtube' | 'spotify' | 'apple_music' | 'arbitrary';
-/**
- * @typedef {object} RawTrackData
- * @property {string} title The title
- * @property {string} description The description
- * @property {string} author The author
- * @property {string} url The url
- * @property {string} thumbnail The thumbnail
- * @property {string} duration The duration
- * @property {number} views The views
- * @property {User} requestedBy The user who requested this track
- * @property {Playlist} [playlist] The playlist
- * @property {TrackSource} [source="arbitrary"] The source
- * @property {any} [engine] The engine
- * @property {boolean} [live] If this track is live
- * @property {any} [raw] The raw data
  */
+declare type TrackSource = 'soundcloud' | 'youtube' | 'spotify' | 'apple_music' | 'arbitrary';
 interface RawTrackData {
+    /**
+     * The title
+     */
     title: string;
+    /**
+     * The description
+     */
     description: string;
+    /**
+     * The author
+     */
     author: string;
+    /**
+     * The url
+     */
     url: string;
+    /**
+     * The thumbnail
+     */
     thumbnail: string;
+    /**
+     * The duration
+     */
     duration: string;
+    /**
+     * The duration in ms
+     */
     views: number;
+    /**
+     * The user who requested this track
+     */
     requestedBy?: User | null;
+    /**
+     * The playlist
+     */
     playlist?: Playlist;
+    /**
+     * The source
+     */
     source?: TrackSource;
+    /**
+     * The engine
+     */
     engine?: any;
+    /**
+     * If this track is live
+     */
     live?: boolean;
+    /**
+     * The raw data
+     */
     raw?: any;
+    /**
+     * The query type
+     */
     queryType?: SearchQueryType;
 }
-/**
- * @typedef {object} TimeData
- * @property {number} days Time in days
- * @property {number} hours Time in hours
- * @property {number} minutes Time in minutes
- * @property {number} seconds Time in seconds
- */
 interface TimeData {
+    /**
+     * Time in days
+     */
     days: number;
+    /**
+     * Time in hours
+     */
     hours: number;
+    /**
+     * Time in minutes
+     */
     minutes: number;
+    /**
+     * Time in seconds
+     */
     seconds: number;
 }
-/**
- * @typedef {object} PlayerProgressbarOptions
- * @property {boolean} [timecodes] If it should render time codes
- * @property {boolean} [queue] If it should create progress bar for the whole queue
- * @property {number} [length] The bar length
- * @property {string} [leftChar] The elapsed time track
- * @property {string} [rightChar] The remaining time track
- * @property {string} [separator] The separation between timestamp and line
- * @property {string} [indicator] The indicator
- */
 interface PlayerProgressbarOptions {
+    /**
+     * If it should render time codes
+     */
     timecodes?: boolean;
+    /**
+     * If it should create progress bar for the whole queue
+     */
     length?: number;
+    /**
+     * The bar length
+     */
     leftChar?: string;
+    /**
+     * The elapsed time track
+     */
     rightChar?: string;
+    /**
+     * The remaining time track
+     */
     separator?: string;
+    /**
+     * The separation between timestamp and line
+     */
     indicator?: string;
+    /**
+     * The indicator
+     */
     queue?: boolean;
 }
 /**
@@ -2192,7 +2341,7 @@ declare const QueryType: {
     readonly FILE: "file";
     readonly AUTO_SEARCH: "autoSearch";
 };
-type SearchQueryType = keyof typeof QueryType | (typeof QueryType)[keyof typeof QueryType];
+declare type SearchQueryType = keyof typeof QueryType | (typeof QueryType)[keyof typeof QueryType];
 interface PlayerEvents {
     debug: (message: string) => any;
     error: (error: Error) => any;
@@ -2203,35 +2352,49 @@ declare enum PlayerEvent {
     error = "error",
     voiceStateUpdate = "voiceStateUpdate"
 }
-/**
- * @typedef {object} PlayOptions
- * @property {boolean} [filtersUpdate=false] If this play was triggered for filters update
- * @property {string[]} [encoderArgs=[]] FFmpeg args passed to encoder
- * @property {number} [seek] Time to seek to before playing
- * @property {boolean} [immediate=false] If it should start playing the provided track immediately
- */
 interface PlayOptions {
+    /**
+     * If this play was triggered for filters update
+     */
     filtersUpdate?: boolean;
+    /**
+     * FFmpeg args passed to encoder
+     */
     encoderArgs?: string[];
+    /**
+     * Time to seek to before playing
+     */
     seek?: number;
+    /**
+     * If it should start playing the provided track immediately
+     */
     immediate?: boolean;
 }
-type QueryExtractorSearch = `ext:${string}`;
-/**
- * @typedef {object} SearchOptions
- * @property {UserResolvable} requestedBy The user who requested this search
- * @property {typeof QueryType|string} [searchEngine='auto'] The query search engine, can be extractor name to target specific one (custom)
- * @property {string[]} [blockExtractors[]] List of the extractors to block
- * @property {boolean} [ignoreCache] If it should ignore query cache lookup
- * @property {SearchQueryType} [fallbackSearchEngine='autoSearch'] Fallback search engine to use
- * @property {any} [requestOptions] The request options
- */
+declare type QueryExtractorSearch = `ext:${string}`;
 interface SearchOptions {
+    /**
+     * The user who requested this search
+     */
     requestedBy?: UserResolvable;
+    /**
+     * The query search engine, can be extractor name to target specific one (custom)
+     */
     searchEngine?: SearchQueryType | QueryExtractorSearch;
+    /**
+     * List of the extractors to block
+     */
     blockExtractors?: string[];
+    /**
+     * If it should ignore query cache lookup
+     */
     ignoreCache?: boolean;
+    /**
+     * Fallback search engine to use
+     */
     requestOptions?: any;
+    /**
+     * Fallback search engine to use
+     */
     fallbackSearchEngine?: (typeof QueryType)[keyof typeof QueryType];
 }
 /**
@@ -2240,124 +2403,218 @@ interface SearchOptions {
  * - TRACK
  * - QUEUE
  * - AUTOPLAY
- * @typedef {number} QueueRepeatMode
  */
 declare enum QueueRepeatMode {
+    /**
+     * Disable repeat mode.
+     */
     OFF = 0,
+    /**
+     * Repeat the current track.
+     */
     TRACK = 1,
+    /**
+     * Repeat the entire queue.
+     */
     QUEUE = 2,
+    /**
+     * When last track ends, play similar tracks in the future if queue is empty.
+     */
     AUTOPLAY = 3
 }
-/**
- * @typedef {object} PlaylistInitData
- * @property {Track[]} tracks The tracks of this playlist
- * @property {string} title The playlist title
- * @property {string} description The description
- * @property {string} thumbnail The thumbnail
- * @property {album|playlist} type The playlist type: `album` | `playlist`
- * @property {TrackSource} source The playlist source
- * @property {object} author The playlist author
- * @property {string} [author.name] The author name
- * @property {string} [author.url] The author url
- * @property {string} id The playlist id
- * @property {string} url The playlist url
- * @property {any} [rawPlaylist] The raw playlist data
- */
 interface PlaylistInitData {
+    /**
+     * The tracks of this playlist
+     */
     tracks: Track[];
+    /**
+     * The playlist title
+     */
     title: string;
+    /**
+     * The description
+     */
     description: string;
+    /**
+     * The thumbnail
+     */
     thumbnail: string;
+    /**
+     * The playlist type: `album` | `playlist`
+     */
     type: 'album' | 'playlist';
+    /**
+     * The playlist source
+     */
     source: TrackSource;
+    /**
+     * The playlist author
+     */
     author: {
+        /**
+         * The author name
+         */
         name: string;
+        /**
+         * The author url
+         */
         url: string;
     };
+    /**
+     * The playlist id
+     */
     id: string;
+    /**
+     * The playlist url
+     */
     url: string;
+    /**
+     * The raw playlist data
+     */
     rawPlaylist?: any;
 }
-/**
- * @typedef {object} TrackJSON
- * @property {string} title The track title
- * @property {string} description The track description
- * @property {string} author The author
- * @property {string} url The url
- * @property {string} thumbnail The thumbnail
- * @property {string} duration The duration
- * @property {number} durationMS The duration in ms
- * @property {number} views The views count
- * @property {Snowflake} requestedBy The id of the user who requested this track
- * @property {PlaylistJSON} [playlist] The playlist info (if any)
- */
 interface TrackJSON {
-    id: Snowflake;
+    /**
+     * The track id
+     */
+    id: string;
+    /**
+     * The track title
+     */
     title: string;
+    /**
+     * The track description
+     */
     description: string;
+    /**
+     * The track author
+     */
     author: string;
+    /**
+     * The track url
+     */
     url: string;
+    /**
+     * The track thumbnail
+     */
     thumbnail: string;
+    /**
+     * The track duration
+     */
     duration: string;
+    /**
+     * The track duration in ms
+     */
     durationMS: number;
+    /**
+     * The track views
+     */
     views: number;
-    requestedBy: Snowflake;
+    /**
+     * The user id who requested this track
+     */
+    requestedBy: string;
+    /**
+     * The playlist info (if any)
+     */
     playlist?: PlaylistJSON;
 }
-/**
- * @typedef {object} PlaylistJSON
- * @property {string} id The playlist id
- * @property {string} url The playlist url
- * @property {string} title The playlist title
- * @property {string} description The playlist description
- * @property {string} thumbnail The thumbnail
- * @property {album|playlist} type The playlist type: `album` | `playlist`
- * @property {TrackSource} source The track source
- * @property {object} author The playlist author
- * @property {string} [author.name] The author name
- * @property {string} [author.url] The author url
- * @property {TrackJSON[]} tracks The tracks data (if any)
- */
 interface PlaylistJSON {
+    /**
+     * The playlist id
+     */
     id: string;
+    /**
+     * The playlist url
+     */
     url: string;
+    /**
+     * The playlist title
+     */
     title: string;
+    /**
+     * The playlist description
+     */
     description: string;
+    /**
+     * The thumbnail
+     */
     thumbnail: string;
+    /**
+     * The playlist type: `album` | `playlist`
+     */
     type: 'album' | 'playlist';
+    /**
+     * The track source
+     */
     source: TrackSource;
+    /**
+     * The playlist author
+     */
     author: {
+        /**
+         * The author name
+         */
         name: string;
+        /**
+         * The author url
+         */
         url: string;
     };
+    /**
+     * The tracks data (if any)
+     */
     tracks: TrackJSON[];
 }
-/**
- * @typedef {object} PlayerInitOptions
- * @property {YTDLDownloadOptions} [ytdlOptions] The options passed to `ytdl-core`
- * @property {number} [connectionTimeout=20000] The voice connection timeout
- * @property {boolean} [lagMonitor=30000] Time in ms to re-monitor event loop lag
- * @property {boolean} [lockVoiceStateHandler] Prevent voice state handler from being overridden
- * @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
- * @property {boolean} [useLegacyFFmpeg] Use legacy version of ffmpeg
- * @property {BridgeProvider} [bridgeProvider] Set bridge provider
- * @property {object} [ipconfig] IP rotator config
- */
 interface PlayerInitOptions {
+    /**
+     * The options passed to `ytdl-core`.
+     */
     ytdlOptions?: downloadOptions;
+    /**
+     * The voice connection timeout
+     */
     connectionTimeout?: number;
+    /**
+     * Time in ms to re-monitor event loop lag
+     */
     lagMonitor?: number;
+    /**
+     * Prevent voice state handler from being overridden
+     */
     lockVoiceStateHandler?: boolean;
+    /**
+     * List of extractors to disable querying metadata from
+     */
     blockExtractors?: string[];
+    /**
+     * List of extractors to disable streaming from
+     */
     blockStreamFrom?: string[];
+    /**
+     * Query cache provider
+     */
     queryCache?: QueryCacheProvider<any> | null;
+    /**
+     * Ignore player instance
+     */
     ignoreInstance?: boolean;
+    /**
+     * Use legacy version of ffmpeg
+     */
     useLegacyFFmpeg?: boolean;
+    /**
+     * Set bridge provider
+     */
     bridgeProvider?: BridgeProvider;
+    /**
+     * IP rotator config
+     */
     ipconfig?: IPRotationConfig;
+    /**
+     * Skip ffmpeg process when possible
+     */
+    skipFFmpeg?: boolean;
 }
 
 declare class AudioFilters {
@@ -2532,13 +2789,13 @@ declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta
  * Fetch main player instance
  * @deprecated
  */
-declare function useMasterPlayer(): Player | null;
+declare function useMasterPlayer(): Player;
 /**
  * Fetch main player instance
  */
-declare function useMainPlayer(): Player | null;
+declare function useMainPlayer(): Player;
 
-type SetterFN$1<T, P> = (previous: P) => T;
+declare type SetterFN$1<T, P> = (previous: P) => T;
 /**
  * Fetch or manipulate guild queue metadata
  * @param node Guild queue node resolvable
@@ -2576,7 +2833,7 @@ declare function onAfterCreateStream(handler: OnAfterCreateStreamHandler): void;
  */
 declare function onBeforeCreateStream(handler: OnBeforeCreateStreamHandler): void;
 
-type SetterFN = (previous: number) => number;
+declare type SetterFN = (previous: number) => number;
 /**
  * Fetch or manipulate player volume
  * @param node Guild queue node resolvable
@@ -2592,9 +2849,9 @@ interface HookDeclarationContext {
     getPlayer: typeof getPlayer;
     instances: typeof instances;
 }
-type HookDeclaration<T extends (...args: any[]) => any> = (context: HookDeclarationContext) => T;
+declare 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, AsyncQueueExceptionHandler, 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, GuildQueueStatistics, GuildQueueStatisticsMetadata, HookDeclaration, HookDeclarationContext, IPBlock, IPRotationConfig, IPRotator, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheProvider, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResolvedQuery, 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 };
+export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AsyncQueueExceptionHandler, AudioFilters, BaseExtractor, CreateStreamOps, DiscordPlayerQueryResultCache, Encodable, EqualizerConfigurationPreset, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, ExtractorStreamable, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, GuildQueueStatistics, GuildQueueStatisticsMetadata, HookDeclaration, HookDeclarationContext, IPBlock, IPRotationConfig, IPRotator, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheProvider, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResolvedQuery, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, SerializedPlaylist, SerializedTrack, SerializedType, StreamConfig, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceStateHandler, VoiceUtils, WithMetadata, createFFmpegStream, createHook, decode, deserialize, encode, onAfterCreateStream, onBeforeCreateStream, serialize, tryIntoThumbnailString, useHistory, useMainPlayer, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };