/**
 * MoviPlayer - Main public API for the streaming video library
 */
import type { PlayerConfig, SourceConfig, Track, PlayerState, PlayerEventMap, MediaInfo, VideoTrack, AudioTrack, SubtitleTrack } from "../types";
import { EventEmitter } from "../events/EventEmitter";
import { type SourceAdapter } from "../source";
import { TrackManager } from "./TrackManager";
import { LogLevel } from "../utils/Logger";
import { type VRView } from "../render/CanvasRenderer";
export declare class MoviPlayer extends EventEmitter<PlayerEventMap> {
    private static readonly _isMobileDevice;
    private config;
    private source;
    private cache;
    private demuxer;
    private nativeAudioEl;
    private _nativeAudioObjectUrl;
    private _nativeAudioLogicalUrl;
    private _nativeAudioAutoplayBlocked;
    private _audioTracks;
    private _activeAudioLang;
    private _subtitleTracks;
    private _activeSubtitleLang;
    private _externalSubCues;
    private _externalSubTimer;
    trackManager: TrackManager;
    private clock;
    private stateManager;
    private mediaInfo;
    private fileSize;
    private lastBufferedTime;
    /**
     * Enable/disable seek-bar scrub previews on an already-constructed player.
     * Lets the `thumb` attribute be toggled at runtime (or applied after `src`,
     * whose callback creates the player first) without recreating the player.
     * The thumbnail pipeline stays lazy — it only spins up on the first hover.
     */
    setPreviewsEnabled(enabled: boolean): void;
    private previewsAllowed;
    /** Proxy a stream wrapper's events + mirror its TrackManager onto the player. */
    private wireStreamWrapper;
    private videoDecoder;
    private audioDecoder;
    private subtitleDecoder;
    private videoRenderer;
    private prefetchedSubtitleStream;
    private prefetchInFlight;
    private coverArt;
    private streamWrapper;
    private thumbnailBindings;
    private thumbnailSource;
    private thumbnailRenderer;
    private thumbnailHDREnabled;
    private isPreviewGenerating;
    private audioRenderer;
    private previewInitPromise;
    private previewInitAttempts;
    private previewInitGaveUp;
    private disableAudio;
    private _audioOnly;
    private muted;
    private wasPlayingBeforeRebuffer;
    private _stallStartTime;
    private _bufferingEntryTime;
    private _playStartTime;
    private _primingAudio;
    private _decoderStuckSince;
    private _lastDesyncSeekTime;
    private animationFrameId;
    private backgroundIntervalId;
    private backgroundWorker;
    private isBackgrounded;
    private wakeLock;
    private seekingToKeyframe;
    private seekingToKeyframeStartTime;
    private static readonly KEYFRAME_SEEK_TIMEOUT;
    private seekCraSeen;
    private static readonly SEEK_IDR_WAIT_MS;
    private videoChainBrokenUntilKeyframe;
    private static readonly PREBUFFER_AUDIO_SECONDS;
    private static readonly PREBUFFER_VIDEO_FRAMES;
    private static readonly PREBUFFER_MAX_WALL_MS;
    private static readonly PREBUFFER_MAX_PACKETS;
    private seekTargetTime;
    private waitingForVideoSync;
    private pendingAudioPackets;
    private pendingPrebufferPackets;
    private justSeeked;
    private seekTime;
    private startTime;
    private seekKeyframeOffset;
    private static readonly POST_SEEK_THROTTLE_MS;
    private pauseBufferTimerId;
    private static readonly PAUSE_BUFFER_INTERVAL_MS;
    private static readonly PAUSE_BUFFER_MAX_PACKETS;
    private static readonly PAUSE_BUFFER_AUDIO_SECONDS;
    private static readonly PAUSE_BUFFER_VIDEO_FRAMES;
    constructor(config: PlayerConfig);
    /**
     * Load the media file
     */
    load(sourceConfig?: SourceConfig): Promise<void>;
    /**
     * Create source adapter from config
     */
    private createSource;
    /**
     * Configure decoders for active tracks
     */
    private configureDecoders;
    /**
     * Pre-read a small amount of media before reporting "ready" and stash the
     * packets for the normal demux loop to consume. On short videos the demux
     * burst can drain the file faster than the HTTP source delivers bytes,
     * tripping the stall detector the moment play() starts; reading ahead
     * gives the source layer more time to buffer bytes.
     *
     * We deliberately do NOT decode here — the video decoder's onFrame
     * callback drops frames whenever state !== "playing", and the audio
     * renderer starts AudioContext playback the moment samples arrive. Both
     * break if we decode during prebuffer.
     */
    /**
     * Native-audio-only playback (split-source data saver): audio-only mode AND a
     * separate <audio> track. There's no video pipeline to run, and the audio is
     * its own element, so the demuxer body is never read — only the header it
     * downloaded at open() — saving the video file's entire bandwidth on top of
     * the skipped decode. Drives playback straight off the <audio> element.
     */
    private nativeAudioOnlyPlayback;
    private prebuffer;
    /**
     * Start playback
     */
    play(): Promise<void>;
    /**
     * Play in native-audio-only mode (split-source data saver). No demuxer reads,
     * no decode loop — just the <audio> element + clock. Handles first play,
     * resume, and replay (rewind on ended). Autoplay-blocked stays paused (there's
     * no video to roll), with the centre play button as the resume affordance.
     */
    private playNativeAudioOnly;
    /**
     * Pause playback
     */
    pause(): void;
    /**
     * Flag to prevent concurrent async WASM operations
     */
    private demuxInFlight;
    private demuxInFlightStartTime;
    private static readonly DEMUX_TIMEOUT;
    private eofReached;
    private eofSince;
    /**
     * Internal handler for seek completion when first target frame is found.
     * Clears the seek flag, synchronizes clock, and transitions to final state.
     */
    private notifySeekCompletion;
    /**
     * Heavy lossless/complex software audio codecs (TrueHD/MLP, DTS/DCA) decode
     * sub-realtime for ~1-2s from a cold start. Every seek flushes the decoder,
     * so each post-seek resume is a cold start that needs the audio prime cushion
     * — not just the first play/replay. Hardware audio (AAC) and lightweight
     * software codecs (Opus/FLAC/AC-3/E-AC-3) decode faster than realtime even
     * cold and don't need it. (issue #11)
     */
    private activeAudioNeedsColdPrime;
    /**
     * Tell the demuxer to skip every audio track except the active one. A file
     * with a second, unused audio track (e.g. a dual-TrueHD source with ~933
     * packets/s PER track) otherwise floods the read path with packets the loop
     * immediately throws away — roughly doubling the reads needed per second. On
     * a slower engine (Safari pulls ~half the packets/s of Chromium) that starved
     * the ACTIVE audio below realtime and stalled every few seconds (issue #11).
     * AVDISCARD_ALL makes av_read_frame skip them internally so each read returns
     * a useful packet. Only audio streams are touched — video and subtitles keep
     * their demuxer defaults (subtitles are read on demand). Re-applied on every
     * audio-track switch so the newly-selected track is re-enabled.
     */
    private applyStreamDiscard;
    /**
     * Begin an audio prime: hold the AudioContext suspended (primeForBuffering,
     * which never issues a resume() so it can't drain/race), flush any pending
     * post-seek audio packets into the decoder so the cushion starts filling, and
     * flag _primingAudio so the buffering→resume gate waits for a real cushion
     * (2s) rather than the thin 0.1s default before resuming.
     */
    private beginAudioPrime;
    /**
     * Main Playback Loop
     */
    private processLoop;
    /**
     * Handle playback ended
     */
    private handleEnded;
    /**
     * Seek to timestamp
     */
    private seekSessionId;
    private seekArmedSessionId;
    private wasPlayingBeforeSeek;
    suppressSeekSpinner: boolean;
    seek(seconds: number, opts?: {
        suppressSpinner?: boolean;
        preservePlaying?: boolean;
    }): Promise<void>;
    /**
     * Check if seek target time falls within the already-buffered byte range.
     * Uses linear byte→time estimation (same as getBufferedTime).
     */
    private isSeekTargetBuffered;
    /**
     * Initialize WebGL context for thumbnail rendering
     */
    /**
     * Generates a preview frame for the given time using C-based FFmpeg software decoding.
     * Fast and doesn't block main playback.
     */
    /**
     * Generates a preview frame for the given time using C for demuxing and WebCodecs for decoding.
     */
    getPreviewFrame(time: number, view?: VRView | null): Promise<Blob | null>;
    /**
     * Generate timeline thumbnails at regular intervals
     * @param count Number of thumbnails to generate (default 8)
     * @param onProgress Callback for each generated thumbnail
     * @returns Array of { time, blob } objects
     */
    generateTimeline(count?: number, onProgress?: (index: number, total: number, blob: Blob, time: number) => void): Promise<Array<{
        time: number;
        blob: Blob;
    }>>;
    private initPreviewPipeline;
    private destroyPreviewPipeline;
    /**
     * Get all tracks
     */
    getTracks(): Track[];
    /**
     * Get video tracks
     */
    getVideoTracks(): VideoTrack[];
    /**
     * Get audio tracks
     */
    getAudioTracks(): AudioTrack[];
    /**
     * Get subtitle tracks
     */
    getSubtitleTracks(): SubtitleTrack[];
    /**
     * Select audio track
     */
    selectAudioTrack(trackId: number): boolean;
    /**
     * Route audio output to a specific device (AudioContext.setSinkId).
     * "" → system default. Returns false when unsupported / device gone.
     */
    setAudioOutputDevice(deviceId: string): Promise<boolean>;
    /** Current audio output device id ("" = system default). */
    getAudioOutputDevice(): string;
    /**
     * Select subtitle track
     */
    selectSubtitleTrack(trackId: number | null): Promise<boolean>;
    /**
     * Get current playback time
     */
    getCurrentTime(): number;
    /**
     * After a `postertime` seek has painted the poster frame on the canvas,
     * reset only the CLOCK/playhead bookkeeping back to the start — WITHOUT
     * flushing the decoder, re-seeking the demuxer, or clearing the renderer
     * queue. That keeps the poster frame (from ~postertime) visible on the
     * canvas while the seek bar/getCurrentTime() read 0, and lets the first
     * play() start cleanly from the beginning (play()'s first-play branch
     * re-seeks the demuxer to 0 itself). Pure time-math; touches no media state.
     */
    resetClockToStartForPoster(): void;
    /**
     * Get duration
     */
    getDuration(): number;
    /**
     * Get LRU cache statistics
     */
    getCacheStats(): {
        utilization: number;
        sizeBytes: number;
        maxSizeBytes: number;
        entryCount: number;
    };
    /**
     * Get cached time ranges for visualization
     * Converts cached byte ranges to time ranges
     * @returns Array of {start, end} time ranges in seconds
     */
    getCachedTimeRanges(): Array<{
        start: number;
        end: number;
    }>;
    /**
     * Get current state
     */
    getState(): PlayerState;
    /**
     * Intended playback state, independent of transient interruptions.
     *
     * The raw state flips to "buffering"/"seeking" while the user is still
     * mid-playback (network stall, internal seek), which would otherwise make
     * the UI's play/pause icon flicker to "play" even though the user never
     * paused. This returns true whenever playback is meant to be running —
     * actually "playing", or interrupted by a buffer/seek that we entered
     * from a playing state (tracked via wasPlayingBeforeRebuffer/Seek). Use
     * this to drive the play/pause icon so it stays stable through stalls.
     */
    isPlaybackIntended(): boolean;
    /**
     * Get media info
     */
    /**
     * Load an encrypted video source
     * Reconfigures the player with an EncryptedHttpSource
     */
    loadEncrypted(config: {
        videoUrl: string;
        tokenUrl: string;
        videoId: string;
        fingerprint: string;
        sessionToken: string;
        tokenRefreshInterval?: number;
        onAuthFailed?: (reason: string) => void;
    }): Promise<void>;
    getMediaInfo(): MediaInfo | null;
    getContentDispositionFilename(): string | null;
    getMetadataTitle(): string | null;
    /**
     * Get HLS video element (DRM mode) for direct DOM insertion
     */
    getHLSVideoElement(): HTMLVideoElement | null;
    /**
     * Get chapters from the media (empty array if none)
     */
    getChapters(): Array<{
        title: string;
        start: number;
        end: number;
    }>;
    resizeCanvas(width: number, height: number): void;
    /**
     * Set HDR enabled state
     */
    setHDREnabled(enabled: boolean): void;
    /**
     * Check if current media is HDR
     */
    isHDRSupported(): boolean;
    /**
     * Set subtitle overlay element for HTML-based subtitle rendering
     */
    setSubtitleOverlay(overlay: HTMLElement | null): void;
    /**
     * Set extra bottom padding for subtitles when controls are visible
     */
    setSubtitleControlsPadding(padding: number): void;
    /**
     * Rotate video 90 degrees clockwise
     */
    rotateVideo(): number;
    /**
     * The currently-displayed decoded VideoFrame, or null. Fallback capture
     * source for snapshots when the WebGL canvas reads back blank.
     */
    getCurrentVideoFrame(): VideoFrame | null;
    /**
     * Get current video rotation
     */
    getVideoRotation(): number;
    setVideoRotation(deg: number): void;
    setFitMode(mode: "contain" | "cover" | "fill" | "zoom" | "control"): void;
    setLetterboxColor(r: number, g: number, b: number): void;
    /** Enable/disable 360° equirectangular projection on the video renderer. */
    setVR360(enabled: boolean): void;
    isVR360Enabled(): boolean;
    /** Live 360° camera + projection snapshot for reprojecting seek-bar previews
     *  to the current view. Null when not in 360. */
    getVR360View(): VRView | null;
    /** Select the VR projection/layout: half = VR180, fisheye = equidistant
     *  fisheye, stereoSbs = side-by-side stereo (left eye), stereographic =
     *  little-planet. */
    setVRProjection(half: boolean, fisheye?: boolean, stereoSbs?: boolean, stereographic?: boolean): void;
    /** Pan the 360° camera by a pointer drag (CSS px) over a viewport of
     *  viewportPx CSS height. */
    nudgeVR360(dx: number, dy: number, viewportPx: number): void;
    /** Zoom the 360° camera (delta>0 zooms out, e.g. wheel deltaY). */
    zoomVR360(delta: number): void;
    /** Recentre the 360° camera. */
    resetVRView(): void;
    /** Paint a still poster image onto the canvas (so a custom `poster` shows in
     *  360° before playback, since a poster URL skips the initial decode). */
    renderPosterImage(image: CanvasImageSource): void;
    /**
     * Set playback rate
     */
    setPlaybackRate(rate: number): void;
    /**
     * Setup native <audio> element for separate audio source.
     * Shared by single audioSource and multi-language audioTracks.
     */
    /**
     * Wire the native <audio> element's media events to player state/time. These
     * only act in native-audio-only mode (split-source data saver) — where there's
     * no demux loop to emit timeUpdate / detect EOF — and are inert during normal
     * split-source playback, which the processLoop drives.
     */
    private wireNativeAudioEvents;
    private setupNativeAudio;
    /** Release the in-memory blob: URL backing a header-authenticated audio file. */
    private revokeNativeAudioObjectUrl;
    /**
     * Detach the native <audio> element from this player WITHOUT pausing it,
     * so it can be re-adopted by a successor instance during a quality switch.
     * Returns the element (or null) so callers can hand it to adoptNativeAudio
     * on the new player. Critical because creating a fresh Audio element after
     * a programmatic src swap loses the user-activation token and trips
     * browser autoplay policy on the way back up.
     */
    releaseNativeAudio(): HTMLAudioElement | null;
    /**
     * Adopt an existing <audio> element before init() runs, so setupNativeAudio
     * sees a populated nativeAudioEl and reuses it (instead of constructing a
     * brand-new — and unactivated — Audio).
     */
    adoptNativeAudio(el: HTMLAudioElement): void;
    /**
     * Get available audio language tracks (multi-language mode)
     */
    getAudioLangs(): {
        lang: string;
        label: string;
        active: boolean;
    }[];
    /**
     * Switch audio to an external language track (native <audio> element).
     * Disables WASM audio if it was active. Preserves position & playback.
     */
    selectAudioLang(lang: string): boolean;
    /**
     * Switch back to muxed (WASM) audio, disabling native <audio> element.
     * Called when user selects a demuxer audio track while external is active.
     */
    useMuxedAudio(): void;
    /** Check if native audio is currently active */
    isNativeAudioActive(): boolean;
    /** True whenever a native <audio> element is loaded (single split-source or multi-lang). */
    hasNativeAudio(): boolean;
    /**
     * True if any audio path is active that the user can mute / volume-control.
     * Covers muxed (WASM) tracks, split-source <audio>, and HLS streams whose
     * audio is muxed inside the native <video> element.
     */
    hasAudibleSource(): boolean;
    /**
     * True when audio plays through a native HTMLMediaElement — an adaptive
     * stream (HLS/DASH via the stream wrapper's <video>) or native split-source
     * audio — rather than the AudioContext. Such audio can't be boosted above
     * 100% (HTMLMediaElement.volume caps at [0,1]), so the volume UI caps at 100%.
     */
    usesNativeAudio(): boolean;
    /** True for a live (dynamic) adaptive stream — drives the LIVE indicator. */
    isLiveStream(): boolean;
    /** True when the active adaptive stream is audio-only (no video track). */
    isStreamAudioOnly(): boolean;
    /** Live-edge time of a live stream (seekable range end). */
    getLiveEdge(): number;
    /** Start of a live stream's seekable (DVR) window. */
    getSeekRangeStart(): number;
    /** Jump to the live edge of a live stream. */
    seekToLive(): void;
    /**
     * Get available external subtitle tracks
     */
    getSubtitleLangs(): {
        lang: string;
        label: string;
        active: boolean;
    }[];
    /**
     * Select an external subtitle track by language.
     * Fetches the VTT/SRT file, parses cues, and starts rendering.
     * Pass empty string or null to disable.
     */
    selectSubtitleLang(lang: string | null): Promise<boolean>;
    /** Parse VTT text into SubtitleCue[] */
    private parseVTT;
    /** Parse SRT text into SubtitleCue[] */
    private parseSRT;
    /** Start rendering external subtitle cues based on playback time */
    private startExternalSubtitles;
    /** Stop external subtitle rendering */
    private stopExternalSubtitles;
    /**
     * Get playback rate
     */
    getPlaybackRate(): number;
    /**
     * Set subtitle delay in seconds.
     * VLC/mpv convention: positive value = subtitles appear later than the
     * original cue timing, negative value = earlier. Useful when the subtitle
     * track is out of sync with the video due to different source releases or
     * frame-rate conversions.
     */
    setSubtitleDelay(seconds: number): void;
    /** Get current subtitle delay in seconds. */
    getSubtitleDelay(): number;
    /**
     * Return every cue for the active subtitle stream, scanning it via the
     * C-side prefetch path if we haven't already done so. Used by the cues
     * browser UI — gives the caller a stable list to render and seek into.
     * Resolves to an empty array when no subtitle is active, the active
     * track is bitmap-only (PGS), or scanning fails.
     */
    getAllSubtitleCues(): Promise<{
        start: number;
        end: number;
        text: string;
    }[]>;
    /**
     * Scan the active subtitle stream and seed the renderer with every cue.
     * No-op when the same stream has already been prefetched, when no
     * subtitle is selected, or when a prefetch is in flight. The demuxer is
     * left at EOF after the C-side scan, so we re-seek back to the current
     * playback position before returning.
     */
    private prefetchActiveSubtitleStream;
    /**
     * Set volume (0-1)
     */
    setVolume(volume: number): void;
    /**
     * Get volume (0-1)
     */
    getVolume(): number;
    /**
     * Set muted state
     */
    setMuted(muted: boolean): void;
    /**
     * Get muted state
     */
    getMuted(): boolean;
    /**
     * Enable/disable stable audio mode
     * Stable audio provides: smooth gain transitions, auto-recovery,
     * gap filling on underrun, starvation detection, and fade on seek/reset
     */
    setStableAudio(enabled: boolean): void;
    /**
     * Get stable audio mode state
     */
    getStableAudio(): boolean;
    /**
     * Get comprehensive player stats for "Stats for nerds" overlay
     */
    /**
     * Raw render-health numbers for the stutter-hint monitor — distinct from
     * getStats(), which formats display strings. framesPresented is cumulative
     * (resets to 0 on seek/reset), so callers must handle it going backwards.
     * Null when there's no video renderer (audio-only / adaptive streams).
     */
    getRenderHealth(): {
        framesPresented: number;
        sourceFps: number;
    } | null;
    getStats(): Record<string, string | number | boolean>;
    /**
     * Get current I/O throughput in bytes/sec (for graph)
     * Works for both network (HttpSource) and disk (FileSource)
     */
    getNetworkSpeed(): number;
    /**
     * Check if source is a local file
     */
    isFileSource(): boolean;
    /**
     * True when the active source has fallen back to linear (forward-only,
     * non-seekable) playback — server lacks HTTP Range support and the file is
     * too big to cache whole. Used by the UI as a backstop alongside the
     * "linearmode" event (in case the event fired before listeners attached).
     */
    isLinearPlayback(): boolean;
    /**
     * True when audio is blocked by the browser's autoplay policy — the
     * AudioContext is stuck suspended despite an unmuted play() because no
     * user gesture has unlocked it. play()'s promise resolves either way, so
     * the element polls this after autoplay to decide whether to fall back to
     * muted playback + a "Tap to unmute" pill.
     */
    isAudioBlockedSuspended(): boolean;
    /** True when audio-only (data-saver) mode is active. */
    isAudioOnly(): boolean;
    /**
     * Toggle audio-only (data-saver) mode at runtime. On the demuxer path the
     * processLoop stops decoding video (CPU saving) — re-enabling re-seeks to
     * recover a keyframe and resume video in sync. Adaptive streams drop/restore
     * video renditions via a reload (config.audioOnly), so this only flips the
     * flag for them; the caller (MoviElement) owns that reload.
     */
    setAudioOnly(enabled: boolean): void;
    /**
     * True when the active source is not a FileSource (gate inactive), or when
     * the FileSource's initial preload pass has settled.
     */
    isFileSourcePreloadComplete(): boolean;
    /**
     * Public accessor for the mobile-device flag (used by MoviElement to gate
     * UI behavior on mobile-only paths).
     */
    static isMobileDevice(): boolean;
    /**
     * Request WakeLock to prevent screen sleep
     */
    private requestWakeLock;
    /**
     * Re-acquire the screen wake lock if we should be holding one but aren't.
     * Called on the moments where the lock can quietly drop, or where a failed
     * first attempt gets a fresh chance: tab visibility changes and player
     * resizes (fullscreen / orientation / PiP transitions). Idempotent — no-op
     * when a lock is already held, playback isn't active, or the page is hidden.
     */
    private ensureWakeLock;
    /**
     * Handle network recovery — re-seek to current position to restart cleanly
     */
    private handleNetworkOnline;
    /**
     * Handle visibility change
     */
    /** Set by MoviElement when Document PiP is active */
    isPiPActive: boolean;
    private handleVisibilityChange;
    /**
     * Start background timer using Web Worker (Safari-safe, not throttled)
     */
    private startBackgroundTimer;
    /**
     * Stop background timer
     */
    private stopBackgroundTimer;
    /**
     * Start pause-time buffering: demux packets while paused so that
     * resume/seek within buffered area is near-instant (YouTube-like behavior).
     * Stashes packets into pendingPrebufferPackets without decoding.
     */
    private startPauseBuffering;
    private stopPauseBuffering;
    private pauseBufferTick;
    /**
     * Release WakeLock
     */
    private releaseWakeLock;
    /**
     * Get buffered time in seconds
     * Returns the furthest time position that has been buffered
     */
    getBufferedTime(): number;
    /**
     * Check if current source is HttpSource
     */
    isHttpSource(): boolean;
    /**
     * Tune the active source's prefetch window. Value is megabytes — the
     * target "buffer ahead of playback" the source should try to maintain.
     * Honored by HttpSource (adjusts its sliding-window cap) and by
     * EncryptedHttpSource (scales PREFETCH_HIGH/LOW_WATER + cache cap).
     * Other source types are silently ignored.
     *
     * Wired to the `buffersize` element attribute so consumers can tune
     * memory vs. seek responsiveness at deploy time without forking.
     */
    setMaxBufferSize(megabytes: number): void;
    /**
     * Get buffer start position in bytes (for HttpSource)
     * Returns -1 if not available or not HttpSource
     */
    getBufferStartBytes(): number;
    /**
     * Get buffer end position in bytes (for HttpSource)
     * Returns -1 if not available or not HttpSource
     */
    getBufferEndBytes(): number;
    /**
     * Get buffer start time in seconds (for HttpSource)
     * Converts buffer start bytes to time position using current read position as reference
     */
    getBufferStartTime(): number;
    /**
     * Lowest time a backward seek can SAFELY land in linear (non-range) playback.
     * The window starts at getBufferStartTime, but a seek's keyframe sits at a
     * lower byte than the linear time→byte estimate (GOP span + VBR), so seeking
     * right at the window edge usually reads just below it and fails. Pad the
     * start by a byte safety margin so the keyframe stays inside the RAM window.
     * Returns 0 for seekable (range-capable) or non-HTTP sources.
     */
    getSeekableStartTime(): number;
    /**
     * Get buffer end time in seconds (for HttpSource)
     * Same as getBufferedTime but more explicit
     */
    getBufferEndTime(): number;
    /**
     * Get the source adapter (for checking buffer status, etc.)
     */
    getSource(): SourceAdapter | null;
    /**
     * Set log level
     */
    static setLogLevel(level: LogLevel): void;
    /**
     * Get the video element renderer (for faststart conversion access)
     * Returns null if not using MSE mode
     */
    /**
     * Check if video decoding is falling back to software
     */
    isSoftwareDecoding(): boolean;
    /**
     * Embedded cover art for the loaded source, decoded into an ImageBitmap.
     * Null when the source has no attached_pic stream (regular video files,
     * audio files without artwork). Caller MUST NOT close() the bitmap — it
     * is owned by the player and released on destroy() / next load.
     */
    getCoverArt(): ImageBitmap | null;
    /**
     * Extract embedded cover art once at load and emit a "coverart" event.
     *
     * Runs entirely in a short-lived, isolated thumbnail-style WASM context
     * — the same isolated-demuxer machinery the seek-bar previews use — so
     * reading the artwork packet never moves the MAIN demuxer's file
     * position and therefore can't disturb playback or seeking. Done
     * exactly once (artwork is static), then the context is torn down.
     *
     * Deliberately does NOT surface attached_pic through a new C/WASM
     * StreamInfo field or export: that shifts the WASM memory layout and
     * trips a latent FFmpeg audio overflow into a production-only OOB (see
     * project memory "Album Art Crashes WASM"). Using only the existing
     * thumbnail read/packet exports keeps the WASM binary byte-identical.
     */
    private extractCoverArt;
    /**
     * Destroy player and release resources
     */
    destroy(): void;
}
//# sourceMappingURL=MoviPlayer.d.ts.map