/**
 * Custom HTML element for Movi Player
 * Usage: <movi-player src="video.mp4" autoplay muted></movi-player>
 *
 * Note: Custom element names must contain a hyphen per HTML spec.
 *
 * Supports native video element properties:
 * - src, autoplay, controls, loop, muted, playsinline, preload, poster
 * - width, height, crossorigin
 * - volume, playbackRate, currentTime, duration, paused, ended
 */
import type { RendererType } from "../types";
import type { SourceAdapter } from "../source/SourceAdapter";
import { type QoESink, type QoESession } from "../utils/QoE";
export declare class MoviElement extends HTMLElement {
    private canvas;
    private video;
    private subtitleOverlay;
    private _captionLive;
    private _captionObserver;
    private _lastCaptionText;
    private _qoe;
    private _qoeHeartbeat;
    private player;
    private isLoading;
    private _isUnsupported;
    private eventHandlers;
    private controlsContainer;
    private unmuteOverlay;
    private _userHasUnmuted;
    private brokenIndicator;
    private emptyStateIndicator;
    private coverArtOverlay;
    private coverArtCanvas;
    private coverArtBitmap;
    private _posterCoverBitmap;
    private _posterCoverUrl;
    private _posterCoverLoading;
    private _coverArtBgEl;
    private _coverArtBgUrl;
    private _coverArtResolved;
    private _lastStripDispatched;
    private controlsTimeout;
    private isOverControls;
    private isSeeking;
    private pendingSeekTarget;
    private _pendingSeek;
    private isDragging;
    private isTouchDragging;
    private touchStartX;
    private touchStartY;
    private touchStartTime;
    private gesturePerformed;
    private clickTimer;
    private lastSeekTime;
    private lastSeekSide;
    private cumulativeSeekAmount;
    private _seekChainTarget;
    private _contextMenuVisible;
    private _contextMenuJustClosed;
    private _menuPortalHost;
    private _menuPortalRoot;
    private _menuHome;
    private lastTouchTime;
    private _holdSpeedTimer;
    private _holdSpeedActive;
    private _rateBeforeHold;
    private _openMenuViaGear;
    private _mediaSessionReady;
    private _mediaSessionLastPos;
    private _mediaSessionArtworkUrl;
    private _nerdStatsVisible;
    private _currentManualRotation;
    private _timelineGenerating;
    private _timelineCancelled;
    private _timelineComplete;
    private _timelineNextIndex;
    private nerdStatsInterval;
    private networkSpeedHistory;
    private _stutterInterval;
    private _stutterLastPresented;
    private _stutterSeconds;
    private _stutterCooldown;
    private _stutterCooldownTimer;
    private static readonly GRAPH_MAX_SAMPLES;
    private _src;
    private _sourceAdapter;
    private _headers;
    private _audioOnly;
    private _audioSrc;
    private _videoQualities;
    private _audioTracks;
    private _subtitleTracks;
    private _autoplay;
    private _autoplayStarting;
    private _autoplayPendingVisible;
    private _autoMutedForAutoplay;
    private _hasEverPlayed;
    private _loopRestartInFlight;
    private _pendingPlay;
    private _preloadGateActive;
    private _resumeDialogPending;
    private _posterTime;
    private _generatedPosterUrl;
    private _posterGenId;
    private _controls;
    private _loop;
    private _muted;
    private _playsinline;
    private _preload;
    private _poster;
    private _volume;
    private _playbackRate;
    private _subtitleDelay;
    private _subtitleSettings;
    private _ambientMode;
    private _renderer;
    private _objectFit;
    private _currentFit;
    private _thumb;
    private _linearMode;
    private _hdr;
    private _theme;
    private _sw;
    private _swForcedForCurrentSource;
    private _suppressSwReload;
    private _fps;
    private _gesturefs;
    private _noHotkeys;
    private _startAt;
    private _fastSeek;
    private _doubleTap;
    private _themeColor;
    private _bufferSize;
    private _title;
    private _showTitle;
    private _resume;
    private _stableVolume;
    private _audioOutputDeviceId;
    private _audioOutputs;
    private _audioOutputsBound;
    private _vr360;
    private _vrPointerDown;
    private _vrMoved;
    private _vrLastX;
    private _vrLastY;
    private _vrPinchDist;
    private _aspectPinchDist;
    private _vrSuppressClick;
    private _vrPadDragging;
    private _encrypted;
    private _tokenUrl;
    private _videoUrl;
    private _videoId;
    private _resumeSaveInterval;
    private _posterSeekActive;
    private _titleAutoLoaded;
    private _resumeCheckedWithTitle;
    private _stripTitleAttr;
    private _lastDuration;
    private posterElement;
    private _ambientWrapper;
    private ambientWrapperElement;
    private _ambientRafId;
    private _lastAmbientSampleTime;
    private _lastRateChangeTime;
    private static readonly AMBIENT_RATE_CHANGE_COOLDOWN_MS;
    private _ambientSampleInterval;
    private currentAmbientColors;
    private _contextLostTime;
    private _contextLostPlaying;
    private _lastFrameSnapshot;
    private _snapshotPosterActive;
    private _snapshotPosterPrev;
    private _showSnapshotPoster;
    private _hideSnapshotPoster;
    private _onVisibilityChange;
    static get observedAttributes(): string[];
    constructor();
    private createContextMenu;
    private createControls;
    private setupControlHandlers;
    private seekFromEvent;
    private seekFromTouchEvent;
    /** Begin press-and-hold fast playback (2x). No-op unless actively playing, so
     * a long-press while paused doesn't silently change the saved rate. */
    private startHoldSpeed;
    /** End press-and-hold fast playback, restoring the pre-hold rate. */
    private stopHoldSpeed;
    private setupGestures;
    /**
     * 360° look-around for mouse + trackpad. Touch is handled inside
     * setupGestures (it already owns touchstart/move). These listeners no-op
     * unless 360° mode is active, and a drag past a few pixels suppresses the
     * trailing click so dragging never toggles play/pause.
     */
    private setupVRControls;
    /**
     * Enable/disable VR rendering and pick the format:
     *  - half: VR180 (front hemisphere) vs full 360°.
     *  - fisheye: equidistant fisheye vs equirectangular.
     *  - sbs: side-by-side stereo (render the left eye) vs mono.
     * Forwards to the player's renderer and flips the host class (for cursor +
     * touch-action CSS). There's no toggle button: VR turns on automatically for
     * sources we know are 360/180 (spherical metadata or the `vr` attribute), the
     * same way YouTube treats them.
     */
    setVR360(enabled: boolean, half?: boolean, fisheye?: boolean, sbs?: boolean, stereographic?: boolean): void;
    /**
     * When a custom/generated poster image is showing and 360° is on, draw the
     * poster onto the canvas through the equirectangular projection (so it looks
     * right, not flat-distorted) and hide the flat <img> overlay. No-op for the
     * decoded-frame poster path (seek/postertime) — that already paints in 360.
     */
    private renderVRPosterIfNeeded;
    /**
     * Resolve the VR format for the CURRENT source from spherical metadata
     * (track.projection) + the live `vr` attribute. Never carries the previous
     * clip's state over — switching to a normal clip drops back to flat unless
     * `vr` is still set.
     *
     * `vr` attribute tokens (space/comma separated), e.g. `vr="fisheye sbs"`:
     *   (bare) / 360 → full 360°; 180 → VR180; sbs / 3d → side-by-side stereo
     *   (left eye); fisheye → equidistant fisheye (implies 180).
     *
     * projection metadata: 0/undefined = none; 1 = equirectangular;
     * 3 = equirectangular-tile; 4 = half-equirectangular (VR180). Stereo/fisheye
     * aren't auto-surfaced, so those need the attribute.
     */
    private resolveVRMode;
    /** Apply the resolved VR format to the renderer (enable OR disable). */
    private detectAndApplyVR360;
    private setupKeyboardShortcuts;
    private setupContextMenu;
    private updateContextMenuContent;
    /**
     * Highlight the current fit as the active row in the aspect-ratio submenu, so
     * it reflects the live fit however it was last changed — context menu, the
     * bottom-controls aspect button, or the keyboard shortcut. Called each time
     * the fit submenu is shown: on hover (desktop, via showSubmenu) and on tap
     * (touch, via the action==="fit" branch). Kept OUT of updateContextMenuContent
     * (which runs on the main menu's open) to avoid touch-open side effects.
     */
    private syncFitSubmenuActive;
    private setupSubmenuHover;
    private toggleFullscreen;
    private _pipWindow;
    private restorePiPCanvas;
    private togglePiP;
    /** Tracks host-driven fullscreen so toggleFullscreen() and the
     *  movi-fullscreen-request event can reflect it correctly even when
     *  document.fullscreenElement is null. */
    private _hostFullscreen;
    /** CSS "fill the viewport" fallback used where the element Fullscreen API
     *  isn't available (iOS Safari only exposes it for <video>, and we render to
     *  a canvas). Not real fullscreen — no chrome hiding — but the player takes
     *  over the visible viewport. */
    private _pseudoFullscreen;
    private _prevBodyOverflow;
    /** True when the player is fullscreen by any route: native element FS, a
     *  host-driven FS, or the iOS pseudo-fullscreen fallback. */
    private isFullscreenActive;
    /** Whether the browser exposes the element Fullscreen API for this element
     *  (false on iOS Safari, which only fullscreens <video>). */
    private nativeFullscreenSupported;
    /** Re-evaluate on device rotation / viewport change while pseudo-fullscreen. */
    private _onPseudoFsResize;
    /**
     * Forced-landscape for the pseudo-fullscreen fallback: iOS won't rotate the
     * screen for us, so a landscape video on a portrait screen is turned 90° via
     * CSS (the .movi-pseudo-fs-rotate class) to fill it — matching what Chrome /
     * Android do with an orientation lock. Once the device itself is landscape
     * (window wider than tall) the rotation is dropped.
     */
    private updatePseudoFsRotation;
    /** Enter/leave the CSS viewport-fill fallback. */
    private setPseudoFullscreen;
    private updateFullscreenIcon;
    private updateFullscreenContextMenu;
    /**
     * On phones/tablets, rotate to match the video when entering fullscreen and
     * release the lock on exit. Wide clips lock landscape, tall clips portrait;
     * defaults to landscape (the common case) if dimensions aren't known. No-op on
     * desktop, audio-only, or where the Screen Orientation lock API is missing
     * (e.g. iOS Safari, which rejects programmatic lock — caught and ignored).
     */
    private applyFullscreenOrientation;
    private applyFullscreenUiState;
    /**
     * Public hook for hosts (VS Code extension, embedded apps) that take over
     * fullscreen via the cancelable `movi-fullscreen-request` event. Call this
     * whenever the host enters/exits its custom fullscreen so the player's
     * toolbar icon and right-click context menu reflect the correct state.
     */
    setHostFullscreen(active: boolean): void;
    private static readonly ASPECT_ICONS;
    private updateAspectRatioIcon;
    private static readonly TRACK_ICON_AUDIO;
    private static readonly TRACK_ICON_SUBTITLE;
    private static readonly TRACK_ICON_OFF;
    private static readonly TRACK_ICON_CHECK;
    private formatAudioBadge;
    private formatSubtitleBadge;
    private updateAudioTrackMenu;
    private updateQualityMenu;
    /**
     * Map a video height to its YouTube-style quality badge (HD/4K/8K) or
     * empty string when the resolution doesn't qualify.
     */
    private _heightBadge;
    /**
     * Paint or hide the small badge pill on the gear button itself so the
     * user can see the active quality tier at a glance — same convention
     * as YouTube's player.
     */
    private _updateQualityBtnBadge;
    /**
     * Render a quality menu for pre-muxed multi-source MP4s (no HLS manifest).
     * Driven by the cached `_videoQualities` list; switching just swaps the
     * active <source> URL and lets the existing src-change pipeline reload
     * the player while preserving currentTime / paused state.
     */
    private renderPremuxedQualityMenu;
    private _carryAudioEl;
    private _qualitySwitchInProgress;
    private _switchResumeTime;
    private _switchResumeDuration;
    /**
     * Swap the active video source and resume playback at the same position.
     * The src setter pipeline tears down the player; we re-seek once metadata
     * is available on the new instance.
     */
    private switchPremuxedQuality;
    private getMaxAllowedRate;
    /** Volume ceiling: 200% normally (boost via AudioContext gain), but 100% when
     *  audio plays through a native element (adaptive stream / native split-source)
     *  which can't boost — so the UI doesn't promise a boost that won't happen. */
    private getMaxVolume;
    /** Re-apply the volume ceiling to the slider + current volume when the audio
     *  path changes (source load, audio-track switch between muxed and native). */
    private updateVolumeCap;
    /**
     * Start sampling render health once per second to detect sustained stutter
     * (decoder can't keep up above 1x on a heavy source → dropped video frames,
     * smooth audio). Runs only during active playback; cheap (reads a couple of
     * numbers). Idempotent.
     */
    private startStutterMonitor;
    private stopStutterMonitor;
    /**
     * Clear the stutter-hint cooldown so the "play at 1x" warning can fire again.
     * Called on every playback-rate change — each new speed the user picks gets a
     * fresh chance to warn if it stutters (instead of showing only once per
     * source). The 3-second sustained requirement still prevents instant spam.
     */
    private resetStutterHint;
    /** One stutter sample: compare presented FPS to the smooth-playback baseline. */
    private sampleStutter;
    /**
     * Show On-Screen Display (OSD) notification
     */
    private osdTimeout;
    private showOSD;
    private static readonly SUBTITLE_SETTINGS_STORAGE_KEY;
    /**
     * Returns the kind of subtitle currently active so the customize
     * panel can show only the options that apply.
     *
     *   - "vtt"   → WebVTT (karaoke-paced from YouTube proxy etc): all
     *               text styling options apply, INCLUDING the backdrop.
     *   - "text"  → SRT/ASS/SSA/TTML or muxed text subs: size/color/edge
     *               and shift apply; backdrop doesn't (it's gated to VTT
     *               in CSS).
     *   - "image" → PGS/DVD/DVB or other muxed image subs: only the
     *               subtitle-shift control applies; styling is baked
     *               into the bitmap.
     *   - null    → no subtitle selected → no customize gear shown.
     */
    private getActiveSubtitleKind;
    private static readonly SUBTITLE_EDGE_STYLES;
    private static readonly SUBTITLE_COLOR_PALETTE;
    private loadSubtitleSettings;
    private saveSubtitleSettings;
    private applySubtitleSettings;
    /**
     * Apply one of the public subtitle-customize attributes onto
     * _subtitleSettings. Returns true if the attribute name matched
     * (caller can decide whether to call applySubtitleSettings()).
     *
     *   subtitlesize="150"      (50–200, treated as %; also accepts 1.5)
     *   subtitlecolor="#FFEB3B" (any CSS color hex, 3 or 6 digits)
     *   subtitlebg="50"         (0–100, treated as %; also accepts 0.5)
     *   subtitleedge="outline"  (none | shadow | outline | raised)
     */
    private applySubtitleAttribute;
    /**
     * Pick a backdrop RGB that contrasts with the text color so the cue
     * stays readable regardless of the user's color choice. Dark text on
     * dark backdrop (or vice versa) would render the subtitle invisible.
     */
    private static contrastBackdropRgb;
    private renderSubtitleCustomizePanel;
    private wireSubtitleCustomizePanel;
    private _showingSubtitleCustomize;
    private _cuesPanelCues;
    private _cuesPanelFiltered;
    private _cuesPanelQuery;
    private _cuesPanelActiveIdx;
    private _cuesPanelTimeUpdateUnsub;
    private _cuesPanelEscHandler;
    private openCuesPanel;
    private closeCuesPanel;
    private renderCuesPanel;
    private updateCuesPanelActive;
    private updateSubtitleTrackMenu;
    /**
     * True when an actual media source is loaded (plain src, a caller-supplied
     * SourceAdapter, or the encrypted video URL). Used to gate the controls
     * auto-hide — in the empty "No Video" state we keep the bar pinned.
     */
    private hasMediaSource;
    /**
     * Switch the UI into linear (forward-only) playback: the source has no Range
     * support and is too big to cache, so seeking is impossible. Hide the
     * timeline and disable seek + thumbnail previews via the `movi-linear` host
     * class. Idempotent — safe to call from both the event and the loadEnd
     * backstop.
     */
    /**
     * In linear (non-seekable-source) playback only the bytes currently in the
     * RAM window are reachable, so clamp any seek target to the buffered time
     * range [bufferStart, bufferEnd]. A small margin keeps the (approximate,
     * linear byte→time) clamp safely inside the window so the keyframe for the
     * target is actually present. Returns the time unchanged when not linear.
     */
    private clampToBufferedWindow;
    private enterLinearMode;
    /**
     * Mirror "is the controls bar currently taking up bottom space?" onto a
     * plain host class so the empty-state placeholder can re-center reliably.
     * The old approach keyed off `:host:has(.movi-controls-hidden)` /
     * `:host(:not([controls]))`, but `:has()` is flaky in Safari/Firefox (and
     * an unsupported selector in a comma list drops the WHOLE rule), which left
     * the "No Video" text stuck off-center there. `:host(.movi-bar-collapsed)`
     * is universally supported, so the centering works in every browser.
     */
    private syncBarCollapsedClass;
    private showControls;
    /**
     * Close every bottom-controls dropdown (speed, audio, subtitle,
     * quality) plus the context menu. Used to enforce one-menu-at-a-time
     * and to swallow a player-area click when a menu is open.
     * Pass a `keep` selector to skip closing the menu currently being
     * opened, otherwise everything goes away.
     */
    private closeAllBottomMenus;
    /**
     * Toggle a bottom-bar dropdown with a pop-in / pop-out animation.
     * Inline display:none stays the truly-hidden terminal state so the
     * existing dom-presence checks elsewhere keep working — we just clear
     * it on open, run the CSS transition, and restore it once the exit
     * transition finishes.
     */
    private setBottomMenuOpen;
    /**
     * Strip-mode menu positioning: place the menu just below the anchor
     * button using viewport-relative position:fixed. The strip CSS drops
     * the host's `contain: paint` + `container-type` so fixed coords are
     * actually viewport-relative again (default behaviour) and paint
     * extends outside the 56px strip box.
     */
    private applyStripFixedMenuPosition;
    private isBottomMenuOpen;
    /**
     * Restart the subtle fade-in on the subtitle dropdown's content area so
     * toggling between the track list and the customize panel feels like a
     * crossfade rather than a snap. Removing + re-adding the class with a
     * forced reflow restarts the CSS animation; without the reflow the
     * browser deduplicates the class change and the animation never replays.
     */
    private flashSubtitleListFade;
    /**
     * Hide the seek OSD pill immediately and reset the chain state.
     * Used when a relative-seek press lands on the boundary (delta 0)
     * so the previous chain's "- 25s" cue doesn't keep reading like the
     * playhead has gone past zero — the cue had served its purpose
     * before the boundary press, but holding it on screen with no
     * forward movement is what the user sees as "minus".
     */
    private dismissSeekOSD;
    /**
     * Run a relative seek (button / key / double-tap) and surface it
     * through the OSD. The OSD label tracks the *actual* delta between
     * the pre-seek time and the clamped target — so pressing left at 5s
     * with a 10s step shows "- 5s", not "- 10s", and a follow-up press
     * at 0s suppresses the OSD entirely instead of accumulating phantom
     * seconds the playhead never travelled. Same on the duration end.
     *
     * For rapid chained presses we anchor "before" on the previous
     * target rather than the (still-stale) playback time, so the cue
     * tracks where the playhead is *headed* even mid-seek.
     */
    private performRelativeSeek;
    /**
     * The Timeline panel (opened with "T") sits just above the controls bar but
     * is a shadow-root sibling of the controls container, so hovering it never
     * sets isOverControls — without this the 3s inactivity auto-hide fires while
     * the user scrubs the storyboard. Gates ONLY the inactivity timer (in
     * showControls) so the bar stays put while the timeline is open; the
     * cursor-left-the-controls / cursor-left-the-player hides keep their normal
     * behavior. Kept out of isAnyMenuOpen(), which also drives click-to-close.
     */
    private isTimelineOpen;
    /** True when the engine can route output to a chosen device. */
    private static audioSinkSupported;
    /** Running inside a (possibly cross-origin) iframe. */
    private isEmbeddedIframe;
    /**
     * Whether a Permissions-Policy feature (e.g. "fullscreen",
     * "picture-in-picture", "speaker-selection") is allowed in this document.
     * At the top level features are allowed by default; inside an iframe they
     * must be delegated via the `allow` attribute. Uses the (Chromium) feature
     * policy API when present and defaults to allowed when it isn't — the
     * features we gate this way are all Chromium-only, so a missing API means a
     * browser that wouldn't expose the capability regardless.
     */
    private featureAllowed;
    /**
     * List the available audio output devices. Labels may be empty until the
     * page has been granted audio-device access (the desktop app has it; a bare
     * web embed may show blank labels until a getUserMedia prompt is accepted).
     */
    getAudioOutputs(): Promise<Array<{
        deviceId: string;
        label: string;
    }>>;
    /** Current audio output device id ("" = system default). */
    getAudioOutput(): string;
    /**
     * Route audio to a device. Accepts a concrete deviceId, or — for
     * convenience — a label substring (case-insensitive); "" / "default" →
     * the system default. Returns false when unsupported or the device is gone.
     */
    setAudioOutput(deviceId: string): Promise<boolean>;
    /** Resolve a deviceId or a label substring to a concrete deviceId. */
    private resolveAudioOutputId;
    /** Apply the `audiooutput` attribute once the player exists. */
    private applyAudioOutput;
    /**
     * Cache the device list, re-applying any pending attribute selection and
     * re-rendering the menu. Bound once to `devicechange` so hot-plugging a
     * headset updates the list live.
     */
    private setupAudioOutputs;
    /** Refresh the cached device list and re-render the menu if it's open. */
    private refreshAudioOutputs;
    /**
     * Browsers only expose output device ids/labels after the page holds audio
     * permission. When the user clicks "Show output devices…" in the (otherwise
     * locked) submenu, request mic permission — the universal unlock, same as
     * Google Meet — then re-render with the now-visible devices and re-open the
     * submenu. Triggered from an explicit click so the prompt has a user
     * gesture. No-op in the desktop app (devices already visible).
     */
    private unlockAudioOutputs;
    /** (Re)build the Audio Output submenu from the cached device list. */
    private updateAudioOutputMenu;
    private isAnyMenuOpen;
    private hideControls;
    private updateControlsVisibility;
    private startUIUpdates;
    private addStyles;
    private handleContextLost;
    private handleContextRestored;
    connectedCallback(): void;
    disconnectedCallback(): void;
    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
    private _lastCanvasW;
    private _lastCanvasH;
    private updateCanvasSize;
    /**
     * Toggle the LIVE indicator for live (dynamic) adaptive streams. Adds the
     * `.movi-live` host class (CSS shows the badge + hides the meaningless
     * wall-clock duration), and marks the badge `.behind` when the viewer has
     * scrubbed back into the DVR window so it reads grey instead of pulsing red.
     * Cheap + idempotent — safe to call on every timeupdate.
     */
    private updateLiveState;
    /**
     * Paint embedded cover art (audio-only sources). Shows when:
     *   - the player has emitted a coverart bitmap, AND
     *   - there is no active video track (a real video would mask this anyway,
     *     but hiding upfront keeps unnecessary canvas work off the critical
     *     path for plain video files that happen to ship a thumbnail track).
     *
     * Layout: blurred fill of the artwork stretched over the full surface,
     * with the sharp artwork centred and sized to ~60% of the smaller host
     * dimension. Matches the YouTube Music / Apple Music aesthetic.
     */
    /**
     * For an audio-only source with a `poster` URL and no embedded album art,
     * lazily load the poster into an ImageBitmap so updateCoverArtOverlay can
     * paint it as album art (via the same blurred-backdrop cover-art canvas).
     * Idempotent: loads once per URL, clears when no longer applicable (source
     * became video, poster cleared, or embedded art arrived). Re-runs
     * updateCoverArtOverlay once the bitmap is ready.
     */
    private ensurePosterCoverArt;
    /** Downscale an album-art bitmap to a tiny JPEG data URL for the blurred
     *  backdrop. The backdrop is blurred to 40px, so ~96px is indistinguishable
     *  from full-res while keeping the URL small and the draw cheap. */
    private makeCoverArtBgUrl;
    private updateCoverArtOverlay;
    /**
     * After an autoplay attempt, detect the browser blocking audio-with-sound
     * (AudioContext stuck suspended) and fall back to muted playback so the
     * video keeps rolling, then surface the "Tap to unmute" pill. No-op when
     * the user already asked for muted, has deliberately unmuted this session,
     * there's no audible source, or audio actually started. The AudioContext
     * resume() kicked off inside play() is async, so we give it a couple of
     * animation frames to settle before reading the state.
     */
    /**
     * Kick off autoplay: suppress the centre play overlay through the startup
     * window, call play(), and run the muted-autoplay fallback. Shared by the
     * initial load and the deferred (tab-was-hidden) path in _onVisibilityChange.
     */
    private _startAutoplay;
    private maybeFallbackToMutedAutoplay;
    private updateMuted;
    /**
     * Show a "Tap to unmute" pill when the player is set up to autoplay
     * muted (browsers block autoplay-with-sound) and the user has asked
     * for controls. Hides as soon as the player isn't muted, one of the
     * prerequisite attributes drops, or audio-track discovery proves
     * there's no audio to surface — reusing the same hasAudibleSource()
     * check that gates the volume button (see updateAudioTrackMenu).
     * Before the player is initialized hasAudibleSource() can't be
     * answered, so we optimistically show the pill on attrs alone and
     * let updateAudioTrackMenu re-call this once tracks are known.
     */
    private updateUnmuteOverlay;
    private updateVolume;
    private updateSubtitleDelay;
    private updatePlaybackRate;
    private updateFitMode;
    private posterObjectFit;
    /**
     * Automatically create and initialize MoviPlayer
     */
    private initializePlayer;
    /**
     * Set up event handlers for the player
     */
    private setupEventHandlers;
    /**
     * Load the video source (automatic when src is set)
     */
    load(): Promise<void>;
    /**
     * Play the video
     */
    play(): Promise<void>;
    /**
     * Pause the video
     */
    pause(): void;
    /**
     * Register OS Media Session action handlers once. These surface play/pause,
     * skip-back/forward and scrub controls on the lock screen, notification
     * shade, media-key hardware (headset / keyboard) and Bluetooth remotes, and
     * route them back into the player. Registered once (guarded); the handlers
     * close over `this` and read `this.player` lazily, so they keep working
     * across source swaps that recreate the internal player.
     */
    private setupMediaSession;
    /**
     * Refresh the lock-screen metadata (title + poster artwork) and the
     * playing/paused indicator. Cheap to call on every state/load change.
     */
    private updateMediaSession;
    /**
     * Capture the current decoded frame off the WebGL canvas as a data: URL for
     * use as OS lock-screen artwork. A source with no explicit `poster` paints
     * its poster/first frame straight onto the canvas (via the postertime /
     * frame-0 seek) and never turns it into a URL — this is how that same still
     * becomes the lock-screen thumbnail. Skipped when an explicit poster/cover
     * URL already wins the artwork chain, or once a snapshot is already stored.
     * The canvas uses preserveDrawingBuffer, so toDataURL returns the real frame.
     * Cheap one-shot (mirrors the proven _lastFrameSnapshot capture) and only
     * runs at moments a real frame is guaranteed on-canvas (poster seek / play).
     */
    private captureMediaSessionArtwork;
    /**
     * Cheap synchronous test for whether the display canvas is still blank/black
     * (renderer hasn't painted a real frame yet). Downscales the WebGL canvas to
     * 16×16 on a throwaway 2D context and checks luminance spread — a near-flat
     * result means no frame content. Used to defer artwork capture until a real
     * frame lands. Returns true (treat as blank) on any failure, so capture just
     * retries rather than storing garbage.
     */
    private isCanvasBlank;
    /**
     * Use an extracted cover-art / thumbnail bitmap as the OS lock-screen artwork.
     * The player surfaces embedded album art (and other thumbnails) asynchronously
     * — after the initial metadata is seeded — so this refreshes the Media Session
     * once it lands, instead of the lock screen being stuck with no image. The
     * bitmap is rasterised to a bounded (≤512px) data: URL. Real art is
     * authoritative, so it overwrites any earlier canvas-snapshot fallback; an
     * explicit `poster`/cover URL still wins the chain in updateMediaSession().
     */
    private setMediaSessionArtworkFromBitmap;
    /** Best-effort MIME guess for poster artwork from its URL/extension. */
    private artworkMime;
    /**
     * Push the current playhead / duration / rate into the OS scrubber. Guarded
     * against live streams (Infinity), un-loaded state (NaN/0) and out-of-range
     * positions, which would otherwise make setPositionState throw.
     */
    private updateMediaSessionPosition;
    /**
     * Tear down the internal player and reset transient UI (time, title,
     * subtitles, timeline) back to the initial, no-source state. Called
     * internally on every src change so the next source starts clean. Safe to
     * call when nothing is loaded.
     *
     * Note: we deliberately do NOT touch the canvas or the native video
     * element — the canvas owns a WebGL2 context that the next renderer reuses,
     * and resetting the <video> can interfere with the DRM/HLS path.
     */
    dispose(): void;
    get theme(): "dark" | "light";
    set theme(value: "dark" | "light");
    /**
     * Get the internal canvas element
     */
    getCanvas(): HTMLCanvasElement;
    private updatePlayPauseIcon;
    private updateTimeDisplay;
    /**
     * Update the seek slider's ARIA so screen readers announce the position as a
     * real slider ("1:23 of 4:56"), not a bare number. Driven off timeUpdate so
     * it stays current even while the visual chrome is auto-hidden.
     */
    private updateSeekAria;
    /** Push the visible caption's text into the off-screen aria-live region so
     *  screen readers announce it. Deduped so identical re-renders stay quiet. */
    private mirrorCaption;
    private startQoeHeartbeat;
    private stopQoeHeartbeat;
    /** Register a QoE analytics sink; returns an unsubscribe fn. Every event is
     *  also dispatched as a `movi-qoe` CustomEvent. */
    addQoeSink(sink: QoESink): () => void;
    removeQoeSink(sink: QoESink): void;
    /** POST every QoE event to `url` via sendBeacon — shorthand for
     *  addQoeSink(beaconSink(url)). Returns an unsubscribe fn. */
    setAnalyticsBeacon(url: string): () => void;
    /** A rolled-up snapshot of the current QoE session. */
    getQoeSession(): QoESession;
    /**
     * Render chapter markers on the progress bar (YouTube-style)
     */
    private renderChapterMarkers;
    /**
     * Convert a 0..1 seek-bar fraction to a media time. For live streams the bar
     * spans the seekable DVR window [seekStart .. liveEdge], so the fraction maps
     * into that window; for VOD it's the usual 0..duration.
     */
    private barFractionToTime;
    private updateProgressBar;
    private updateVolumeIcon;
    private updateLoadingIndicator;
    private formatTime;
    private handleUnsupportedVideo;
    /**
     * Check if required security headers (COOP/COEP) are present
     * These headers are required for SharedArrayBuffer support (needed by FFmpeg)
     */
    private checkSecurityHeaders;
    /**
     * Enable software decoding and reload the video
     */
    private enableSoftwareDecoding;
    private updateControlsState;
    private updateAmbientWrapperElement;
    private updateAmbientMode;
    private startAmbientColorSampling;
    private stopAmbientColorSampling;
    private sampleCanvasColors;
    private updateAmbientBackground;
    get src(): string | File | null;
    /**
     * Separate audio source URL (for split video+audio files)
     */
    get audioSrc(): string | null;
    set audioSrc(value: string | null);
    /**
     * Get available audio language tracks
     */
    getAudioLangs(): {
        lang: string;
        label: string;
        active: boolean;
    }[];
    /**
     * Switch audio to a different language
     */
    selectAudioLang(lang: string): boolean;
    /**
     * Get available external subtitle tracks
     */
    getSubtitleLangs(): {
        lang: string;
        label: string;
        active: boolean;
    }[];
    /**
     * Select an external subtitle track by language (null to disable)
     */
    selectSubtitleLang(lang: string | null): Promise<boolean>;
    set src(value: string | File | null);
    /**
     * Set a File object as the source (convenience method)
     */
    setFile(file: File | null): void;
    /**
     * Custom SourceAdapter — feeds bytes from any protocol (WebSocket, WebRTC
     * data channel, IndexedDB, custom encryption, etc.) without writing a
     * SourceConfig branch. Set to `null` to clear and go back to `src`.
     *
     * Usage:
     * ```ts
     *   const element = document.querySelector('movi-player');
     *   element.sourceAdapter = new MyWebSocketSource(url);
     * ```
     *
     * Clearing src + setting adapter is mutually exclusive — the adapter wins.
     */
    get sourceAdapter(): SourceAdapter | null;
    set sourceAdapter(adapter: SourceAdapter | null);
    /**
     * Convenience method mirroring `setFile()` — same effect as assigning to
     * the `sourceAdapter` property.
     */
    setSourceAdapter(adapter: SourceAdapter | null): void;
    /**
     * Custom HTTP headers sent with every media network request — the adaptive
     * manifest (.mpd/.m3u8) and all of its segments, plus progressive downloads.
     * Use for auth tokens, signed headers, etc. The object form is the
     * programmatic counterpart to the JSON `headers` attribute; objects can't go
     * through attributes, so set non-trivial header maps via this property.
     *
     *   player.headers = { Authorization: "Bearer <token>" };
     */
    get headers(): Record<string, string> | null;
    set headers(value: Record<string, string> | null);
    /**
     * Audio-only (data-saver) mode. When true the player skips video decoding to
     * save CPU and, for adaptive streams (HLS/DASH), fetches only audio
     * renditions to save bandwidth; the UI shows the album-art / strip surface.
     * Toggle via this property or the `audioonly` attribute.
     *
     *   player.audioOnly = true;  // data saver on
     */
    get audioOnly(): boolean;
    set audioOnly(value: boolean);
    /**
     * Apply an audio-only toggle to the live player. Adaptive streams change what
     * gets downloaded (Shaka ignores video at manifest-parse time), so they
     * reload; the demuxer path flips video decode on/off in place.
     */
    private applyAudioOnly;
    /**
     * Video.js-style source API
     *
     * Usage:
     *   // Single source as string
     *   player.source('video.mp4');
     *
     *   // Single source as object
     *   player.source({ src: 'video.mp4', type: 'video/mp4' });
     *
     *   // Multiple sources (first playable source wins)
     *   player.source([
     *     { src: 'video.mp4', type: 'video/mp4' },
     *     { src: 'video.webm', type: 'video/webm' },
     *   ]);
     *
     *   // Separate video + audio (DASH-style split)
     *   player.source({
     *     video: { src: 'video-only.mp4', type: 'video/mp4' },
     *     audio: { src: 'audio.m4a', type: 'audio/mp4' },
     *   });
     *
     *   // Multi-language audio
     *   player.source({
     *     video: { src: 'video.mp4', type: 'video/mp4' },
     *     audio: [
     *       { src: 'en.m4a', type: 'audio/mp4', lang: 'en', label: 'English' },
     *       { src: 'hi.m4a', type: 'audio/mp4', lang: 'hi', label: 'Hindi' },
     *     ],
     *   });
     *
     *   // Get current source
     *   const current = player.source();
     */
    source(value?: string | {
        src: string;
        type?: string;
    } | {
        src: string;
        type?: string;
    }[] | {
        video: {
            src: string;
            type?: string;
        };
        audio?: {
            src: string;
            type?: string;
        } | {
            src: string;
            type?: string;
            lang: string;
            label: string;
        }[];
        subtitles?: {
            src: string;
            lang: string;
            label: string;
            format?: string;
        }[];
    }): {
        src: string | File | null;
        type: string;
        audioSrc?: string | null;
    } | void;
    /**
     * Pick the first source whose MIME type the browser can play.
     * Falls back to null if none are supported.
     */
    private pickSource;
    /**
     * Guess MIME type from a URL string extension.
     */
    private guessMediaType;
    /**
     * Load an encrypted video source (programmatic API)
     *
     * Usage:
     *   const player = document.querySelector('movi-player');
     *   player.loadEncrypted({
     *     videoUrl: '/api/video',
     *     tokenUrl: '/api/token',
     *     videoId: 'my-video',
     *     fingerprint: await generateFingerprint(),
     *     sessionToken: 'jwt-token',
     *   });
     */
    loadEncrypted(config: {
        videoUrl: string;
        tokenUrl: string;
        videoId: string;
        fingerprint: string;
        sessionToken: string;
        tokenRefreshInterval?: number;
        onAuthFailed?: (reason: string) => void;
    }): Promise<void>;
    get autoplay(): boolean;
    set autoplay(value: boolean);
    get controls(): boolean;
    set controls(value: boolean);
    get loop(): boolean;
    set loop(value: boolean);
    /**
     * The root the context menu currently lives in. On desktop the menu portals
     * to a body-level shadow root while open, so its items are NOT in this.shadowRoot
     * at that moment — a toggle-state updater querying the shadow root would find
     * nothing and silently no-op (the reason menu toggles didn't reflect their new
     * state after a click). Query menu items through this so they're found whether
     * the menu is portaled or still home in the shadow root.
     */
    private contextMenuRoot;
    private updateLoopUI;
    private updateAmbientUI;
    private updateStableAudioUI;
    /**
     * Toggle nerd stats overlay
     */
    private toggleNerdStats;
    /**
     * Update nerd stats content and network graph
     */
    private updateNerdStats;
    /**
     * Draw network throughput graph on canvas
     */
    private drawNetworkGraph;
    /**
     * Reset timeline panel (clear thumbnails, hide panel)
     */
    /**
     * Apply rotation transform + margin to a seek thumbnail image
     */
    private applyThumbnailRotation;
    /**
     * Sync thumbnail and timeline rotation with video rotation
     */
    private syncThumbnailRotation;
    /**
     * Show resume dialog if a saved position exists and we're not mid-context-
     * loss recovery. Centralized so the mobile 4K+ preload gate can hold it
     * back and replay it after preload settles.
     */
    private maybeShowResumeDialog;
    /**
     * Show resume dialog with saved position
     */
    private showResumeDialog;
    /**
     * Get a unique key for the current source (for localStorage)
     */
    private getResumeKey;
    /**
     * Get saved resume position from localStorage
     */
    private getResumePosition;
    /**
     * Save current position to localStorage
     */
    private saveResumePosition;
    /**
     * Start periodically saving playback position
     */
    private startResumeSaving;
    /**
     * Stop saving playback position
     */
    private stopResumeSaving;
    /**
     * Clear saved position for current source
     */
    private clearResumePosition;
    private resetTimeline;
    /**
     * Toggle timeline panel visibility
     */
    private toggleTimeline;
    /**
     * Generate timeline thumbnail strip
     */
    private generateTimelineStrip;
    get muted(): boolean;
    set muted(value: boolean);
    get playsInline(): boolean;
    set playsInline(value: boolean);
    get preload(): "none" | "metadata" | "auto";
    set preload(value: "none" | "metadata" | "auto");
    get poster(): string;
    set poster(value: string);
    get volume(): number;
    set volume(value: number);
    get playbackRate(): number;
    set playbackRate(value: number);
    get subtitleDelay(): number;
    set subtitleDelay(value: number);
    /** VLC-style API alias from the feature request issue. */
    setSubtitleDelay(seconds: number): void;
    /** VLC-style API alias from the feature request issue. */
    getSubtitleDelay(): number;
    get ambientMode(): boolean;
    set ambientMode(value: boolean);
    get stableVolume(): boolean;
    set stableVolume(value: boolean);
    get currentTime(): number;
    set currentTime(value: number);
    get renderer(): RendererType;
    set renderer(value: RendererType);
    get sw(): boolean | "auto";
    set sw(value: boolean | "auto");
    get fps(): number;
    set fps(value: number);
    /** @deprecated Use `playsInline` instead — an inline player now restricts
     *  touch gestures to fullscreen on its own. Kept for backward compatibility. */
    get gesturefs(): boolean;
    /** @deprecated Use `playsInline` instead. */
    set gesturefs(value: boolean);
    get nohotkeys(): boolean;
    set nohotkeys(value: boolean);
    get startat(): number;
    set startat(value: number);
    get fastseek(): boolean;
    set fastseek(value: boolean);
    private updatePoster;
    get postertime(): string | null;
    set postertime(value: string | null);
    /**
     * Parse a `postertime` string into seconds, clamped to [0, duration].
     * Accepted formats:
     *   - "10%"      → 10% of duration
     *   - "5"        → 5 seconds
     *   - "1:30"     → 90 seconds (mm:ss)
     *   - "0:01:30"  → 90 seconds (hh:mm:ss)
     */
    private parsePosterTime;
    get doubletap(): boolean;
    set doubletap(value: boolean);
    get themecolor(): string | null;
    set themecolor(value: string | null);
    get buffersize(): number;
    set buffersize(value: number);
    get title(): string;
    set title(value: string);
    get showtitle(): boolean;
    set showtitle(value: boolean);
    private updateTitle;
    /**
     * Clean a video filename into a human-readable title (VLC-style).
     * "The.Boys.S05E01.Fifteen.Inches.of.Sheer.Dynamite.2160p.AMZN.WEB-DL.Hindi.DDP5.1-English.DDP5.1.Atmos.DV.HDR.H.265-4kHdHub.Com"
     * → "The Boys S05E01 Fifteen Inches of Sheer Dynamite"
     */
    /**
     * Turn a raw filename or metadata string into a human-readable title by
     * stripping separators, release-group tags, and quality/codec suffixes.
     * Exposed as a static utility so callers (e.g. a playlist UI) can derive
     * the same value the player does — useful for computing the resume
     * localStorage key (`movi-resume:<cleanVideoTitle(name)>`).
     */
    static cleanVideoTitle(filename: string): string;
    private cleanVideoTitle;
    get duration(): number;
    get paused(): boolean;
    get ended(): boolean;
    /** True only while the player is actively playing. Unlike `!paused`, this
     * distinguishes "playing" from intermediate states like "ready", "loading",
     * "seeking" and "buffering" — useful when deciding whether to carry play
     * state over to a new source. */
    get playing(): boolean;
    get readyState(): number;
    get width(): number;
    set width(value: number);
    get height(): number;
    set height(value: number);
    get objectFit(): "contain" | "cover" | "fill" | "zoom" | "control";
    set objectFit(value: "contain" | "cover" | "fill" | "zoom" | "control");
    get thumb(): boolean;
    set thumb(value: boolean);
    get hdr(): boolean;
    set hdr(value: boolean);
    /**
     * Whether the currently loaded source is classified as HDR (BT.2020
     * primaries or PQ/HLG transfer). Public mirror of the same check the
     * element uses internally for HDR-button visibility — safe for host
     * pages to read without reaching into private `.player` internals.
     * Returns false before a source has loaded.
     */
    get isHDRContent(): boolean;
    private updateHDRUI;
    private takeSnapshot;
    /**
     * Decode a data-URL into a small sampling canvas and report whether every
     * pixel is (near-)black — i.e. the capture came out empty. Used to detect a
     * failed WebGL readback so takeSnapshot can fall back to the raw VideoFrame.
     */
    private isDataUrlBlank;
    /**
     * Final safety net for context-menu placement. Whatever a path computed
     * (strip-mode position:fixed, host-relative absolute, …), the host's
     * `contain` re-anchors fixed/absolute to the host box — so a clamp done in
     * window coordinates can still leave the menu spilling off the real viewport
     * (seen in audio-strip mode on touch). Re-measure the ACTUAL rect and nudge
     * left/top by the overflow. Translation isn't affected by the containing
     * block, so this works regardless. The mobile drawer is a deliberate
     * right-edge panel — skip it.
     */
    /**
     * Below ~290px even the always-visible right cluster (more · fullscreen)
     * crowds the bar, so fold the fullscreen button into the collapsible
     * expandable too — leaving only the "more" (>) toggle outside, with
     * fullscreen reachable (and horizontally scrollable) once expanded. Restored
     * to its normal slot (last child of the right cluster, after the more button)
     * once there's room again. Idempotent: only moves when out of place, so it
     * survives repeated resize ticks without thrashing the DOM.
     */
    private syncTinyLayout;
    /**
     * A body-level shadow-DOM portal for the desktop context menu. Moving the
     * menu here lets it escape any overflow:hidden / clipping ancestor of the
     * player (page wrappers, cards, `body{overflow-x:hidden}`) — the player's own
     * shadow keeps `container-type` for its @container queries, which makes it a
     * containing block for fixed descendants, so a menu that stays inside can't
     * break out. The portal clones the player's shadow styles so the menu looks
     * identical, and carries over any inline theme custom-properties.
     */
    private ensureMenuPortal;
    private _portaledSubs;
    /** Move the context menu (+ its submenu panels) into the body portal and mirror theme vars. */
    private portalContextMenu;
    /** Return the context menu (+ submenus) from the portal to the shadow root. */
    private unportalContextMenu;
    private clampMenuToViewport;
    private updateHDRVisibility;
    private updateFastSeek;
}
//# sourceMappingURL=MoviElement.d.ts.map