import { Filters } from "./Filters";
import { Synthra, SearchQuery, SearchResult } from "./Manager";
import { Lyrics, Node, SponsorBlockSegment } from "./Node";
import { Queue } from "./Queue";
import { Sizes, StateTypes, TrackSourceName, VoiceState } from "./Utils";
import { ClientUser, Message, User } from "discord.js";
export declare class Player {
    options: PlayerOptions;
    /** The Queue for the Player. */
    readonly queue: Queue;
    /** The filters applied to the audio. */
    filters: Filters;
    /** Whether the queue repeats the track. */
    trackRepeat: boolean;
    /** Whether the queue repeats the queue. */
    queueRepeat: boolean;
    /**Whether the queue repeats and shuffles after each song. */
    dynamicRepeat: boolean;
    /** The time the player is in the track. */
    position: number;
    /** Whether the player is playing. */
    playing: boolean;
    /** Whether the player is paused. */
    paused: boolean;
    /** The volume for the player */
    volume: number;
    /** The Node for the Player. */
    node: Node;
    /** The guild ID for the player. */
    guildId: string;
    /** The voice channel for the player. */
    voiceChannelId: string | null;
    /** The text channel for the player. */
    textChannelId: string | null;
    /**The now playing message. */
    nowPlayingMessage?: Message;
    /** The current state of the player. */
    state: StateTypes;
    /** The equalizer bands array. */
    bands: number[];
    /** The voice state object from Discord. */
    voiceState: VoiceState;
    /** The Manager. */
    manager: Synthra;
    /** The autoplay state of the player. */
    isAutoplay: boolean;
    /** The number of times to try autoplay before emitting queueEnd. */
    autoplayTries: number | null;
    private static _manager;
    private readonly data;
    private dynamicLoopInterval;
    private dynamicRepeatIntervalMs;
    /**
     * Creates a new player, returns one if it already exists.
     * @param options The player options.
     * @see https://docs.magmastream.com/main/introduction/getting-started
     */
    constructor(options: PlayerOptions);
    /**
     * Set custom data.
     * @param key - The key to set the data for.
     * @param value - The value to set the data to.
     */
    set(key: string, value: unknown): void;
    /**
     * Retrieves custom data associated with a given key.
     * @template T - The expected type of the data.
     * @param {string} key - The key to retrieve the data for.
     * @returns {T} - The data associated with the key, cast to the specified type.
     */
    get<T>(key: string): T;
    /**
     * Initializes the static properties of the Player class.
     * @hidden
     * @param manager The Manager to use.
     */
    static init(manager: Synthra): void;
    /**
     * Same as Manager#search() but a shortcut on the player itself.
     * @param query
     * @param requester
     */
    search<T extends User | ClientUser = User | ClientUser>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
    /**
     * Connects the player to the voice channel.
     * @throws {RangeError} If no voice channel has been set.
     * @returns {void}
     */
    connect(): void;
    /**
     * Disconnects the player from the voice channel.
     * @throws {TypeError} If the player is not connected.
     * @returns {this} - The current instance of the Player class for method chaining.
     */
    disconnect(): Promise<this>;
    /**
     * Destroys the player and clears the queue.
     * @param {boolean} disconnect - Whether to disconnect the player from the voice channel.
     * @returns {Promise<boolean>} - Whether the player was successfully destroyed.
     * @emits {PlayerDestroy} - Emitted when the player is destroyed.
     * @emits {PlayerStateUpdate} - Emitted when the player state is updated.
     */
    destroy(disconnect?: boolean): Promise<boolean>;
    /**
     * Sets the player voice channel.
     * @param {string} channel - The new voice channel ID.
     * @returns {this} - The player instance.
     * @throws {TypeError} If the channel parameter is not a string.
     */
    setVoiceChannelId(channel: string): this;
    /**
     * Sets the player text channel.
     *
     * This method updates the text channel associated with the player. It also
     * emits a player state update event indicating the change in the channel.
     *
     * @param {string} channel - The new text channel ID.
     * @returns {this} - The player instance for method chaining.
     * @throws {TypeError} If the channel parameter is not a string.
     */
    setTextChannelId(channel: string): this;
    /**
     * Sets the now playing message.
     *
     * @param message - The message of the now playing message.
     * @returns The now playing message.
     */
    setNowPlayingMessage<T = Message>(message: T): Message;
    /**
     * Plays the next track.
     *
     * If a track is provided, it will be played. Otherwise, the next track in the queue will be played.
     * If the queue is not empty, but the current track has not finished yet, it will be replaced with the provided track.
     *
     * @param {object} [optionsOrTrack] - The track to play or the options to play with.
     * @param {object} [playOptions] - The options to play with.
     *
     * @returns {Promise<void>}
     */
    play(): Promise<Player>;
    play(track: Track): Promise<Player>;
    play(options: PlayOptions): Promise<Player>;
    play(track: Track, options: PlayOptions): Promise<Player>;
    /**
     * Sets the autoplay-state of the player.
     *
     * Autoplay is a feature that makes the player play a recommended
     * track when the current track ends.
     *
     * @param {boolean} autoplayState - Whether or not autoplay should be enabled.
     * @param {object} botUser - The user-object that should be used as the bot-user.
     * @param {number} [tries=3] - The number of times the player should try to find a
     * recommended track if the first one doesn't work.
     * @returns {this} - The player instance.
     */
    setAutoplay(autoplayState: boolean, botUser?: object, tries?: number): this;
    /**
     * Gets recommended tracks and returns an array of tracks.
     * @param {Track} track - The track to find recommendations for.
     * @returns {Promise<Track[]>} - Array of recommended tracks.
     */
    getRecommendedTracks(track: Track): Promise<Track[]>;
    /**
     * Handles YouTube-based recommendations.
     * @param {Track} track - The track to find recommendations for.
     * @returns {Promise<Track[]>} - Array of recommended tracks.
     */
    private handleYouTubeRecommendations;
    /**
     * Handles Last.fm-based autoplay (or other platforms).
     * @param {Track} track - The track to find recommendations for.
     * @param {SearchPlatform} source - The selected search platform.
     * @param {string} apiKey - The Last.fm API key.
     * @returns {Promise<Track[]>} - Array of recommended tracks.
     */
    private handlePlatformAutoplay;
    /**
     * Sets the volume of the player.
     * @param {number} volume - The new volume. Must be between 0 and 1000.
     * @returns {Promise<Player>} - The updated player.
     * @throws {TypeError} If the volume is not a number.
     * @throws {RangeError} If the volume is not between 0 and 1000.
     * @emits {PlayerStateUpdate} - Emitted when the volume is changed.
     * @example
     * player.setVolume(50);
     */
    setVolume(volume: number): Promise<this>;
    /**
     * Sets the sponsorblock for the player. This will set the sponsorblock segments for the player to the given segments.
     * @param {SponsorBlockSegment[]} segments - The sponsorblock segments to set. Defaults to `[SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]` if not provided.
     * @returns {Promise<void>} The promise is resolved when the operation is complete.
     */
    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
    /**
     * Gets the sponsorblock for the player.
     * @returns {Promise<SponsorBlockSegment[]>} The sponsorblock segments.
     */
    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
    /**
     * Deletes the sponsorblock for the player. This will remove all sponsorblock segments that have been set for the player.
     * @returns {Promise<void>}
     */
    deleteSponsorBlock(): Promise<void>;
    /**
     * Sets the track repeat mode.
     * When track repeat is enabled, the current track will replay after it ends.
     * Disables queueRepeat and dynamicRepeat modes if enabled.
     *
     * @param repeat - A boolean indicating whether to enable track repeat.
     * @returns {this} - The player instance.
     * @throws {TypeError} If the repeat parameter is not a boolean.
     */
    setTrackRepeat(repeat: boolean): this;
    /**
     * Sets the queue repeat.
     * @param repeat Whether to repeat the queue or not
     * @returns {this} - The player instance.
     * @throws {TypeError} If the repeat parameter is not a boolean
     */
    setQueueRepeat(repeat: boolean): this;
    /**
     * Sets the queue to repeat and shuffles the queue after each song.
     * @param repeat "true" or "false".
     * @param ms After how many milliseconds to trigger dynamic repeat.
     * @returns {this} - The player instance.
     * @throws {TypeError} If the repeat parameter is not a boolean.
     * @throws {RangeError} If the queue size is less than or equal to 1.
     */
    setDynamicRepeat(repeat: boolean, ms: number): this;
    /**
     * Restarts the currently playing track from the beginning.
     * If there is no track playing, it will play the next track in the queue.
     * @returns {Promise<Player>} The current instance of the Player class for method chaining.
     */
    restart(): Promise<Player>;
    /**
     * Stops the player and optionally removes tracks from the queue.
     * @param {number} [amount] The amount of tracks to remove from the queue. If not provided, removes the current track if it exists.
     * @returns {Promise<this>} - The player instance.
     * @throws {RangeError} If the amount is greater than the queue length.
     */
    stop(amount?: number): Promise<this>;
    /**
     * Skips the current track.
     * @returns {this} - The player instance.
     * @throws {Error} If there are no tracks in the queue.
     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
     */
    pause(pause: boolean): Promise<this>;
    /**
     * Skips to the previous track in the queue.
     * @returns {this} - The player instance.
     * @throws {Error} If there are no previous tracks in the queue.
     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
     */
    previous(): Promise<this>;
    /**
     * Seeks to a given position in the currently playing track.
     * @param position - The position in milliseconds to seek to.
     * @returns {this} - The player instance.
     * @throws {Error} If the position is invalid.
     * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
     */
    seek(position: number): Promise<this>;
    /**
     * Returns the current repeat state of the player.
     * @param player The player to get the repeat state from.
     * @returns The repeat state of the player, or null if it is not repeating.
     */
    private getRepeatState;
    /**
     * Automatically moves the player to a usable node.
     * @returns {Promise<Player | void>} - The player instance or void if not moved.
     */
    autoMoveNode(): Promise<Player | void>;
    /**
     * Moves the player to another node.
     * @param {string} identifier - The identifier of the node to move to.
     * @returns {Promise<Player>} - The player instance after being moved.
     */
    moveNode(identifier: string): Promise<Player>;
    /**
     * Transfers the player to a new server. If the player already exists on the new server
     * and force is false, this method will return the existing player. Otherwise, a new player
     * will be created and the current player will be destroyed.
     * @param {PlayerOptions} newOptions - The new options for the player.
     * @param {boolean} force - Whether to force the creation of a new player.
     * @returns {Promise<Player>} - The new player instance.
     */
    switchGuild(newOptions: PlayerOptions, force?: boolean): Promise<Player>;
    /**
     * Retrieves the current lyrics for the playing track.
     * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.
     * @returns {Promise<Lyrics>} - The lyrics of the current track.
     * @throws {RangeError} - If the 'lavalyrics-plugin' is not available on the Lavalink node.
     */
    getCurrentLyrics(skipTrackSource?: boolean): Promise<Lyrics>;
}
export interface PlayerOptions {
    /** The guild ID the Player belongs to. */
    guildId: string;
    /** The text channel the Player belongs to. */
    textChannelId: string;
    /** The voice channel the Player belongs to. */
    voiceChannelId?: string;
    /** The node the Player uses. */
    node?: string;
    /** The initial volume the Player will use. */
    volume?: number;
    /** If the player should mute itself. */
    selfMute?: boolean;
    /** If the player should deaf itself. */
    selfDeafen?: boolean;
}
/** If track partials are set some of these will be `undefined` as they were removed. */
export interface Track {
    /** The base64 encoded track. */
    readonly track: string;
    /** The artwork url of the track. */
    readonly artworkUrl: string;
    /** The track source name. */
    readonly sourceName: TrackSourceName;
    /** The title of the track. */
    title: string;
    /** The identifier of the track. */
    readonly identifier: string;
    /** The author of the track. */
    author: string;
    /** The duration of the track. */
    readonly duration: number;
    /** The ISRC of the track. */
    readonly isrc: string;
    /** If the track is seekable. */
    readonly isSeekable: boolean;
    /** If the track is a stream.. */
    readonly isStream: boolean;
    /** The uri of the track. */
    readonly uri: string;
    /** The thumbnail of the track or null if it's a unsupported source. */
    readonly thumbnail: string | null;
    /** The user that requested the track. */
    readonly requester?: User | ClientUser;
    /** Displays the track thumbnail with optional size or null if it's a unsupported source. */
    displayThumbnail(size?: Sizes): string;
    /** Additional track info provided by plugins. */
    pluginInfo: TrackPluginInfo;
    /** Add your own data to the track. */
    customData: Record<string, unknown>;
}
export interface TrackPluginInfo {
    albumName?: string;
    albumUrl?: string;
    artistArtworkUrl?: string;
    artistUrl?: string;
    isPreview?: string;
    previewUrl?: string;
}
export interface PlayOptions {
    /** The position to start the track. */
    readonly startTime?: number;
    /** The position to end the track. */
    readonly endTime?: number;
    /** Whether to not replace the track if a play payload is sent. */
    readonly noReplace?: boolean;
}
export interface EqualizerBand {
    /** The band number being 0 to 14. */
    band: number;
    /** The gain amount being -0.25 to 1.00, 0.25 being double. */
    gain: number;
}