import { Readable, Duplex, DuplexOptions } from 'node:stream';
import { WebmHeader } from 'play-audio';
import { EventEmitter } from 'stream';

/**
 * YouTube Live Stream class for playing audio from Live Stream videos.
 */
declare class LiveStream {
    /**
     * Readable Stream through which data passes
     */
    stream: Readable;
    /**
     * Type of audio data that we recieved from live stream youtube url.
     */
    type: StreamType;
    /**
     * Incoming message that we recieve.
     *
     * Storing this is essential.
     * This helps to destroy the TCP connection completely if you stopped player in between the stream
     */
    private request?;
    /**
     * Timer that creates loop from interval time provided.
     */
    private normal_timer?;
    /**
     * Timer used to update dash url so as to avoid 404 errors after long hours of streaming.
     *
     * It updates dash_url every 30 minutes.
     */
    private dash_timer;
    /**
     * Given Dash URL.
     */
    private dash_url;
    /**
     * Base URL in dash manifest file.
     */
    private base_url;
    /**
     * Interval to fetch data again to dash url.
     */
    private interval;
    /**
     * Timer used to update dash url so as to avoid 404 errors after long hours of streaming.
     *
     * It updates dash_url every 30 minutes.
     */
    private video_url;
    /**
     * No of segments of data to add in stream before starting to loop
     */
    private precache;
    /**
     * Segment sequence number
     */
    private sequence;
    /**
     * Live Stream Class Constructor
     * @param dash_url dash manifest URL
     * @param target_interval interval time for fetching dash data again
     * @param video_url Live Stream video url.
     */
    constructor(dash_url: string, interval: number, video_url: string, precache?: number);
    /**
     * This cleans every used variable in class.
     *
     * This is used to prevent re-use of this class and helping garbage collector to collect it.
     */
    private cleanup;
    /**
     * Updates dash url.
     *
     * Used by dash_timer for updating dash_url every 30 minutes.
     */
    private dash_updater;
    /**
     * Initializes dash after getting dash url.
     *
     * Start if it is first time of initialishing dash function.
     */
    private initialize_dash;
    /**
     * Used only after initializing dash function first time.
     * @param len Length of data that you want to
     */
    private first_data;
    /**
     * This loops function in Live Stream Class.
     *
     * Gets next segment and push it.
     */
    private loop;
    /**
     * Deprecated Functions
     */
    pause(): void;
    /**
     * Deprecated Functions
     */
    resume(): void;
}
/**
 * YouTube Stream Class for playing audio from normal videos.
 */
declare class Stream {
    /**
     * Readable Stream through which data passes
     */
    stream: Readable;
    /**
     * Type of audio data that we recieved from normal youtube url.
     */
    type: StreamType;
    /**
     * Audio Endpoint Format Url to get data from.
     */
    private url;
    /**
     * Used to calculate no of bytes data that we have recieved
     */
    private bytes_count;
    /**
     * Calculate per second bytes by using contentLength (Total bytes) / Duration (in seconds)
     */
    private per_sec_bytes;
    /**
     * Total length of audio file in bytes
     */
    private content_length;
    /**
     * YouTube video url. [ Used only for retrying purposes only. ]
     */
    private video_url;
    /**
     * Timer for looping data every 265 seconds.
     */
    private timer;
    /**
     * Quality given by user. [ Used only for retrying purposes only. ]
     */
    private quality;
    /**
     * Incoming message that we recieve.
     *
     * Storing this is essential.
     * This helps to destroy the TCP connection completely if you stopped player in between the stream
     */
    private request;
    /**
     * YouTube Stream Class constructor
     * @param url Audio Endpoint url.
     * @param type Type of Stream
     * @param duration Duration of audio playback [ in seconds ]
     * @param contentLength Total length of Audio file in bytes.
     * @param video_url YouTube video url.
     * @param options Options provided to stream function.
     */
    constructor(url: string, type: StreamType, duration: number, contentLength: number, video_url: string, options: StreamOptions);
    /**
     * Retry if we get 404 or 403 Errors.
     */
    private retry;
    /**
     * This cleans every used variable in class.
     *
     * This is used to prevent re-use of this class and helping garbage collector to collect it.
     */
    private cleanup;
    /**
     * Getting data from audio endpoint url and passing it to stream.
     *
     * If 404 or 403 occurs, it will retry again.
     */
    private loop;
    /**
     * Pauses timer.
     * Stops running of loop.
     *
     * Useful if you don't want to get excess data to be stored in stream.
     */
    pause(): void;
    /**
     * Resumes timer.
     * Starts running of loop.
     */
    resume(): void;
}

declare enum WebmSeekerState {
    READING_HEAD = "READING_HEAD",
    READING_DATA = "READING_DATA"
}
interface WebmSeekerOptions extends DuplexOptions {
    mode?: 'precise' | 'granular';
}
declare class WebmSeeker extends Duplex {
    remaining?: Buffer;
    state: WebmSeekerState;
    chunk?: Buffer;
    cursor: number;
    header: WebmHeader;
    headfound: boolean;
    headerparsed: boolean;
    seekfound: boolean;
    private data_size;
    private offset;
    private data_length;
    private sec;
    private time;
    constructor(sec: number, options: WebmSeekerOptions);
    private get vint_length();
    private vint_value;
    cleanup(): void;
    _read(): void;
    seek(content_length: number): Error | number;
    _write(chunk: Buffer, _: BufferEncoding, callback: (error?: Error | null) => void): void;
    private readHead;
    private readTag;
    private getClosestBlock;
    private parseEbmlID;
    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
    _final(callback: (error?: Error | null) => void): void;
}

/**
 * YouTube Stream Class for seeking audio to a timeStamp.
 */
declare class SeekStream {
    /**
     * WebmSeeker Stream through which data passes
     */
    stream: WebmSeeker;
    /**
     * Type of audio data that we recieved from normal youtube url.
     */
    type: StreamType;
    /**
     * Audio Endpoint Format Url to get data from.
     */
    private url;
    /**
     * Used to calculate no of bytes data that we have recieved
     */
    private bytes_count;
    /**
     * Calculate per second bytes by using contentLength (Total bytes) / Duration (in seconds)
     */
    private per_sec_bytes;
    /**
     * Length of the header in bytes
     */
    private header_length;
    /**
     * Total length of audio file in bytes
     */
    private content_length;
    /**
     * YouTube video url. [ Used only for retrying purposes only. ]
     */
    private video_url;
    /**
     * Timer for looping data every 265 seconds.
     */
    private timer;
    /**
     * Quality given by user. [ Used only for retrying purposes only. ]
     */
    private quality;
    /**
     * Incoming message that we recieve.
     *
     * Storing this is essential.
     * This helps to destroy the TCP connection completely if you stopped player in between the stream
     */
    private request;
    /**
     * YouTube Stream Class constructor
     * @param url Audio Endpoint url.
     * @param type Type of Stream
     * @param duration Duration of audio playback [ in seconds ]
     * @param headerLength Length of the header in bytes.
     * @param contentLength Total length of Audio file in bytes.
     * @param bitrate Bitrate provided by YouTube.
     * @param video_url YouTube video url.
     * @param options Options provided to stream function.
     */
    constructor(url: string, duration: number, headerLength: number, contentLength: number, bitrate: number, video_url: string, options: StreamOptions);
    /**
     * **INTERNAL Function**
     *
     * Uses stream functions to parse Webm Head and gets Offset byte to seek to.
     * @returns Nothing
     */
    private seek;
    /**
     * Retry if we get 404 or 403 Errors.
     */
    private retry;
    /**
     * This cleans every used variable in class.
     *
     * This is used to prevent re-use of this class and helping garbage collector to collect it.
     */
    private cleanup;
    /**
     * Getting data from audio endpoint url and passing it to stream.
     *
     * If 404 or 403 occurs, it will retry again.
     */
    private loop;
    /**
     * Pauses timer.
     * Stops running of loop.
     *
     * Useful if you don't want to get excess data to be stored in stream.
     */
    pause(): void;
    /**
     * Resumes timer.
     * Starts running of loop.
     */
    resume(): void;
}

interface ChannelIconInterface {
    /**
     * YouTube Channel Icon URL
     */
    url: string;
    /**
     * YouTube Channel Icon Width
     */
    width: number;
    /**
     * YouTube Channel Icon Height
     */
    height: number;
}
/**
 * YouTube Channel Class
 */
declare class YouTubeChannel {
    /**
     * YouTube Channel Title
     */
    name?: string;
    /**
     * YouTube Channel Verified status.
     */
    verified?: boolean;
    /**
     * YouTube Channel artist if any.
     */
    artist?: boolean;
    /**
     * YouTube Channel ID.
     */
    id?: string;
    /**
     * YouTube Class type. == "channel"
     */
    type: 'video' | 'playlist' | 'channel';
    /**
     * YouTube Channel Url
     */
    url?: string;
    /**
     * YouTube Channel Icons data.
     */
    icons?: ChannelIconInterface[];
    /**
     * YouTube Channel subscribers count.
     */
    subscribers?: string;
    /**
     * YouTube Channel Constructor
     * @param data YouTube Channel data that we recieve from basic info or from search
     */
    constructor(data?: any);
    /**
     * Returns channel icon url
     * @param {object} options Icon options
     * @param {number} [options.size=0] Icon size. **Default is 0**
     */
    iconURL(options?: {
        size: number;
    }): string | undefined;
    /**
     * Converts Channel Class to channel name.
     * @returns name of channel
     */
    toString(): string;
    /**
     * Converts Channel Class to JSON format
     * @returns json data of the channel
     */
    toJSON(): ChannelJSON;
}
interface ChannelJSON {
    /**
     * YouTube Channel Title
     */
    name?: string;
    /**
     * YouTube Channel Verified status.
     */
    verified?: boolean;
    /**
     * YouTube Channel artist if any.
     */
    artist?: boolean;
    /**
     * YouTube Channel ID.
     */
    id?: string;
    /**
     * Type of Class [ Channel ]
     */
    type: 'video' | 'playlist' | 'channel';
    /**
     * YouTube Channel Url
     */
    url?: string;
    /**
     * YouTube Channel Icon data.
     */
    icons?: ChannelIconInterface[];
    /**
     * YouTube Channel subscribers count.
     */
    subscribers?: string;
}

declare class YouTubeThumbnail {
    url: string;
    width: number;
    height: number;
    constructor(data: any);
    toJSON(): {
        url: string;
        width: number;
        height: number;
    };
}

/**
 * Licensed music in the video
 *
 * The property names change depending on your region's language.
 */
interface VideoMusic {
    song?: string;
    url?: string | null;
    artist?: string;
    album?: string;
    writers?: string;
    licenses?: string;
}
interface VideoOptions {
    /**
     * YouTube Video ID
     */
    id?: string;
    /**
     * YouTube video url
     */
    url: string;
    /**
     * YouTube Video title
     */
    title?: string;
    /**
     * YouTube Video description.
     */
    description?: string;
    /**
     * YouTube Video Duration Formatted
     */
    durationRaw: string;
    /**
     * YouTube Video Duration in seconds
     */
    durationInSec: number;
    /**
     * YouTube Video Uploaded Date
     */
    uploadedAt?: string;
    /**
     * If the video is upcoming or a premiere that isn't currently live, this will contain the premiere date, for watch page playlists this will be true, it defaults to undefined
     */
    upcoming?: Date | true;
    /**
     * YouTube Views
     */
    views: number;
    /**
     * YouTube Thumbnail Data
     */
    thumbnail?: {
        width: number | undefined;
        height: number | undefined;
        url: string | undefined;
    };
    /**
     * YouTube Video's uploader Channel Data
     */
    channel?: YouTubeChannel;
    /**
     * YouTube Video's likes
     */
    likes: number;
    /**
     * YouTube Video live status
     */
    live: boolean;
    /**
     * YouTube Video private status
     */
    private: boolean;
    /**
     * YouTube Video tags
     */
    tags: string[];
    /**
     * `true` if the video has been identified by the YouTube community as inappropriate or offensive to some audiences and viewer discretion is advised
     */
    discretionAdvised?: boolean;
    /**
     * Gives info about music content in that video.
     *
     * The property names of VideoMusic change depending on your region's language.
     */
    music?: VideoMusic[];
    /**
     * The chapters for this video
     *
     * If the video doesn't have any chapters or if the video object wasn't created by {@link video_basic_info} or {@link video_info} this will be an empty array.
     */
    chapters: VideoChapter[];
}
interface VideoChapter {
    /**
     * The title of the chapter
     */
    title: string;
    /**
     * The timestamp of the start of the chapter
     */
    timestamp: string;
    /**
     * The start of the chapter in seconds
     */
    seconds: number;
    /**
     * Thumbnails of the frame at the start of this chapter
     */
    thumbnails: YouTubeThumbnail[];
}
/**
 * Class for YouTube Video url
 */
declare class YouTubeVideo {
    /**
     * YouTube Video ID
     */
    id?: string;
    /**
     * YouTube video url
     */
    url: string;
    /**
     * YouTube Class type. == "video"
     */
    type: 'video' | 'playlist' | 'channel';
    /**
     * YouTube Video title
     */
    title?: string;
    /**
     * YouTube Video description.
     */
    description?: string;
    /**
     * YouTube Video Duration Formatted
     */
    durationRaw: string;
    /**
     * YouTube Video Duration in seconds
     */
    durationInSec: number;
    /**
     * YouTube Video Uploaded Date
     */
    uploadedAt?: string;
    /**
     * YouTube Live Date
     */
    liveAt?: string;
    /**
     * If the video is upcoming or a premiere that isn't currently live, this will contain the premiere date, for watch page playlists this will be true, it defaults to undefined
     */
    upcoming?: Date | true;
    /**
     * YouTube Views
     */
    views: number;
    /**
     * YouTube Thumbnail Data
     */
    thumbnails: YouTubeThumbnail[];
    /**
     * YouTube Video's uploader Channel Data
     */
    channel?: YouTubeChannel;
    /**
     * YouTube Video's likes
     */
    likes: number;
    /**
     * YouTube Video live status
     */
    live: boolean;
    /**
     * YouTube Video private status
     */
    private: boolean;
    /**
     * YouTube Video tags
     */
    tags: string[];
    /**
     * `true` if the video has been identified by the YouTube community as inappropriate or offensive to some audiences and viewer discretion is advised
     */
    discretionAdvised?: boolean;
    /**
     * Gives info about music content in that video.
     */
    music?: VideoMusic[];
    /**
     * The chapters for this video
     *
     * If the video doesn't have any chapters or if the video object wasn't created by {@link video_basic_info} or {@link video_info} this will be an empty array.
     */
    chapters: VideoChapter[];
    /**
     * Constructor for YouTube Video Class
     * @param data JSON parsed data.
     */
    constructor(data: any);
    /**
     * Converts class to title name of video.
     * @returns Title name
     */
    toString(): string;
    /**
     * Converts class to JSON data
     * @returns JSON data.
     */
    toJSON(): VideoOptions;
}

interface LiveStreamData {
    isLive: boolean;
    dashManifestUrl: string | null;
    hlsManifestUrl: string | null;
}
interface formatData {
    itag: number;
    mimeType: string;
    bitrate: number;
    width: number;
    height: number;
    lastModified: string;
    contentLength: string;
    quality: string;
    fps: number;
    qualityLabel: string;
    projectionType: string;
    averageBitrate: number;
    audioQuality: string;
    approxDurationMs: string;
    audioSampleRate: string;
    audioChannels: number;
    url: string;
    signatureCipher: string;
    cipher: string;
    loudnessDb: number;
    targetDurationSec: number;
}
interface InfoData {
    LiveStreamData: LiveStreamData;
    html5player: string;
    format: Partial<formatData>[];
    video_details: YouTubeVideo;
    related_videos: string[];
}
interface StreamInfoData {
    LiveStreamData: LiveStreamData;
    html5player: string;
    format: Partial<formatData>[];
    video_details: Pick<YouTubeVideo, 'url' | 'durationInSec'>;
}

declare enum StreamType {
    Arbitrary = "arbitrary",
    Raw = "raw",
    OggOpus = "ogg/opus",
    WebmOpus = "webm/opus",
    Opus = "opus"
}
interface StreamOptions {
    seek?: number;
    quality?: number;
    language?: string;
    htmldata?: boolean;
    precache?: number;
    discordPlayerCompatibility?: boolean;
}
/**
 * Type for YouTube Stream
 */
type YouTubeStream = Stream | LiveStream | SeekStream;

/**
 * YouTube Playlist Class containing vital informations about playlist.
 */
declare class YouTubePlayList {
    /**
     * YouTube Playlist ID
     */
    id?: string;
    /**
     * YouTube Playlist Name
     */
    title?: string;
    /**
     * YouTube Class type. == "playlist"
     */
    type: 'video' | 'playlist' | 'channel';
    /**
     * Total no of videos in that playlist
     */
    videoCount?: number;
    /**
     * Time when playlist was last updated
     */
    lastUpdate?: string;
    /**
     * Total views of that playlist
     */
    views?: number;
    /**
     * YouTube Playlist url
     */
    url?: string;
    /**
     * YouTube Playlist url with starting video url.
     */
    link?: string;
    /**
     * YouTube Playlist channel data
     */
    channel?: YouTubeChannel;
    /**
     * YouTube Playlist thumbnail Data
     */
    thumbnail?: YouTubeThumbnail;
    /**
     * Videos array containing data of first 100 videos
     */
    private videos?;
    /**
     * Map contaning data of all fetched videos
     */
    private fetched_videos;
    /**
     * Token containing API key, Token, ClientVersion.
     */
    private _continuation;
    /**
     * Total no of pages count.
     */
    private __count;
    /**
     * Constructor for YouTube Playlist Class
     * @param data Json Parsed YouTube Playlist data
     * @param searchResult If the data is from search or not
     */
    constructor(data: any, searchResult?: boolean);
    /**
     * Updates variable according to a normal data.
     * @param data Json Parsed YouTube Playlist data
     */
    private __patch;
    /**
     * Updates variable according to a searched data.
     * @param data Json Parsed YouTube Playlist data
     */
    private __patchSearch;
    /**
     * Parses next segment of videos from playlist and returns parsed data.
     * @param limit Total no of videos to parse.
     *
     * Default = Infinity
     * @returns Array of YouTube Video Class
     */
    next(limit?: number): Promise<YouTubeVideo[]>;
    /**
     * Fetches remaining data from playlist
     *
     * For fetching and getting all songs data, see `total_pages` property.
     * @param max Max no of videos to fetch
     *
     * Default = Infinity
     * @returns
     */
    fetch(max?: number): Promise<YouTubePlayList>;
    /**
     * YouTube Playlists are divided into pages.
     *
     * For example, if you want to get 101 - 200 songs
     *
     * ```ts
     * const playlist = await play.playlist_info('playlist url')
     *
     * await playlist.fetch()
     *
     * const result = playlist.page(2)
     * ```
     * @param number Page number
     * @returns Array of YouTube Video Class
     * @see {@link YouTubePlayList.all_videos}
     */
    page(number: number): YouTubeVideo[];
    /**
     * Gets total number of pages in that playlist class.
     * @see {@link YouTubePlayList.all_videos}
     */
    get total_pages(): number;
    /**
     * This tells total number of videos that have been fetched so far.
     *
     * This can be equal to videosCount if all videos in playlist have been fetched and they are not hidden.
     */
    get total_videos(): number;
    /**
     * Fetches all the videos in the playlist and returns them
     *
     * ```ts
     * const playlist = await play.playlist_info('playlist url')
     *
     * const videos = await playlist.all_videos()
     * ```
     * @returns An array of {@link YouTubeVideo} objects
     * @see {@link YouTubePlayList.fetch}
     */
    all_videos(): Promise<YouTubeVideo[]>;
    /**
     * Converts Playlist Class to a json parsed data.
     * @returns
     */
    toJSON(): PlaylistJSON$2;
}
interface PlaylistJSON$2 {
    /**
     * YouTube Playlist ID
     */
    id?: string;
    /**
     * YouTube Playlist Name
     */
    title?: string;
    /**
     * Total no of videos in that playlist
     */
    videoCount?: number;
    /**
     * Time when playlist was last updated
     */
    lastUpdate?: string;
    /**
     * Total views of that playlist
     */
    views?: number;
    /**
     * YouTube Playlist url
     */
    url?: string;
    /**
     * YouTube Playlist url with starting video url.
     */
    link?: string;
    /**
     * YouTube Playlist channel data
     */
    channel?: YouTubeChannel;
    /**
     * YouTube Playlist thumbnail Data
     */
    thumbnail?: {
        width: number | undefined;
        height: number | undefined;
        url: string | undefined;
    };
    /**
     * first 100 videos in that playlist
     */
    videos?: YouTubeVideo[];
}

interface InfoOptions {
    htmldata?: boolean;
    language?: string;
}
interface PlaylistOptions {
    incomplete?: boolean;
    language?: string;
}
/**
 * Validate YouTube URL or ID.
 *
 * **CAUTION :** If your search word is 11 or 12 characters long, you might get it validated as video ID.
 *
 * To avoid above, add one more condition to yt_validate
 * ```ts
 * if (url.startsWith('https') && yt_validate(url) === 'video') {
 *      // YouTube Video Url.
 * }
 * ```
 * @param url YouTube URL OR ID
 * @returns
 * ```
 * 'playlist' | 'video' | 'search' | false
 * ```
 */
declare function yt_validate(url: string): 'playlist' | 'video' | 'search' | false;
/**
 * Extract ID of YouTube url.
 * @param url ID or url of YouTube
 * @returns ID of video or playlist.
 */
declare function extractID(url: string): string;
/**
 * Basic function to get data from a YouTube url or ID.
 *
 * Example
 * ```ts
 * const video = await play.video_basic_info('youtube video url')
 *
 * const res = ... // Any https package get function.
 *
 * const video = await play.video_basic_info(res.body, { htmldata : true })
 * ```
 * @param url YouTube url or ID or html body data
 * @param options Video Info Options
 *  - `boolean` htmldata : given data is html data or not
 * @returns Video Basic Info {@link InfoData}.
 */
declare function video_basic_info(url: string, options?: InfoOptions): Promise<InfoData>;
/**
 * Gets data from YouTube url or ID or html body data and deciphers it.
 * ```
 * video_basic_info + decipher_info = video_info
 * ```
 *
 * Example
 * ```ts
 * const video = await play.video_info('youtube video url')
 *
 * const res = ... // Any https package get function.
 *
 * const video = await play.video_info(res.body, { htmldata : true })
 * ```
 * @param url YouTube url or ID or html body data
 * @param options Video Info Options
 *  - `boolean` htmldata : given data is html data or not
 * @returns Deciphered Video Info {@link InfoData}.
 */
declare function video_info(url: string, options?: InfoOptions): Promise<InfoData>;
/**
 * Function uses data from video_basic_info and deciphers it if it contains signatures.
 * @param data Data - {@link InfoData}
 * @param audio_only `boolean` - To decipher only audio formats only.
 * @returns Deciphered Video Info {@link InfoData}
 */
declare function decipher_info<T extends InfoData | StreamInfoData>(data: T, audio_only?: boolean): Promise<T>;
/**
 * Gets YouTube playlist info from a playlist url.
 *
 * Example
 * ```ts
 * const playlist = await play.playlist_info('youtube playlist url')
 *
 * const playlist = await play.playlist_info('youtube playlist url', { incomplete : true })
 * ```
 * @param url Playlist URL
 * @param options Playlist Info Options
 * - `boolean` incomplete : When this is set to `false` (default) this function will throw an error
 *                          if the playlist contains hidden videos.
 *                          If it is set to `true`, it parses the playlist skipping the hidden videos,
 *                          only visible videos are included in the resulting {@link YouTubePlaylist}.
 *
 * @returns YouTube Playlist
 */
declare function playlist_info(url: string, options?: PlaylistOptions): Promise<YouTubePlayList>;

/**
 * Type for YouTube returns
 */
type YouTube = YouTubeVideo | YouTubeChannel | YouTubePlayList;

interface TrackJSON {
    /**
     * Spotify Track Name
     */
    name: string;
    /**
     * Spotify Track ID
     */
    id: string;
    /**
     * Spotify Track url
     */
    url: string;
    /**
     * Spotify Track explicit info.
     */
    explicit: boolean;
    /**
     * Spotify Track Duration in seconds
     */
    durationInSec: number;
    /**
     * Spotify Track Duration in milli seconds
     */
    durationInMs: number;
    /**
     * Spotify Track Artists data [ array ]
     */
    artists: SpotifyArtists[];
    /**
     * Spotify Track Album data
     */
    album: SpotifyTrackAlbum | undefined;
    /**
     * Spotify Track Thumbnail Data
     */
    thumbnail: SpotifyThumbnail | undefined;
}
interface PlaylistJSON$1 {
    /**
     * Spotify Playlist Name
     */
    name: string;
    /**
     * Spotify Playlist collaborative boolean.
     */
    collaborative: boolean;
    /**
     * Spotify Playlist Description
     */
    description: string;
    /**
     * Spotify Playlist URL
     */
    url: string;
    /**
     * Spotify Playlist ID
     */
    id: string;
    /**
     * Spotify Playlist Thumbnail Data
     */
    thumbnail: SpotifyThumbnail;
    /**
     * Spotify Playlist Owner Artist data
     */
    owner: SpotifyArtists;
    /**
     * Spotify Playlist total tracks Count
     */
    tracksCount: number;
}
interface AlbumJSON {
    /**
     * Spotify Album Name
     */
    name: string;
    /**
     * Spotify Class type. == "album"
     */
    type: 'track' | 'playlist' | 'album';
    /**
     * Spotify Album url
     */
    url: string;
    /**
     * Spotify Album id
     */
    id: string;
    /**
     * Spotify Album Thumbnail data
     */
    thumbnail: SpotifyThumbnail;
    /**
     * Spotify Album artists [ array ]
     */
    artists: SpotifyArtists[];
    /**
     * Spotify Album copyright data [ array ]
     */
    copyrights: SpotifyCopyright[];
    /**
     * Spotify Album Release date
     */
    release_date: string;
    /**
     * Spotify Album Release Date **precise**
     */
    release_date_precision: string;
    /**
     * Spotify Album total no of tracks
     */
    tracksCount: number;
}

interface SpotifyTrackAlbum {
    /**
     * Spotify Track Album name
     */
    name: string;
    /**
     * Spotify Track Album url
     */
    url: string;
    /**
     * Spotify Track Album id
     */
    id: string;
    /**
     * Spotify Track Album release date
     */
    release_date: string;
    /**
     * Spotify Track Album release date **precise**
     */
    release_date_precision: string;
    /**
     * Spotify Track Album total tracks number
     */
    total_tracks: number;
}
interface SpotifyArtists {
    /**
     * Spotify Artist Name
     */
    name: string;
    /**
     * Spotify Artist Url
     */
    url: string;
    /**
     * Spotify Artist ID
     */
    id: string;
}
interface SpotifyThumbnail {
    /**
     * Spotify Thumbnail height
     */
    height: number;
    /**
     * Spotify Thumbnail width
     */
    width: number;
    /**
     * Spotify Thumbnail url
     */
    url: string;
}
interface SpotifyCopyright {
    /**
     * Spotify Copyright Text
     */
    text: string;
    /**
     * Spotify Copyright Type
     */
    type: string;
}
/**
 * Spotify Track Class
 */
declare class SpotifyTrack {
    /**
     * Spotify Track Name
     */
    name: string;
    /**
     * Spotify Class type. == "track"
     */
    type: 'track' | 'playlist' | 'album';
    /**
     * Spotify Track ID
     */
    id: string;
    /**
     * Spotify Track ISRC
     */
    isrc: string;
    /**
     * Spotify Track url
     */
    url: string;
    /**
     * Spotify Track explicit info.
     */
    explicit: boolean;
    /**
     * Spotify Track playability info.
     */
    playable: boolean;
    /**
     * Spotify Track Duration in seconds
     */
    durationInSec: number;
    /**
     * Spotify Track Duration in milli seconds
     */
    durationInMs: number;
    /**
     * Spotify Track Artists data [ array ]
     */
    artists: SpotifyArtists[];
    /**
     * Spotify Track Album data
     */
    album: SpotifyTrackAlbum | undefined;
    /**
     * Spotify Track Thumbnail Data
     */
    thumbnail: SpotifyThumbnail | undefined;
    /**
     * Constructor for Spotify Track
     * @param data
     */
    constructor(data: any);
    toJSON(): TrackJSON;
}
/**
 * Spotify Playlist Class
 */
declare class SpotifyPlaylist {
    /**
     * Spotify Playlist Name
     */
    name: string;
    /**
     * Spotify Class type. == "playlist"
     */
    type: 'track' | 'playlist' | 'album';
    /**
     * Spotify Playlist collaborative boolean.
     */
    collaborative: boolean;
    /**
     * Spotify Playlist Description
     */
    description: string;
    /**
     * Spotify Playlist URL
     */
    url: string;
    /**
     * Spotify Playlist ID
     */
    id: string;
    /**
     * Spotify Playlist Thumbnail Data
     */
    thumbnail: SpotifyThumbnail;
    /**
     * Spotify Playlist Owner Artist data
     */
    owner: SpotifyArtists;
    /**
     * Spotify Playlist total tracks Count
     */
    tracksCount: number;
    /**
     * Spotify Playlist Spotify data
     *
     * @private
     */
    private spotifyData;
    /**
     * Spotify Playlist fetched tracks Map
     *
     * @private
     */
    private fetched_tracks;
    /**
     * Boolean to tell whether it is a searched result or not.
     */
    private readonly search;
    /**
     * Constructor for Spotify Playlist Class
     * @param data JSON parsed data of playlist
     * @param spotifyData Data about sporify token for furhter fetching.
     */
    constructor(data: any, spotifyData: SpotifyDataOptions, search: boolean);
    /**
     * Fetches Spotify Playlist tracks more than 100 tracks.
     *
     * For getting all tracks in playlist, see `total_pages` property.
     * @returns Playlist Class.
     */
    fetch(): Promise<this>;
    /**
     * Spotify Playlist tracks are divided in pages.
     *
     * For example getting data of 101 - 200 videos in a playlist,
     *
     * ```ts
     * const playlist = await play.spotify('playlist url')
     *
     * await playlist.fetch()
     *
     * const result = playlist.page(2)
     * ```
     * @param num Page Number
     * @returns
     */
    page(num: number): SpotifyTrack[];
    /**
     * Gets total number of pages in that playlist class.
     * @see {@link SpotifyPlaylist.all_tracks}
     */
    get total_pages(): number;
    /**
     * Spotify Playlist total no of tracks that have been fetched so far.
     */
    get total_tracks(): number;
    /**
     * Fetches all the tracks in the playlist and returns them
     *
     * ```ts
     * const playlist = await play.spotify('playlist url')
     *
     * const tracks = await playlist.all_tracks()
     * ```
     * @returns An array of {@link SpotifyTrack}
     */
    all_tracks(): Promise<SpotifyTrack[]>;
    /**
     * Converts Class to JSON
     * @returns JSON data
     */
    toJSON(): PlaylistJSON$1;
}
/**
 * Spotify Album Class
 */
declare class SpotifyAlbum {
    /**
     * Spotify Album Name
     */
    name: string;
    /**
     * Spotify Class type. == "album"
     */
    type: 'track' | 'playlist' | 'album';
    /**
     * Spotify Album url
     */
    url: string;
    /**
     * Spotify Album id
     */
    id: string;
    /**
     * Spotify Album Thumbnail data
     */
    thumbnail: SpotifyThumbnail;
    /**
     * Spotify Album artists [ array ]
     */
    artists: SpotifyArtists[];
    /**
     * Spotify Album copyright data [ array ]
     */
    copyrights: SpotifyCopyright[];
    /**
     * Spotify Album Release date
     */
    release_date: string;
    /**
     * Spotify Album Release Date **precise**
     */
    release_date_precision: string;
    /**
     * Spotify Album total no of tracks
     */
    tracksCount: number;
    /**
     * Spotify Album Spotify data
     *
     * @private
     */
    private spotifyData;
    /**
     * Spotify Album fetched tracks Map
     *
     * @private
     */
    private fetched_tracks;
    /**
     * Boolean to tell whether it is a searched result or not.
     */
    private readonly search;
    /**
     * Constructor for Spotify Album Class
     * @param data Json parsed album data
     * @param spotifyData Spotify credentials
     */
    constructor(data: any, spotifyData: SpotifyDataOptions, search: boolean);
    /**
     * Fetches Spotify Album tracks more than 50 tracks.
     *
     * For getting all tracks in album, see `total_pages` property.
     * @returns Album Class.
     */
    fetch(): Promise<this>;
    /**
     * Spotify Album tracks are divided in pages.
     *
     * For example getting data of 51 - 100 videos in a album,
     *
     * ```ts
     * const album = await play.spotify('album url')
     *
     * await album.fetch()
     *
     * const result = album.page(2)
     * ```
     * @param num Page Number
     * @returns
     */
    page(num: number): SpotifyTrack[] | undefined;
    /**
     * Gets total number of pages in that album class.
     * @see {@link SpotifyAlbum.all_tracks}
     */
    get total_pages(): number;
    /**
     * Spotify Album total no of tracks that have been fetched so far.
     */
    get total_tracks(): number;
    /**
     * Fetches all the tracks in the album and returns them
     *
     * ```ts
     * const album = await play.spotify('album url')
     *
     * const tracks = await album.all_tracks()
     * ```
     * @returns An array of {@link SpotifyTrack}
     */
    all_tracks(): Promise<SpotifyTrack[]>;
    /**
     * Converts Class to JSON
     * @returns JSON data
     */
    toJSON(): AlbumJSON;
}

/**
 * Spotify Data options that are stored in spotify.data file.
 */
interface SpotifyDataOptions {
    client_id: string;
    client_secret: string;
    redirect_url?: string;
    authorization_code?: string;
    access_token?: string;
    refresh_token?: string;
    token_type?: string;
    expires_in?: number;
    expiry?: number;
    market?: string;
    file?: boolean;
}
/**
 * Gets Spotify url details.
 *
 * ```ts
 * let spot = await play.spotify('spotify url')
 *
 * // spot.type === "track" | "playlist" | "album"
 *
 * if (spot.type === "track") {
 *      spot = spot as play.SpotifyTrack
 *      // Code with spotify track class.
 * }
 * ```
 * @param url Spotify Url
 * @returns A {@link SpotifyTrack} or {@link SpotifyPlaylist} or {@link SpotifyAlbum}
 */
declare function spotify(url: string): Promise<Spotify>;
/**
 * Validate Spotify url
 * @param url Spotify URL
 * @returns
 * ```ts
 * 'track' | 'playlist' | 'album' | 'search' | false
 * ```
 */
declare function sp_validate(url: string): 'track' | 'playlist' | 'album' | 'search' | false;
/**
 * Checks if spotify token is expired or not.
 *
 * Update token if returned false.
 * ```ts
 * if (play.is_expired()) {
 *      await play.refreshToken()
 * }
 * ```
 * @returns boolean
 */
declare function is_expired(): boolean;
/**
 * type for Spotify Classes
 */
type Spotify = SpotifyAlbum | SpotifyPlaylist | SpotifyTrack;
/**
 * Refreshes Token
 *
 * ```ts
 * if (play.is_expired()) {
 *      await play.refreshToken()
 * }
 * ```
 * @returns boolean
 */
declare function refreshToken(): Promise<boolean>;

interface SoundTrackJSON {
    /**
     * SoundCloud Track Name
     */
    name: string;
    /**
     * SoundCloud Track ID
     */
    id: number;
    /**
     * SoundCloud Track url
     */
    url: string;
    /**
     * User friendly SoundCloud track URL
     */
    permalink: string;
    /**
     * SoundCloud Track fetched status
     */
    fetched: boolean;
    /**
     * SoundCloud Track Duration in seconds
     */
    durationInSec: number;
    /**
     * SoundCloud Track Duration in miili seconds
     */
    durationInMs: number;
    /**
     * SoundCloud Track formats data
     */
    formats: SoundCloudTrackFormat[];
    /**
     * SoundCloud Track Publisher Data
     */
    publisher: {
        name: string;
        id: number;
        artist: string;
        contains_music: boolean;
        writer_composer: string;
    } | null;
    /**
     * SoundCloud Track thumbnail
     */
    thumbnail: string;
    /**
     * SoundCloud Track user data
     */
    user: SoundCloudUser;
}
interface PlaylistJSON {
    /**
     * SoundCloud Playlist Name
     */
    name: string;
    /**
     * SoundCloud Playlist ID
     */
    id: number;
    /**
     * SoundCloud Playlist URL
     */
    url: string;
    /**
     * SoundCloud Playlist Sub type. == "album" for soundcloud albums
     */
    sub_type: string;
    /**
     * SoundCloud Playlist Total Duration in seconds
     */
    durationInSec: number;
    /**
     * SoundCloud Playlist Total Duration in milli seconds
     */
    durationInMs: number;
    /**
     * SoundCloud Playlist user data
     */
    user: SoundCloudUser;
    /**
     * SoundCloud Playlist tracks [ It can be fetched or not fetched ]
     */
    tracks: SoundCloudTrack[] | SoundCloudTrackDeprecated[];
    /**
     * SoundCloud Playlist tracks number
     */
    tracksCount: number;
}

interface SoundCloudUser {
    /**
     * SoundCloud User Name
     */
    name: string;
    /**
     * SoundCloud User ID
     */
    id: string;
    /**
     * SoundCloud User URL
     */
    url: string;
    /**
     * SoundCloud Class type. == "user"
     */
    type: 'track' | 'playlist' | 'user';
    /**
     * SoundCloud User Verified status
     */
    verified: boolean;
    /**
     * SoundCloud User Description
     */
    description: string;
    /**
     * SoundCloud User First Name
     */
    first_name: string;
    /**
     * SoundCloud User Full Name
     */
    full_name: string;
    /**
     * SoundCloud User Last Name
     */
    last_name: string;
    /**
     * SoundCloud User thumbnail URL
     */
    thumbnail: string;
}
interface SoundCloudTrackDeprecated {
    /**
     * SoundCloud Track fetched status
     */
    fetched: boolean;
    /**
     * SoundCloud Track ID
     */
    id: number;
    /**
     * SoundCloud Class type. == "track"
     */
    type: 'track';
}
interface SoundCloudTrackFormat {
    /**
     * SoundCloud Track Format Url
     */
    url: string;
    /**
     * SoundCloud Track Format preset
     */
    preset: string;
    /**
     * SoundCloud Track Format Duration
     */
    duration: number;
    /**
     * SoundCloud Track Format data containing protocol and mime_type
     */
    format: {
        protocol: string;
        mime_type: string;
    };
    /**
     * SoundCloud Track Format quality
     */
    quality: string;
}
/**
 * SoundCloud Track Class
 */
declare class SoundCloudTrack {
    /**
     * SoundCloud Track Name
     */
    name: string;
    /**
     * SoundCloud Track ID
     */
    id: number;
    /**
     * SoundCloud Track url
     */
    url: string;
    /**
     * User friendly SoundCloud track URL
     */
    permalink: string;
    /**
     * SoundCloud Track fetched status
     */
    fetched: boolean;
    /**
     * SoundCloud Class type. === "track"
     */
    type: 'track' | 'playlist' | 'user';
    /**
     * SoundCloud Track Duration in seconds
     */
    durationInSec: number;
    /**
     * SoundCloud Track Duration in miili seconds
     */
    durationInMs: number;
    /**
     * SoundCloud Track formats data
     */
    formats: SoundCloudTrackFormat[];
    /**
     * SoundCloud Track Publisher Data
     */
    publisher: {
        name: string;
        id: number;
        artist: string;
        contains_music: boolean;
        writer_composer: string;
    } | null;
    /**
     * SoundCloud Track thumbnail
     */
    thumbnail: string;
    /**
     * SoundCloud Track user data
     */
    user: SoundCloudUser;
    /**
     * Constructor for SoundCloud Track Class
     * @param data JSON parsed track html data
     */
    constructor(data: any);
    /**
     * Converts class to JSON
     * @returns JSON parsed Data
     */
    toJSON(): SoundTrackJSON;
}
/**
 * SoundCloud Playlist Class
 */
declare class SoundCloudPlaylist {
    /**
     * SoundCloud Playlist Name
     */
    name: string;
    /**
     * SoundCloud Playlist ID
     */
    id: number;
    /**
     * SoundCloud Playlist URL
     */
    url: string;
    /**
     * SoundCloud Class type. == "playlist"
     */
    type: 'track' | 'playlist' | 'user';
    /**
     * SoundCloud Playlist Sub type. == "album" for soundcloud albums
     */
    sub_type: string;
    /**
     * SoundCloud Playlist Total Duration in seconds
     */
    durationInSec: number;
    /**
     * SoundCloud Playlist Total Duration in milli seconds
     */
    durationInMs: number;
    /**
     * SoundCloud Playlist user data
     */
    user: SoundCloudUser;
    /**
     * SoundCloud Playlist tracks [ It can be fetched or not fetched ]
     */
    tracks: SoundCloudTrack[] | SoundCloudTrackDeprecated[];
    /**
     * SoundCloud Playlist tracks number
     */
    tracksCount: number;
    /**
     * SoundCloud Client ID provided by user
     * @private
     */
    private client_id;
    /**
     * Constructor for SoundCloud Playlist
     * @param data JSON parsed SoundCloud playlist data
     * @param client_id Provided SoundCloud Client ID
     */
    constructor(data: any, client_id: string);
    /**
     * Fetches all unfetched songs in a playlist.
     *
     * For fetching songs and getting all songs, see `fetched_tracks` property.
     * @returns playlist class
     */
    fetch(): Promise<SoundCloudPlaylist>;
    /**
     * Get total no. of fetched tracks
     * @see {@link SoundCloudPlaylist.all_tracks}
     */
    get total_tracks(): number;
    /**
     * Fetches all the tracks in the playlist and returns them
     *
     * ```ts
     * const playlist = await play.soundcloud('playlist url')
     *
     * const tracks = await playlist.all_tracks()
     * ```
     * @returns An array of {@link SoundCloudTrack}
     */
    all_tracks(): Promise<SoundCloudTrack[]>;
    /**
     * Converts Class to JSON data
     * @returns JSON parsed data
     */
    toJSON(): PlaylistJSON;
}
/**
 * SoundCloud Stream class
 */
declare class SoundCloudStream {
    /**
     * Readable Stream through which data passes
     */
    stream: Readable;
    /**
     * Type of audio data that we recieved from normal youtube url.
     */
    type: StreamType;
    /**
     * Dash Url containing segment urls.
     * @private
     */
    private url;
    /**
     * Total time of downloaded segments data.
     * @private
     */
    private downloaded_time;
    /**
     * Timer for looping code every 5 minutes
     * @private
     */
    private timer;
    /**
     * Total segments Downloaded so far
     * @private
     */
    private downloaded_segments;
    /**
     * Incoming message that we recieve.
     *
     * Storing this is essential.
     * This helps to destroy the TCP connection completely if you stopped player in between the stream
     * @private
     */
    private request;
    /**
     * Array of segment time. Useful for calculating downloaded_time.
     */
    private time;
    /**
     * Array of segment_urls in dash file.
     */
    private segment_urls;
    /**
     * Constructor for SoundCloud Stream
     * @param url Dash url containing dash file.
     * @param type Stream Type
     */
    constructor(url: string, type?: StreamType);
    /**
     * Parses SoundCloud dash file.
     * @private
     */
    private parser;
    /**
     * Starts looping of code for getting all segments urls data
     */
    private start;
    /**
     * Main Loop function for getting all segments urls data
     */
    private loop;
    /**
     * This cleans every used variable in class.
     *
     * This is used to prevent re-use of this class and helping garbage collector to collect it.
     */
    private cleanup;
    /**
     * Pauses timer.
     * Stops running of loop.
     *
     * Useful if you don't want to get excess data to be stored in stream.
     */
    pause(): void;
    /**
     * Resumes timer.
     * Starts running of loop.
     */
    resume(): void;
}

/**
 * Gets info from a soundcloud url.
 *
 * ```ts
 * let sound = await play.soundcloud('soundcloud url')
 *
 * // sound.type === "track" | "playlist" | "user"
 *
 * if (sound.type === "track") {
 *      spot = spot as play.SoundCloudTrack
 *      // Code with SoundCloud track class.
 * }
 * ```
 * @param url soundcloud url
 * @returns A {@link SoundCloudTrack} or {@link SoundCloudPlaylist}
 */
declare function soundcloud(url: string): Promise<SoundCloud>;
/**
 * Type of SoundCloud
 */
type SoundCloud = SoundCloudTrack | SoundCloudPlaylist;
/**
 * Gets Free SoundCloud Client ID.
 *
 * Use this in beginning of your code to add SoundCloud support.
 *
 * ```ts
 * play.getFreeClientID().then((clientID) => play.setToken({
 *      soundcloud : {
 *          client_id : clientID
 *      }
 * }))
 * ```
 * @returns client ID
 */
declare function getFreeClientID(): Promise<string>;
/**
 * Validates a soundcloud url
 * @param url soundcloud url
 * @returns
 * ```ts
 * false | 'track' | 'playlist'
 * ```
 */
declare function so_validate(url: string): Promise<false | 'track' | 'playlist' | 'search'>;

/**
 * Interface representing an image on Deezer
 * available in four sizes
 */
interface DeezerImage {
    /**
     * The largest version of the image
     */
    xl: string;
    /**
     * The second largest version of the image
     */
    big: string;
    /**
     * The second smallest version of the image
     */
    medium: string;
    /**
     * The smallest version of the image
     */
    small: string;
}
/**
 * Interface representing a Deezer genre
 */
interface DeezerGenre {
    /**
     * The name of the genre
     */
    name: string;
    /**
     * The thumbnail of the genre available in four sizes
     */
    picture: DeezerImage;
}
/**
 * Interface representing a Deezer user account
 */
interface DeezerUser {
    /**
     * The id of the user
     */
    id: number;
    /**
     * The name of the user
     */
    name: string;
}
/**
 * Class representing a Deezer track
 */
declare class DeezerTrack {
    /**
     * The id of the track
     */
    id: number;
    /**
     * The title of the track
     */
    title: string;
    /**
     * A shorter version of the title
     */
    shortTitle: string;
    /**
     * The URL of the track on Deezer
     */
    url: string;
    /**
     * The duration of the track in seconds
     */
    durationInSec: number;
    /**
     * The rank of the track
     */
    rank: number;
    /**
     * `true` if the track contains any explicit lyrics
     */
    explicit: boolean;
    /**
     * URL to a file containing the first 30 seconds of the track
     */
    previewURL: string;
    /**
     * The artist of the track
     */
    artist: DeezerArtist;
    /**
     * The album that this track is in
     */
    album: DeezerTrackAlbum;
    /**
     * The type, always `'track'`, useful to determine what the deezer function returned
     */
    type: 'track' | 'playlist' | 'album';
    /**
     * Signifies that some properties are not populated
     *
     * Partial tracks can be populated by calling {@link DeezerTrack.fetch}.
     *
     * `true` for tracks in search results and `false` if the track was fetched directly or expanded.
     */
    partial: boolean;
    /**
     * The position of the track in the album
     *
     * `undefined` for partial tracks
     *
     * @see {@link DeezerTrack.partial}
     */
    trackPosition?: number;
    /**
     * The number of the disk the track is on
     *
     * `undefined` for partial tracks
     *
     * @see {@link DeezerTrack.partial}
     */
    diskNumber?: number;
    /**
     * The release date
     *
     * `undefined` for partial tracks
     *
     * @see {@link DeezerTrack.partial}
     */
    releaseDate?: Date;
    /**
     * The number of beats per minute
     *
     * `undefined` for partial tracks
     *
     * @see {@link DeezerTrack.partial}
     */
    bpm?: number;
    /**
     * The gain of the track
     *
     * `undefined` for partial tracks
     *
     * @see {@link DeezerTrack.partial}
     */
    gain?: number;
    /**
     * The artists that have contributed to the track
     *
     * `undefined` for partial tracks
     *
     * @see {@link DeezerTrack.partial}
     */
    contributors?: DeezerArtist[];
    /**
     * Creates a Deezer track from the data in an API response
     * @param data the data to use to create the track
     * @param partial Whether the track should be partial
     * @see {@link DeezerTrack.partial}
     */
    constructor(data: any, partial: boolean);
    /**
     * Fetches and populates the missing fields
     *
     * The property {@link partial} will be `false` if this method finishes successfully.
     *
     * @returns A promise with the same track this method was called on.
     */
    fetch(): Promise<DeezerTrack>;
    /**
     * Converts instances of this class to JSON data
     * @returns JSON data.
     */
    toJSON(): {
        id: number;
        title: string;
        shortTitle: string;
        url: string;
        durationInSec: number;
        rank: number;
        explicit: boolean;
        previewURL: string;
        artist: DeezerArtist;
        album: DeezerTrackAlbum;
        type: "playlist" | "album" | "track";
        trackPosition: number | undefined;
        diskNumber: number | undefined;
        releaseDate: Date | undefined;
        bpm: number | undefined;
        gain: number | undefined;
        contributors: DeezerArtist[] | undefined;
    };
}
/**
 * Class for Deezer Albums
 */
declare class DeezerAlbum {
    /**
     * The id of the album
     */
    id: number;
    /**
     * The title of the album
     */
    title: string;
    /**
     * The URL to the album on Deezer
     */
    url: string;
    /**
     * The record type of the album (e.g. EP, ALBUM, etc ...)
     */
    recordType: string;
    /**
     * `true` if the album contains any explicit lyrics
     */
    explicit: boolean;
    /**
     * The artist of the album
     */
    artist: DeezerArtist;
    /**
     * The album cover available in four sizes
     */
    cover: DeezerImage;
    /**
     * The type, always `'album'`, useful to determine what the deezer function returned
     */
    type: 'track' | 'playlist' | 'album';
    /**
     * The number of tracks in the album
     */
    tracksCount: number;
    /**
     * Signifies that some properties are not populated
     *
     * Partial albums can be populated by calling {@link DeezerAlbum.fetch}.
     *
     * `true` for albums in search results and `false` if the album was fetched directly or expanded.
     */
    partial: boolean;
    /**
     * The **u**niversal **p**roduct **c**ode of the album
     *
     * `undefined` for partial albums
     *
     * @see {@link DeezerAlbum.partial}
     */
    upc?: string;
    /**
     * The duration of the album in seconds
     *
     * `undefined` for partial albums
     *
     * @see {@link DeezerAlbum.partial}
     */
    durationInSec?: number;
    /**
     * The number of fans the album has
     *
     * `undefined` for partial albums
     *
     * @see {@link DeezerAlbum.partial}
     */
    numberOfFans?: number;
    /**
     * The release date of the album
     *
     * `undefined` for partial albums
     *
     * @see {@link DeezerAlbum.partial}
     */
    releaseDate?: Date;
    /**
     * Whether the album is available
     *
     * `undefined` for partial albums
     *
     * @see {@link DeezerAlbum.partial}
     */
    available?: boolean;
    /**
     * The list of genres present in this album
     *
     * `undefined` for partial albums
     *
     * @see {@link DeezerAlbum.partial}
     */
    genres?: DeezerGenre[];
    /**
     * The contributors to the album
     *
     * `undefined` for partial albums
     *
     * @see {@link DeezerAlbum.partial}
     */
    contributors?: DeezerArtist[];
    /**
     * The list of tracks in the album
     *
     * empty (length === 0) for partial albums
     *
     * Use {@link DeezerAlbum.fetch} to populate the tracks and other properties
     *
     * @see {@link DeezerAlbum.partial}
     */
    tracks: DeezerTrack[];
    /**
     * Creates a Deezer album from the data in an API response
     * @param data the data to use to create the album
     * @param partial Whether the album should be partial
     * @see {@link DeezerAlbum.partial}
     */
    constructor(data: any, partial: boolean);
    /**
     * Fetches and populates the missing fields including all tracks.
     *
     * The property {@link DeezerAlbum.partial} will be `false` if this method finishes successfully.
     *
     * @returns A promise with the same album this method was called on.
     */
    fetch(): Promise<DeezerAlbum>;
    /**
     * Fetches all the tracks in the album and returns them
     *
     * ```ts
     * const album = await play.deezer('album url')
     *
     * const tracks = await album.all_tracks()
     * ```
     * @returns An array of {@link DeezerTrack}
     */
    all_tracks(): Promise<DeezerTrack[]>;
    /**
     * Converts instances of this class to JSON data
     * @returns JSON data.
     */
    toJSON(): {
        id: number;
        title: string;
        url: string;
        recordType: string;
        explicit: boolean;
        artist: DeezerArtist;
        cover: DeezerImage;
        type: "playlist" | "album" | "track";
        upc: string | undefined;
        tracksCount: number;
        durationInSec: number | undefined;
        numberOfFans: number | undefined;
        releaseDate: Date | undefined;
        available: boolean | undefined;
        genres: DeezerGenre[] | undefined;
        contributors: DeezerArtist[] | undefined;
        tracks: {
            id: number;
            title: string;
            shortTitle: string;
            url: string;
            durationInSec: number;
            rank: number;
            explicit: boolean;
            previewURL: string;
            artist: DeezerArtist;
            album: DeezerTrackAlbum;
            type: "playlist" | "album" | "track";
            trackPosition: number | undefined;
            diskNumber: number | undefined;
            releaseDate: Date | undefined;
            bpm: number | undefined;
            gain: number | undefined;
            contributors: DeezerArtist[] | undefined;
        }[];
    };
}
/**
 * Class for Deezer Playlists
 */
declare class DeezerPlaylist {
    /**
     * The id of the playlist
     */
    id: number;
    /**
     * The title of the playlist
     */
    title: string;
    /**
     * Whether the playlist is public or private
     */
    public: boolean;
    /**
     * The URL of the playlist on Deezer
     */
    url: string;
    /**
     * Cover picture of the playlist available in four sizes
     */
    picture: DeezerImage;
    /**
     * The date of the playlist's creation
     */
    creationDate: Date;
    /**
     * The type, always `'playlist'`, useful to determine what the deezer function returned
     */
    type: 'track' | 'playlist' | 'album';
    /**
     * The Deezer user that created the playlist
     */
    creator: DeezerUser;
    /**
     * The number of tracks in the playlist
     */
    tracksCount: number;
    /**
     * Signifies that some properties are not populated
     *
     * Partial playlists can be populated by calling {@link DeezerPlaylist.fetch}.
     *
     * `true` for playlists in search results and `false` if the album was fetched directly or expanded.
     */
    partial: boolean;
    /**
     * Description of the playlist
     *
     * `undefined` for partial playlists
     *
     * @see {@link DeezerPlaylist.partial}
     */
    description?: string;
    /**
     * Duration of the playlist in seconds
     *
     * `undefined` for partial playlists
     *
     * @see {@link DeezerPlaylist.partial}
     */
    durationInSec?: number;
    /**
     * `true` if the playlist is the loved tracks playlist
     *
     * `undefined` for partial playlists
     *
     * @see {@link DeezerPlaylist.partial}
     */
    isLoved?: boolean;
    /**
     * Whether multiple users have worked on the playlist
     *
     * `undefined` for partial playlists
     *
     * @see {@link DeezerPlaylist.partial}
     */
    collaborative?: boolean;
    /**
     * The number of fans the playlist has
     *
     * `undefined` for partial playlists
     *
     * @see {@link DeezerPlaylist.partial}
     */
    fans?: number;
    /**
     * The list of tracks in the playlist
     *
     * empty (length === 0) for partial and non public playlists
     *
     * Use {@link DeezerPlaylist.fetch} to populate the tracks and other properties
     *
     * @see {@link DeezerPlaylist.partial}
     * @see {@link DeezerPlaylist.public}
     */
    tracks: DeezerTrack[];
    /**
     * Creates a Deezer playlist from the data in an API response
     * @param data the data to use to create the playlist
     * @param partial Whether the playlist should be partial
     * @see {@link DeezerPlaylist.partial}
     */
    constructor(data: any, partial: boolean);
    /**
     * Fetches and populates the missing fields, including all tracks.
     *
     * The property {@link DeezerPlaylist.partial} will be `false` if this method finishes successfully.
     *
     * @returns A promise with the same playlist this method was called on.
     */
    fetch(): Promise<DeezerPlaylist>;
    /**
     * Fetches all the tracks in the playlist and returns them
     *
     * ```ts
     * const playlist = await play.deezer('playlist url')
     *
     * const tracks = await playlist.all_tracks()
     * ```
     * @returns An array of {@link DeezerTrack}
     */
    all_tracks(): Promise<DeezerTrack[]>;
    /**
     * Converts instances of this class to JSON data
     * @returns JSON data.
     */
    toJSON(): {
        id: number;
        title: string;
        public: boolean;
        url: string;
        picture: DeezerImage;
        creationDate: Date;
        type: "playlist" | "album" | "track";
        creator: DeezerUser;
        tracksCount: number;
        description: string | undefined;
        durationInSec: number | undefined;
        isLoved: boolean | undefined;
        collaborative: boolean | undefined;
        fans: number | undefined;
        tracks: {
            id: number;
            title: string;
            shortTitle: string;
            url: string;
            durationInSec: number;
            rank: number;
            explicit: boolean;
            previewURL: string;
            artist: DeezerArtist;
            album: DeezerTrackAlbum;
            type: "playlist" | "album" | "track";
            trackPosition: number | undefined;
            diskNumber: number | undefined;
            releaseDate: Date | undefined;
            bpm: number | undefined;
            gain: number | undefined;
            contributors: DeezerArtist[] | undefined;
        }[];
    };
}
declare class DeezerTrackAlbum {
    id: number;
    title: string;
    url: string;
    cover: DeezerImage;
    releaseDate?: Date;
    constructor(data: any);
}
/**
 * Class representing a Deezer artist
 */
declare class DeezerArtist {
    /**
     * The id of the artist
     */
    id: number;
    /**
     * The name of the artist
     */
    name: string;
    /**
     * The URL of the artist on Deezer
     */
    url: string;
    /**
     * The picture of the artist available in four sizes
     */
    picture?: DeezerImage;
    /**
     * The of the artist on the track
     */
    role?: string;
    constructor(data: any);
}

interface DeezerAdvancedSearchOptions {
    /**
     * The maximum number of results to return, maximum `100`, defaults to `10`.
     */
    limit?: number;
    /**
     * The name of the artist.
     */
    artist?: string;
    /**
     * The title of the album.
     */
    album?: string;
    /**
     * The title of the track.
     */
    title?: string;
    /**
     * The label that released the track.
     */
    label?: string;
    /**
     * The minimum duration in seconds.
     */
    minDurationInSec?: number;
    /**
     * The maximum duration in seconds.
     */
    maxDurationInSec?: number;
    /**
     * The minimum BPM.
     */
    minBPM?: number;
    /**
     * The minimum BPM.
     */
    maxBPM?: number;
}
/**
 * Shared type for Deezer tracks, playlists and albums
 */
type Deezer = DeezerTrack | DeezerPlaylist | DeezerAlbum;
/**
 * Fetches the information for a track, playlist or album on Deezer
 * @param url The track, playlist or album URL
 * @returns A {@link DeezerTrack}, {@link DeezerPlaylist} or {@link DeezerAlbum}
 * object depending on the provided URL.
 */
declare function deezer(url: string): Promise<Deezer>;
/**
 * Validates a Deezer URL
 * @param url The URL to validate
 * @returns The type of the URL either `'track'`, `'playlist'`, `'album'`, `'search'` or `false`.
 * `false` means that the provided URL was a wrongly formatted or an unsupported Deezer URL.
 */
declare function dz_validate(url: string): Promise<'track' | 'playlist' | 'album' | 'search' | false>;
/**
 * Searches Deezer for tracks using the specified metadata.
 * @param options The metadata and limit for the search
 *
 * * limit?: The maximum number of results to return, maximum `100`, defaults to `10`.
 * * artist?: The name of the artist
 * * album?: The title of the album
 * * title?: The title of the track
 * * label?: The label that released the track
 * * minDurationInSec?: The minimum duration in seconds
 * * maxDurationInSec?: The maximum duration in seconds
 * * minBpm?: The minimum BPM
 * * maxBpm?: The minimum BPM
 * @returns An array of tracks matching the metadata
 */
declare function dz_advanced_track_search(options: DeezerAdvancedSearchOptions): Promise<DeezerTrack[]>;

interface tokenOptions {
    spotify?: {
        client_id: string;
        client_secret: string;
        refresh_token: string;
        market: string;
    };
    soundcloud?: {
        client_id: string;
    };
    youtube?: {
        cookie: string;
    };
    useragent?: string[];
}
/**
 * Sets
 *
 *  i> YouTube :- cookies.
 *
 *  ii> SoundCloud :- client ID.
 *
 *  iii> Spotify :- client ID, client secret, refresh token, market.
 *
 *  iv> Useragents :- array of string.
 *
 * locally in memory.
 *
 * Example :
 * ```ts
 * play.setToken({
 *      youtube : {
 *          cookie : "Your Cookies"
 *      }
 * }) // YouTube Cookies
 *
 * await play.setToken({
 *      spotify : {
 *          client_id: 'ID',
            client_secret: 'secret',
            refresh_token: 'token',
            market: 'US'
 *      }
 * }) // Await this only when setting data for spotify
 *
 * play.setToken({
 *      useragent: ['Your User-agent']
 * }) // Use this to avoid 429 errors.
 * ```
 * @param options {@link tokenOptions}
 */
declare function setToken(options: tokenOptions): Promise<void>;

interface SearchOptions {
    limit?: number;
    source?: {
        youtube?: 'video' | 'playlist' | 'channel';
        spotify?: 'album' | 'playlist' | 'track';
        soundcloud?: 'tracks' | 'playlists' | 'albums';
        deezer?: 'track' | 'playlist' | 'album';
    };
    fuzzy?: boolean;
    language?: string;
    /**
     * !!! Before enabling this for public servers, please consider using Discord features like NSFW channels as not everyone in your server wants to see NSFW images. !!!
     * Unblurred images will likely have different dimensions than specified in the {@link YouTubeThumbnail} objects.
     */
    unblurNSFWThumbnails?: boolean;
}

declare function stream(url: string, options: {
    seek?: number;
} & StreamOptions): Promise<YouTubeStream>;
declare function stream(url: string, options?: StreamOptions): Promise<YouTubeStream | SoundCloudStream>;
declare function search(query: string, options: {
    source: {
        deezer: 'album';
    };
} & SearchOptions): Promise<DeezerAlbum[]>;
declare function search(query: string, options: {
    source: {
        deezer: 'playlist';
    };
} & SearchOptions): Promise<DeezerPlaylist[]>;
declare function search(query: string, options: {
    source: {
        deezer: 'track';
    };
} & SearchOptions): Promise<DeezerTrack[]>;
declare function search(query: string, options: {
    source: {
        soundcloud: 'albums';
    };
} & SearchOptions): Promise<SoundCloudPlaylist[]>;
declare function search(query: string, options: {
    source: {
        soundcloud: 'playlists';
    };
} & SearchOptions): Promise<SoundCloudPlaylist[]>;
declare function search(query: string, options: {
    source: {
        soundcloud: 'tracks';
    };
} & SearchOptions): Promise<SoundCloudTrack[]>;
declare function search(query: string, options: {
    source: {
        spotify: 'album';
    };
} & SearchOptions): Promise<SpotifyAlbum[]>;
declare function search(query: string, options: {
    source: {
        spotify: 'playlist';
    };
} & SearchOptions): Promise<SpotifyPlaylist[]>;
declare function search(query: string, options: {
    source: {
        spotify: 'track';
    };
} & SearchOptions): Promise<SpotifyTrack[]>;
declare function search(query: string, options: {
    source: {
        youtube: 'channel';
    };
} & SearchOptions): Promise<YouTubeChannel[]>;
declare function search(query: string, options: {
    source: {
        youtube: 'playlist';
    };
} & SearchOptions): Promise<YouTubePlayList[]>;
declare function search(query: string, options: {
    source: {
        youtube: 'video';
    };
} & SearchOptions): Promise<YouTubeVideo[]>;
declare function search(query: string, options: {
    limit: number;
} & SearchOptions): Promise<YouTubeVideo[]>;
declare function search(query: string, options?: SearchOptions): Promise<YouTubeVideo[]>;
declare function stream_from_info(info: SoundCloudTrack, options?: StreamOptions): Promise<SoundCloudStream>;
declare function stream_from_info(info: InfoData, options?: StreamOptions): Promise<YouTubeStream>;
/**
 * Validates url that play-dl supports.
 *
 * - `so` - SoundCloud
 * - `sp` - Spotify
 * - `dz` - Deezer
 * - `yt` - YouTube
 * @param url URL
 * @returns
 * ```ts
 * 'so_playlist' / 'so_track' | 'sp_track' | 'sp_album' | 'sp_playlist' | 'dz_track' | 'dz_playlist' | 'dz_album' | 'yt_video' | 'yt_playlist' | 'search' | false
 * ```
 */
declare function validate(url: string): Promise<'so_playlist' | 'so_track' | 'sp_track' | 'sp_album' | 'sp_playlist' | 'dz_track' | 'dz_playlist' | 'dz_album' | 'yt_video' | 'yt_playlist' | 'search' | false>;
/**
 * Authorization interface for Spotify, SoundCloud and YouTube.
 *
 * Either stores info in `.data` folder or shows relevant data to be used in `setToken` function.
 *
 * ```ts
 * const play = require('play-dl')
 *
 * play.authorization()
 * ```
 *
 * Just run the above command and you will get a interface asking some questions.
 */
declare function authorization(): void;
/**
 * Attaches paused, playing, autoPaused Listeners to discordjs voice AudioPlayer.
 *
 * Useful if you don't want extra data to be downloaded by play-dl.
 * @param player discordjs voice AudioPlayer
 * @param resource A {@link YouTubeStream} or {@link SoundCloudStream}
 */
declare function attachListeners(player: EventEmitter, resource: YouTubeStream | SoundCloudStream): void;

declare const _default: {
    DeezerAlbum: typeof DeezerAlbum;
    DeezerPlaylist: typeof DeezerPlaylist;
    DeezerTrack: typeof DeezerTrack;
    SoundCloudPlaylist: typeof SoundCloudPlaylist;
    SoundCloudStream: typeof SoundCloudStream;
    SoundCloudTrack: typeof SoundCloudTrack;
    SpotifyAlbum: typeof SpotifyAlbum;
    SpotifyPlaylist: typeof SpotifyPlaylist;
    SpotifyTrack: typeof SpotifyTrack;
    YouTubeChannel: typeof YouTubeChannel;
    YouTubePlayList: typeof YouTubePlayList;
    YouTubeVideo: typeof YouTubeVideo;
    attachListeners: typeof attachListeners;
    authorization: typeof authorization;
    decipher_info: typeof decipher_info;
    deezer: typeof deezer;
    dz_advanced_track_search: typeof dz_advanced_track_search;
    dz_validate: typeof dz_validate;
    extractID: typeof extractID;
    getFreeClientID: typeof getFreeClientID;
    is_expired: typeof is_expired;
    playlist_info: typeof playlist_info;
    refreshToken: typeof refreshToken;
    search: typeof search;
    setToken: typeof setToken;
    so_validate: typeof so_validate;
    soundcloud: typeof soundcloud;
    spotify: typeof spotify;
    sp_validate: typeof sp_validate;
    stream: typeof stream;
    stream_from_info: typeof stream_from_info;
    validate: typeof validate;
    video_basic_info: typeof video_basic_info;
    video_info: typeof video_info;
    yt_validate: typeof yt_validate;
};

export { type Deezer, DeezerAlbum, DeezerPlaylist, DeezerTrack, type InfoData, type SoundCloud, SoundCloudPlaylist, SoundCloudStream, SoundCloudTrack, type Spotify, SpotifyAlbum, SpotifyPlaylist, SpotifyTrack, type YouTube, YouTubeChannel, YouTubePlayList, type YouTubeStream, YouTubeVideo, attachListeners, authorization, decipher_info, deezer, _default as default, dz_advanced_track_search, dz_validate, extractID, getFreeClientID, is_expired, playlist_info, refreshToken, search, setToken, so_validate, soundcloud, sp_validate, spotify, stream, stream_from_info, validate, video_basic_info, video_info, yt_validate };