import type { LavalinkManager } from './manager';
import type { LavalinkNode } from './node';
import type { PlayerOptions, Track, Filters, LoopMode, TrackEndReason, PersistedPlayerState, VoiceServerPayload, SponsorBlockCategory } from './types';
import { LavalinkQueue } from './queue';
/** Real-time state updated from Lavalink `playerUpdate` ops */
export interface PlayerState {
    position: number;
    ping: number;
    connected: boolean;
    time: number;
}
/**
 * Controls audio playback for a single Discord guild.
 *
 * Create via `manager.create()` — do not construct directly.
 *
 * Key features:
 * - Chainable async API (`await player.play(track).then(p => p.setVolume(80))`)
 * - Built-in loop modes: none / track / queue
 * - Auto-advance on track end, error, and stuck
 * - 50-track history ring in `player.queue.history`
 * - Filter presets: `bassBoost`, `nightcore`, `vaporwave`, `eightD`, `karaoke`, …
 * - State auto-saved to disk after every meaningful change
 */
export declare class LavalinkPlayer {
    readonly manager: LavalinkManager;
    readonly guildId: string;
    /** The Lavalink node this player is attached to */
    node: LavalinkNode;
    readonly queue: LavalinkQueue;
    voiceChannelId: string;
    textChannelId: string | undefined;
    selfDeaf: boolean;
    selfMute: boolean;
    /** Current volume 0–1000 */
    volume: number;
    paused: boolean;
    playing: boolean;
    loop: LoopMode;
    /** Automatically queue a related track when the queue runs out (default: false) */
    autoplay: boolean;
    filters: Filters;
    /** Currently playing track, or null if idle */
    current: Track | null;
    /** @internal — updated by LavalinkNode on `playerUpdate` */
    _state: PlayerState;
    /** @internal — collected from Discord VOICE_STATE_UPDATE */
    _voiceSessionId: string | null;
    /** @internal — collected from Discord VOICE_SERVER_UPDATE */
    _voiceServer: VoiceServerPayload | null;
    /** @internal — track to replay after voice WS reconnect (set when cleanup fires) */
    _reconnectTrack: Track | null;
    /** @internal — interval handle for periodic position saves */
    private _positionInterval;
    constructor(manager: LavalinkManager, node: LavalinkNode, options: PlayerOptions);
    /**
     * Interpolated playback position in milliseconds.
     * More accurate than `_state.position` because it accounts for
     * elapsed time since the last Lavalink `playerUpdate` op.
     */
    get position(): number;
    /** Send a voice-state payload to Discord to join the configured voice channel */
    connect(): Promise<this>;
    /** Leave the voice channel (does not destroy the player) */
    disconnect(): Promise<this>;
    /**
     * Destroy the player — disconnects, removes from manager, and clears persistence.
     * @param disconnect  Also leave the voice channel (default: true).
     */
    destroy(disconnect?: boolean): Promise<void>;
    /**
     * Play a track.
     * If no track is supplied, shifts the first track from the queue.
     * Throws if there's nothing to play.
     */
    play(track?: Track): Promise<this>;
    /**
     * Skip the current track.
     * Lavalink will send a `TrackEndEvent` with reason `'replaced'`,
     * and the next track in the queue will start automatically.
     */
    skip(): Promise<this>;
    /** Stop playback and clear the current track */
    stop(): Promise<this>;
    /**
     * Pause or un-pause playback.
     * Calling with no argument pauses; pass `false` to resume.
     */
    pause(state?: boolean): Promise<this>;
    /** Resume playback (alias for `pause(false)`) */
    resume(): Promise<this>;
    /**
     * Seek to an absolute position in milliseconds.
     * Throws if the current track isn't seekable.
     */
    seek(position: number): Promise<this>;
    /**
     * Set the player volume (0–1000).
     * 100 is 100 %, 200 is 200 %, etc.
     */
    setVolume(volume: number): Promise<this>;
    /**
     * Set the loop mode: `'none'` | `'track'` | `'queue'`
     * - `'track'`  — repeat the current track indefinitely
     * - `'queue'`  — repeat the whole queue indefinitely
     */
    setLoop(mode: LoopMode): this;
    /** Apply a partial filter object (merges with current filters) */
    setFilters(filters: Partial<Filters>): Promise<this>;
    /** Reset all active filters */
    clearFilters(): Promise<this>;
    bassBoost(level?: 'low' | 'medium' | 'high' | 'extreme'): Promise<this>;
    nightcore(enabled?: boolean): Promise<this>;
    vaporwave(enabled?: boolean): Promise<this>;
    eightD(enabled?: boolean): Promise<this>;
    karaoke(enabled?: boolean): Promise<this>;
    softFilter(enabled?: boolean): Promise<this>;
    trebleBass(enabled?: boolean): Promise<this>;
    tremolo(enabled?: boolean): Promise<this>;
    vibrato(enabled?: boolean): Promise<this>;
    /** @internal */
    _handleTrackStart(track: Track): void;
    /** @internal */
    _handleTrackEnd(track: Track, reason: TrackEndReason): void;
    /** @internal */
    _handleTrackException(track: Track, exception: unknown): void;
    /** @internal */
    _handleTrackStuck(track: Track, thresholdMs: number): void;
    /** @internal — trigger a persistence write */
    _save(): void;
    /** Serialize the player's full state for disk persistence */
    toJSON(): PersistedPlayerState;
    private _startPositionInterval;
    private _clearPositionInterval;
    /**
     * Enable SponsorBlock segment skipping for this player.
     * Requires the SponsorBlock Lavalink plugin to be installed on the server.
     *
     * @param categories - Segment categories to skip (e.g. `['sponsor', 'selfpromo']`)
     */
    setSponsorBlock(categories: SponsorBlockCategory[]): Promise<this>;
    /**
     * Disable all SponsorBlock segment skipping for this player.
     */
    clearSponsorBlock(): Promise<this>;
    /**
     * @internal — called when `autoplay` is true and the queue runs out.
     * Searches for a related track using the seed track's title + author.
     */
    private _triggerAutoplay;
}
//# sourceMappingURL=player.d.ts.map