distube 4.0.0-dev.3 → 4.0.0-dev.6

package/dist/index.d.ts

@@ -1,13 +1,11 @@
 import ytdl from '@distube/ytdl-core';
 import * as discord_js from 'discord.js';
-import { GuildTextBasedChannel, Message, Snowflake, VoiceBasedChannel, VoiceState, Guild, GuildMember, Interaction, User, Client, Collection, ClientOptions } from 'discord.js';
-import ytpl from '@distube/ytpl';
+import { GuildTextBasedChannel, Message, Snowflake, VoiceBasedChannel, VoiceState, Guild, GuildMember, Interaction, Client, Collection, ClientOptions } from 'discord.js';
 import { Video, Playlist as Playlist$1 } from '@distube/ytsr';
 import { TypedEmitter } from 'tiny-typed-emitter';
+import { AudioPlayer, VoiceConnection, AudioResource, StreamType as StreamType$1 } from '@discordjs/voice';
 import { FFmpeg } from 'prism-media';
-import { StreamType, AudioPlayer, VoiceConnection, AudioResource, VoiceConnectionStatus, AudioPlayerStatus } from '@discordjs/voice';
 import * as _discordjs_collection from '@discordjs/collection';
-import { EventEmitter } from 'node:events';
 import https from 'https';
 import http from 'http';
 
@@ -58,6 +56,8 @@ interface DisTubeOptions {
     nsfw?: boolean;
     emitAddSongWhenCreatingQueue?: boolean;
     emitAddListWhenCreatingQueue?: boolean;
+    joinNewVoiceChannel?: boolean;
+    streamType?: StreamType;
 }
 declare type GuildIdResolvable = Queue | DisTubeVoice | Snowflake | Message | GuildTextBasedChannel | VoiceBasedChannel | VoiceState | Guild | GuildMember | Interaction | string;
 interface OtherSongInfo {
@@ -97,11 +97,12 @@ interface Chapter {
 interface PlaylistInfo {
     source: string;
     member?: GuildMember;
-    user?: User;
     songs: Song[];
     name?: string;
     url?: string;
     thumbnail?: string;
+    title?: string;
+    webpage_url?: string;
 }
 declare type RelatedSong = Omit<Song, "related">;
 declare type PlayHandlerOptions = {
@@ -138,6 +139,10 @@ declare enum SearchResultType {
     VIDEO = "video",
     PLAYLIST = "playlist"
 }
+declare enum StreamType {
+    OPUS = 0,
+    RAW = 1
+}
 
 declare const defaultFilters: Filters;
 declare const defaultOptions: {
@@ -155,10 +160,11 @@ declare const defaultOptions: {
     emitAddSongWhenCreatingQueue: boolean;
     emitAddListWhenCreatingQueue: boolean;
     joinNewVoiceChannel: boolean;
+    streamType: StreamType;
 };
 
 declare const ERROR_MESSAGES: {
-    INVALID_TYPE: (expected: (number | string) | readonly (number | string)[], got: any, name?: string | undefined) => string;
+    INVALID_TYPE: (expected: (number | string) | readonly (number | string)[], got: any, name?: string) => string;
     NUMBER_COMPARE: (name: string, expected: string, value: number) => string;
     EMPTY_ARRAY: (name: string) => string;
     EMPTY_FILTERED_ARRAY: (name: string, type: string) => string;
@@ -175,6 +181,7 @@ declare const ERROR_MESSAGES: {
     VOICE_MISSING_PERMS: string;
     VOICE_RECONNECT_FAILED: string;
     VOICE_DIFFERENT_GUILD: string;
+    VOICE_DIFFERENT_CLIENT: string;
     NO_QUEUE: string;
     QUEUE_EXIST: string;
     PAUSED: string;
@@ -227,7 +234,7 @@ declare class Playlist<T = unknown> implements PlaylistInfo {
     url?: string;
     thumbnail?: string;
     [x: string]: any;
-    constructor(playlist: Song[] | ytpl.result | PlaylistInfo, options?: {
+    constructor(playlist: Song[] | PlaylistInfo, options?: {
         member?: GuildMember;
         properties?: Record<string, any>;
         metadata?: T;
@@ -241,23 +248,33 @@ declare class Playlist<T = unknown> implements PlaylistInfo {
     set metadata(metadata: T);
 }
 
-declare class SearchResult {
+declare abstract class ISearchResult {
     source: "youtube";
-    type: SearchResultType;
+    abstract type: SearchResultType;
     id: string;
     name: string;
     url: string;
-    views?: number;
-    isLive?: boolean;
-    duration?: number;
-    formattedDuration?: string;
-    thumbnail?: string;
     uploader: {
         name?: string;
         url?: string;
     };
     constructor(info: Video | Playlist$1);
 }
+declare class SearchResultVideo extends ISearchResult {
+    type: SearchResultType.VIDEO;
+    views: number;
+    isLive: boolean;
+    duration: number;
+    formattedDuration: string;
+    thumbnail: string;
+    constructor(info: Video);
+}
+declare class SearchResultPlaylist extends ISearchResult {
+    type: SearchResultType.PLAYLIST;
+    length: number;
+    constructor(info: Playlist$1);
+}
+declare type SearchResult = SearchResultVideo | SearchResultPlaylist;
 
 declare class Song<T = unknown> {
     #private;
@@ -298,28 +315,6 @@ declare class Song<T = unknown> {
     set metadata(metadata: T);
 }
 
-declare class Options {
-    #private;
-    plugins: (CustomPlugin | ExtractorPlugin)[];
-    emitNewSongOnly: boolean;
-    leaveOnFinish: boolean;
-    leaveOnStop: boolean;
-    leaveOnEmpty: boolean;
-    emptyCooldown: number;
-    savePreviousSongs: boolean;
-    searchSongs: number;
-    searchCooldown: number;
-    youtubeCookie?: string;
-    youtubeIdentityToken?: string;
-    customFilters?: Filters;
-    ytdlOptions: ytdl.getInfoOptions;
-    nsfw: boolean;
-    emitAddSongWhenCreatingQueue: boolean;
-    emitAddListWhenCreatingQueue: boolean;
-    joinNewVoiceChannel: boolean;
-    constructor(options: DisTubeOptions);
-}
-
 declare abstract class DisTubeBase {
     distube: DisTube;
     constructor(distube: DisTube);
@@ -332,54 +327,6 @@ declare abstract class DisTubeBase {
     get handler(): DisTubeHandler;
 }
 
-interface StreamOptions {
-    seek?: number;
-    ffmpegArgs?: string[];
-    isLive?: boolean;
-}
-declare const chooseBestVideoFormat: (formats: ytdl.videoFormat[], isLive?: boolean) => ytdl.videoFormat;
-declare class DisTubeStream {
-    static YouTube(formats: ytdl.videoFormat[] | undefined, options?: StreamOptions): DisTubeStream;
-    static DirectLink(url: string, options?: StreamOptions): DisTubeStream;
-    type: StreamType.Raw;
-    stream: FFmpeg;
-    url: string;
-    constructor(url: string, options: StreamOptions);
-}
-
-declare abstract class BaseManager<V> extends DisTubeBase {
-    collection: Collection<string, V>;
-    get size(): number;
-}
-
-declare abstract class GuildIdManager<V> extends BaseManager<V> {
-    add(idOrInstance: GuildIdResolvable, data: V): this | _discordjs_collection.Collection<string, V>;
-    get(idOrInstance: GuildIdResolvable): V | undefined;
-    remove(idOrInstance: GuildIdResolvable): boolean;
-    has(idOrInstance: GuildIdResolvable): boolean;
-}
-
-declare class QueueManager extends GuildIdManager<Queue> {
-    #private;
-    create(channel: VoiceBasedChannel, song: Song[] | Song, textChannel?: GuildTextBasedChannel): Promise<Queue | true>;
-    createStream(queue: Queue): DisTubeStream;
-    playSong(queue: Queue): Promise<boolean>;
-}
-
-declare class FilterManager extends BaseManager<FilterResolvable> {
-    #private;
-    queue: Queue;
-    constructor(queue: Queue);
-    add(filterOrFilters: FilterResolvable | FilterResolvable[], override?: boolean): this;
-    clear(): this;
-    set(filters: FilterResolvable[]): this;
-    remove(filterOrFilters: FilterResolvable | FilterResolvable[]): this;
-    has(filter: FilterResolvable): boolean;
-    get names(): string[];
-    get values(): string[];
-    toString(): string;
-}
-
 declare class DisTubeVoice extends TypedEmitter<DisTubeVoiceEvents> {
     #private;
     readonly id: Snowflake;
@@ -408,12 +355,45 @@ declare class DisTubeVoice extends TypedEmitter<DisTubeVoiceEvents> {
     get voiceState(): VoiceState | undefined;
 }
 
+declare abstract class BaseManager<V> extends DisTubeBase {
+    collection: Collection<string, V>;
+    get size(): number;
+}
+
+declare abstract class GuildIdManager<V> extends BaseManager<V> {
+    add(idOrInstance: GuildIdResolvable, data: V): this | _discordjs_collection.Collection<string, V>;
+    get(idOrInstance: GuildIdResolvable): V | undefined;
+    remove(idOrInstance: GuildIdResolvable): boolean;
+    has(idOrInstance: GuildIdResolvable): boolean;
+}
+
 declare class DisTubeVoiceManager extends GuildIdManager<DisTubeVoice> {
     create(channel: VoiceBasedChannel): DisTubeVoice;
     join(channel: VoiceBasedChannel): Promise<DisTubeVoice>;
     leave(guild: GuildIdResolvable): void;
 }
 
+declare class FilterManager extends BaseManager<FilterResolvable> {
+    #private;
+    queue: Queue;
+    constructor(queue: Queue);
+    add(filterOrFilters: FilterResolvable | FilterResolvable[], override?: boolean): this;
+    clear(): this;
+    set(filters: FilterResolvable[]): this;
+    remove(filterOrFilters: FilterResolvable | FilterResolvable[]): this;
+    has(filter: FilterResolvable): boolean;
+    get names(): string[];
+    get values(): string[];
+    toString(): string;
+}
+
+declare class QueueManager extends GuildIdManager<Queue> {
+    #private;
+    create(channel: VoiceBasedChannel, song: Song[] | Song, textChannel?: GuildTextBasedChannel): Promise<Queue | true>;
+    createStream(queue: Queue): DisTubeStream;
+    playSong(queue: Queue): Promise<boolean>;
+}
+
 declare class DisTubeHandler extends DisTubeBase {
     constructor(distube: DisTube);
     get ytdlOptions(): ytdl.getInfoOptions;
@@ -433,6 +413,45 @@ declare class DisTubeHandler extends DisTubeBase {
     playSong(voiceChannel: VoiceBasedChannel, song: Song, options?: PlayHandlerOptions): Promise<void>;
 }
 
+declare class Options {
+    #private;
+    plugins: (CustomPlugin | ExtractorPlugin)[];
+    emitNewSongOnly: boolean;
+    leaveOnFinish: boolean;
+    leaveOnStop: boolean;
+    leaveOnEmpty: boolean;
+    emptyCooldown: number;
+    savePreviousSongs: boolean;
+    searchSongs: number;
+    searchCooldown: number;
+    youtubeCookie?: string;
+    youtubeIdentityToken?: string;
+    customFilters?: Filters;
+    ytdlOptions: ytdl.getInfoOptions;
+    nsfw: boolean;
+    emitAddSongWhenCreatingQueue: boolean;
+    emitAddListWhenCreatingQueue: boolean;
+    joinNewVoiceChannel: boolean;
+    streamType: StreamType;
+    constructor(options: DisTubeOptions);
+}
+
+interface StreamOptions {
+    seek?: number;
+    ffmpegArgs?: string[];
+    isLive?: boolean;
+    type?: StreamType;
+}
+declare const chooseBestVideoFormat: (formats: ytdl.videoFormat[], isLive?: boolean) => ytdl.videoFormat;
+declare class DisTubeStream {
+    static YouTube(formats: ytdl.videoFormat[] | undefined, options?: StreamOptions): DisTubeStream;
+    static DirectLink(url: string, options?: StreamOptions): DisTubeStream;
+    type: StreamType$1;
+    stream: FFmpeg;
+    url: string;
+    constructor(url: string, options: StreamOptions);
+}
+
 declare class Queue extends DisTubeBase {
     #private;
     readonly id: Snowflake;
@@ -449,10 +468,10 @@ declare class Queue extends DisTubeBase {
     beginTime: number;
     textChannel?: GuildTextBasedChannel;
     _emptyTimeout?: NodeJS.Timeout;
-    clientMember: GuildMember;
     _taskQueue: TaskQueue;
     _listeners?: DisTubeVoiceEvents;
     constructor(distube: DisTube, voice: DisTubeVoice, song: Song | Song[], textChannel?: GuildTextBasedChannel);
+    get clientMember(): discord_js.GuildMember | undefined;
     get filters(): FilterManager;
     get formattedDuration(): string;
     get duration(): number;
@@ -521,9 +540,8 @@ declare function isGuildInstance(guild: any): guild is Guild;
 declare function resolveGuildId(resolvable: GuildIdResolvable): Snowflake;
 declare function isClientInstance(client: any): client is Client;
 declare function checkInvalidKey(target: Record<string, any>, source: Record<string, any> | string[], sourceName: string): void;
-declare function entersState<T extends VoiceConnection | AudioPlayer>(target: T, status: T extends VoiceConnection ? VoiceConnectionStatus : AudioPlayerStatus, maxTime: number): Promise<EventEmitter | T>;
 declare function isObject(obj: any): obj is object;
-declare function isRecord(obj: any): obj is Record<string, unknown>;
+declare function isRecord<T = unknown>(obj: any): obj is Record<string, T>;
 
 declare class HTTPPlugin extends ExtractorPlugin {
     validate(url: string): Promise<boolean>;
@@ -569,11 +587,23 @@ declare class DisTube extends TypedEmitter<DisTubeEvents> {
         metadata?: any;
     }): Promise<Playlist>;
     search(string: string, options?: {
-        type?: "video" | "playlist";
+        type?: SearchResultType;
         limit?: number;
         safeSearch?: boolean;
         retried?: boolean;
     }): Promise<Array<SearchResult>>;
+    search(string: string, options?: {
+        type?: SearchResultType.VIDEO;
+        limit?: number;
+        safeSearch?: boolean;
+        retried?: boolean;
+    }): Promise<Array<SearchResultVideo>>;
+    search(string: string, options: {
+        type: SearchResultType.PLAYLIST;
+        limit?: number;
+        safeSearch?: boolean;
+        retried?: boolean;
+    }): Promise<Array<SearchResultPlaylist>>;
     getQueue(guild: GuildIdResolvable): Queue | undefined;
     pause(guild: GuildIdResolvable): Queue;
     resume(guild: GuildIdResolvable): Queue;
@@ -590,4 +620,4 @@ declare class DisTube extends TypedEmitter<DisTubeEvents> {
     emitError(error: Error, channel?: GuildTextBasedChannel): void;
 }
 
-export { Awaitable, BaseManager, Chapter, CustomPlaylistOptions, CustomPlugin, DisTube, DisTubeBase, DisTubeError, DisTubeEvents, DisTubeHandler, DisTubeOptions, DisTubeStream, DisTubeVoice, DisTubeVoiceEvents, DisTubeVoiceManager, ExtractorPlugin, Filter, FilterManager, FilterResolvable, Filters, GuildIdManager, GuildIdResolvable, HTTPPlugin, HTTPSPlugin, Options, OtherSongInfo, PlayHandlerOptions, PlayOptions, Playlist, PlaylistInfo, Plugin, PluginType, Queue, QueueManager, RelatedSong, RepeatMode, ResolveOptions, ResolvePlaylistOptions, SearchResult, SearchResultType, Song, TaskQueue, checkIntents, checkInvalidKey, chooseBestVideoFormat, DisTube as default, defaultFilters, defaultOptions, entersState, formatDuration, getResponseHeaders, isClientInstance, isGuildInstance, isMemberInstance, isMessageInstance, isObject, isRecord, isSnowflake, isSupportedVoiceChannel, isTextChannelInstance, isURL, isVoiceChannelEmpty, parseNumber, resolveGuildId, resolveHttpSong, toSecond, validateAudioURL, version };
+export { Awaitable, BaseManager, Chapter, CustomPlaylistOptions, CustomPlugin, DisTube, DisTubeBase, DisTubeError, DisTubeEvents, DisTubeHandler, DisTubeOptions, DisTubeStream, DisTubeVoice, DisTubeVoiceEvents, DisTubeVoiceManager, ExtractorPlugin, Filter, FilterManager, FilterResolvable, Filters, GuildIdManager, GuildIdResolvable, HTTPPlugin, HTTPSPlugin, Options, OtherSongInfo, PlayHandlerOptions, PlayOptions, Playlist, PlaylistInfo, Plugin, PluginType, Queue, QueueManager, RelatedSong, RepeatMode, ResolveOptions, ResolvePlaylistOptions, SearchResult, SearchResultPlaylist, SearchResultType, SearchResultVideo, Song, StreamType, TaskQueue, checkIntents, checkInvalidKey, chooseBestVideoFormat, DisTube as default, defaultFilters, defaultOptions, formatDuration, getResponseHeaders, isClientInstance, isGuildInstance, isMemberInstance, isMessageInstance, isObject, isRecord, isSnowflake, isSupportedVoiceChannel, isTextChannelInstance, isURL, isVoiceChannelEmpty, parseNumber, resolveGuildId, resolveHttpSong, toSecond, validateAudioURL, version };