import { EventEmitter } from "../events/EventEmitter";
import { PlayerEventMap, PlayerState, VideoTrack, AudioTrack, SubtitleTrack } from "../types";
import { TrackManager } from "../core/TrackManager";
export interface NativeFallbackOptions {
    autoplay?: boolean;
    muted?: boolean;
    loop?: boolean;
    playsInline?: boolean;
    /**
     * Split-audio companion (`<source kind="audio">`): the video URL carries no
     * audio track, so a bare `<video src>` would play silently. Given this, the
     * wrapper drives a second `<audio>` element alongside and keeps the two in
     * sync — see the sync notes on `attachSplitAudio`.
     */
    audioUrl?: string;
}
/** An external subtitle file declared as a `<track>` child. */
export interface SubtitleSource {
    url: string;
    lang: string;
    label: string;
    format?: "vtt" | "srt";
}
/**
 * Minimal player-interface adapter backed by a raw <video> element, used for
 * fallback="native": when the WASM/WebCodecs pipeline can't READ a cross-origin
 * no-CORS source but the browser's own media element can render it opaquely, we
 * hand playback to this wrapper and set it as MoviElement's `player`, so Movi's
 * OWN control UI (play / seek / time / volume / fullscreen) drives the native
 * <video> instead of the browser's default controls.
 *
 * It intentionally does NOT use fetch/MSE (both would re-hit the same CORS wall
 * that broke the WASM path) — just `<video src>`, which the browser fetches
 * opaquely. Advanced features (quality/audio/subtitle tracks, HDR, VR, chapters,
 * stats) don't apply to a degraded native surface, so their methods are safe
 * no-ops / empty; returning empty track lists makes Movi auto-hide those menus.
 *
 * Structurally it implements the subset of MoviPlayer's public API that
 * MoviElement's controls + UI-poll loop actually call (see the enumeration in
 * engageNativeFallback). It is assigned to `this.player` via an `unknown` cast.
 */
export declare class NativeVideoWrapper extends EventEmitter<PlayerEventMap> {
    trackManager: TrackManager;
    private video;
    private state;
    private _destroyed;
    private _handlers;
    private audio;
    private _audioHandlers;
    private _syncTimer;
    private _playIntent;
    private _rate;
    private _volume;
    private _muted;
    private _resyncing;
    private activeSrc;
    private _publishedTrackStamp;
    private renditions;
    private autoQuality;
    private abrTimer;
    private abrSwitching;
    private abrSettleFrom;
    private abrLastStallAt;
    private abrPenalty;
    private audioLangs;
    private activeAudioLang;
    private subs;
    private activeSubLang;
    private subtitleOverlay;
    private trackEl;
    private textTrack;
    private _cueChangeHandler;
    private cueBlobUrl;
    private subDelay;
    private _appliedSubDelay;
    private _lastCueSignature;
    constructor(videoElement: HTMLVideoElement);
    private wireVideoEvents;
    /**
     * Drive a second `<audio>` element next to the `<video>` for split sources
     * (`<source kind="audio">`), which the browser can't do on its own — a media
     * element plays exactly one file, so the video-only stream would be silent.
     *
     * There's no common clock to slave them to (that's what the WASM pipeline
     * provides), so the two run independently and are held together by:
     *   • mirrored transport — play/pause/seek/rate/loop go to both;
     *   • a stall hold — whichever element goes "waiting" pauses the other, so a
     *     rebuffer on one side doesn't advance the other past it;
     *   • a drift watchdog on a timer — a small playbackRate trim for ordinary
     *     drift, a hard `currentTime` resync once it's past hearing it.
     *
     * A/V lock is looser than the WASM path's sample-accurate sync; it's the
     * degraded surface's "audio at all" rather than a replacement for it.
     */
    private attachSplitAudio;
    /** Start/resume the split audio at the video's position. */
    private resumeAudio;
    /**
     * Hard resync: seek the audio to `target` and HOLD the picture until the
     * element has actually landed there.
     *
     * Seeking the audio alone doesn't work — an `<audio>` seek costs a rebuffer,
     * and the video keeps running through it, so the pair settles a few hundred ms
     * apart again (measured ~350ms, right back at the resync threshold, where the
     * rate trim then claws at it forever). Pausing the video for the duration and
     * re-aligning it to where the audio actually landed converts that permanent
     * offset into one short hitch.
     */
    private syncAudioTo;
    /** Drift watchdog — trim small drift by rate, hard-resync large drift. */
    private syncTick;
    /** The rendition URL currently on screen (drives the menu's checkmark). */
    getActiveDashRendition(): string;
    /**
     * Take the quality ladder (MoviElement parsed it from the `<source>` children)
     * so "Auto" has something to switch between.
     */
    setDashRenditions(renditions: {
        url: string;
        id?: string;
        label?: string;
        height?: number;
    }[], activeUrl?: string): void;
    isAutoQuality(): boolean;
    /**
     * Turn adaptive switching on/off.
     *
     * The ABR here is BUFFER-based, not throughput-based: a native element
     * downloads opaquely, so there are no byte counters to measure a link speed
     * with (the WASM path's ABR sizes renditions off measured throughput). What
     * IS observable is how the buffer ahead of the playhead behaves — it grows
     * when the link outruns the bitrate, drains when it doesn't. So: sustained
     * healthy buffer → try one rung up; drained buffer or a stall → drop a rung.
     * Slower to settle than the real ABR, but it never guesses above what the
     * link is visibly sustaining.
     */
    setAutoQuality(enabled: boolean): void;
    private abrTick;
    /**
     * Playback stalled for data. That — not a buffer-level reading — is the
     * signal that the current rung is bigger than the link can carry, so drop one
     * and remember that the rung we were on stalled quickly, if it did.
     */
    private onAbrStall;
    private abrSwitchTo;
    /**
     * Publish the active rung as the one video track. MoviElement's UI poll reads
     * trackManager.getActiveVideoTrack()?.height to fire `qualitychange` (with the
     * auto flag), which is how a host like movi-tube learns what Auto settled on —
     * so the ladder has to surface through the same channel the WASM path uses.
     */
    private publishActiveVideoTrack;
    /**
     * Swap the video file in place for another rung of the premuxed ladder,
     * keeping the playhead, the play state and the split audio. MoviElement's
     * switchPremuxedQuality() prefers this over a reload precisely so the audio
     * and clock survive — here a reload would tear the whole fallback down and
     * re-run the WASM path that already failed.
     *
     * Auto IS offered here, but on a different signal: sizing renditions by
     * throughput needs byte counters a native element doesn't expose, so
     * setAutoQuality above adapts off the buffer instead.
     */
    switchVideoRenditionInPlace(url: string): Promise<boolean>;
    /** The declared audio-language tracks; MoviElement drives the menu. */
    setAudioLangTracks(tracks: {
        src: string;
        lang: string;
        label: string;
    }[]): void;
    getAudioLangs(): {
        lang: string;
        label: string;
        active: boolean;
    }[];
    /**
     * Switch the companion `<audio>` to another language. The WASM path rebuilds
     * its audio demuxer here; on this surface the companion is just a media
     * element, so it's a src swap plus the same aligned resync the drift watchdog
     * uses — position and play state carry over.
     */
    selectAudioLang(lang: string): Promise<boolean>;
    /** Hand over the declared `<track>` children; MoviElement drives the menu. */
    setExternalSubtitles(tracks: SubtitleSource[]): void;
    /** Where cues are painted — Movi's own overlay, so its styling controls apply. */
    setSubtitleOverlay(element: HTMLElement | null): void;
    getSubtitleLangs(): {
        lang: string;
        label: string;
        active: boolean;
    }[];
    /** VLC/mpv convention: positive = subtitles appear later. */
    setSubtitleDelay(seconds: number): void;
    getSubtitleDelay(): number;
    /**
     * Load + activate one of the declared tracks, or pass null to turn them off.
     *
     * The cues go through a real `<track kind="subtitles" mode="hidden">` on the
     * `<video>` — the same shape HLSPlayerWrapper/ShakaPlayerWrapper use for their
     * native surfaces. The browser owns parsing and cue scheduling (including
     * WebVTT markup and YouTube's inline karaoke timestamps, which a hand-rolled
     * parser flattens into one run-on blob) and we only paint whatever it reports
     * as active into Movi's overlay.
     */
    selectSubtitleLang(lang: string | null): Promise<boolean>;
    /** Paint the browser's currently-active cues into Movi's overlay. */
    private paintActiveCues;
    /**
     * Shift every cue by the current delay. VTTCue times are mutable, so the
     * offset is applied to the cue list itself and the browser keeps scheduling
     * them — no second timing loop of our own.
     */
    private applySubtitleDelayToCues;
    private clearCueDisplay;
    private detachTrackElement;
    private stopSyncLoop;
    private setState;
    /** Point the native element at the source and start loading. No fetch/MSE. */
    load(url: string, opts?: NativeFallbackOptions): Promise<void>;
    play(): Promise<void>;
    pause(): void;
    seek(time: number): Promise<void>;
    getState(): PlayerState;
    getCurrentTime(): number;
    getDuration(): number;
    setVolume(volume: number): void;
    getVolume(): number;
    setMuted(muted: boolean): void;
    isMuted(): boolean;
    setPlaybackRate(rate: number): void;
    getPlaybackRate(): number;
    getBufferEndTime(): number;
    getBufferStartTime(): number;
    getBufferedRangeStart(): number;
    getSeekableStartTime(): number;
    getSeekRangeStart(): number;
    getHLSVideoElement(): HTMLVideoElement;
    getVideoElement(): HTMLVideoElement;
    isLiveStream(): boolean;
    isLive(): boolean;
    isFileSource(): boolean;
    isStreamPlayback(): boolean;
    isFileSourcePreloadComplete(): boolean;
    isAudioOnly(): boolean;
    isPiPActive(): boolean;
    isSoftwareDecoding(): boolean;
    isHDRSupported(): boolean;
    isPlaybackIntended(): boolean;
    isLinearPlayback(): boolean;
    isAudioBlockedSuspended(): boolean;
    hasAudibleSource(): boolean;
    isNativeAudioActive(): boolean;
    usesNativeAudio(): boolean;
    wasAudioContextActivated(): boolean;
    getStableAudio(): boolean;
    getVideoTracks(): VideoTrack[];
    getAudioTracks(): AudioTrack[];
    getSubtitleTracks(): SubtitleTrack[];
    getChapters(): unknown[];
    getAllSubtitleCues(): unknown[];
    getVideoRotation(): number;
    getLiveEdge(): number;
    getNetworkSpeed(): number;
    getMetadataTitle(): string;
    getContentDispositionFilename(): string;
    getAudioOutputDevice(): string;
    getPreviewFrame(): Promise<Blob | null>;
    getCurrentVideoFrame(): ImageBitmap | null;
    getStats(): Record<string, string | number | boolean>;
    getRenderHealth(): null;
    selectVideoTrack(_id: number): void;
    selectAudioTrack(_id: number): boolean;
    selectSubtitleTrack(_id: number | null): Promise<boolean>;
    setStableAudio(_enabled: boolean): void;
    setHDREnabled(_enabled: boolean): void;
    setMaxBufferSize(_bytes: number): void;
    setLetterboxColor(_color: unknown): void;
    setSubtitleControlsPadding(_px: number): void;
    setPreviewsEnabled(_enabled: boolean): void;
    setFitMode(_mode: unknown): void;
    setAudioOutputDevice(_deviceId: string): void;
    setVideoRotation(_deg: number): void;
    rotateVideo(): void;
    resizeCanvas(_width: number, _height: number): void;
    useMuxedAudio(): void;
    setAudioOnly(_enabled: boolean): void;
    setVR(_enabled: boolean): void;
    setVRProjection(_projection: unknown): void;
    nudgeVR(_x: number, _y: number): void;
    zoomVR(_delta: number): void;
    suppressSeekSpinner(): void;
    seekToLive(): void;
    resetClockToStartForPoster(): void;
    renderPosterImage(): void;
    /**
     * MoviElement hands over the `<audio>` a previous MoviPlayer released across a
     * quality switch, expecting the next player to reuse it. This wrapper runs its
     * own companion, so the donated one has to be STOPPED rather than ignored:
     * it's detached from the DOM and still playing the previous source, and the
     * hand-off drops the last reference to it — a silent no-op here leaves the old
     * audio running under the new video with nothing able to reach it.
     */
    adoptNativeAudio(el: unknown): void;
    /** Stop and release the companion `<audio>` (nothing else can reach it). */
    private detachSplitAudio;
    /** Aborted by destroy(), so a subtitle fetch can't outlive the wrapper. */
    private readonly lifetimeAbort;
    destroy(): void;
}
//# sourceMappingURL=NativeVideoWrapper.d.ts.map