import type React from 'react';
/**
 * Extract the YouTube video id from any common URL shape OR from a
 * bare 11-char id (carousels and some admin shapes pass that form
 * directly).
 *
 * Uses strict `URL` parsing + an anchored pathname regex — NOT the
 * legacy `.*v=` pattern that CodeQL flagged for polynomial-time
 * backtracking on adversarial input like `youtube.com/watch?`
 * repeated N times. Bare-id fallback uses an anchored character-class
 * regex so it can never ReDoS either.
 *
 * Exported so admin tooling and carousel thumbnail logic can validate
 * a URL without rendering the full `<Video>` component.
 */
export declare function extractYouTubeId(url: string): string | null;
export type VideoFailureKind = 'file' | 'youtube';
/** `stall`: buffering that never cleared while playback was expected. */
export type VideoFailureReason = 'error' | 'stall';
export interface VideoPlaybackFailureDetail {
    kind: VideoFailureKind;
    /** File URL or YouTube video id — enough to group failures by source. */
    src: string;
    reason: VideoFailureReason;
    /** YouTube IFrame API error code, when the embed reported one. */
    errorCode?: number;
}
export declare const VIDEO_PLAYBACK_FAILED_EVENT = "flamingo:video-playback-failed";
export type VideoLayout = 'centered' | 'fill' | 'native' | 'wide';
/**
 * Imperative snapshot/control handle for playback-handoff surfaces (the
 * floating walkthrough widget's mini-player continuation). Getters power
 * close-time snapshots; the mutators let a close/reopen gesture drive the
 * player without remounting. `getDuration` exists so an "ended" predicate
 * (`duration - time < 1s`) is evaluable at close time.
 */
export interface VideoPlayerHandle {
    getCurrentTime(): number;
    getDuration(): number;
    getPaused(): boolean;
    getMuted(): boolean;
    play(): Promise<void>;
    pause(): void;
    setMuted(muted: boolean): void;
}
/** Muted-fallback state reported to hosts that own their own unmute control
 *  (`onMutedFallbackChange`). `blocked` is true when even the muted play()
 *  retry was rejected (iOS Low Power Mode) — the host's control is really
 *  a "play" affordance in that state, not an "unmute" one. */
export interface VideoMutedFallbackState {
    muted: boolean;
    blocked: boolean;
}
interface VideoCommonProps {
    /** Layout wrapper. Detail pages pass `"centered"`. Default `"native"`. */
    layout?: VideoLayout;
    /** Poster / thumbnail. */
    poster?: string | null;
    /** Mute by default — for autoplay carousels. */
    muted?: boolean;
    /** LCP hint — YouTube facade poster gets `fetchpriority="high"`. */
    priority?: boolean;
    /** Tailwind classes applied to the underlying player root. */
    className?: string;
    /** Accessible label (used as YT facade title; ignored for file branch). */
    title?: string;
    /**
     * Mount the player only once its box comes near the viewport (shared
     * fire-once IntersectionObserver, `NEAR_VIEWPORT_ROOT_MARGIN` lookahead).
     * Until then the box shows the poster (or nothing) — the caller's container
     * still owns the size, so nothing shifts when the player mounts. For grids
     * of players: a library of 20 clips costs 20 posters, not 20 players.
     */
    lazy?: boolean;
    /**
     * YouTube-only: hide YT player chrome (controls, info, fullscreen, related
     * videos, keyboard shortcuts). Used for marketing/landing-page embeds that
     * want a minimal look. No-op for file (MP4/HLS) branches.
     */
    minimalControls?: boolean;
}
/**
 * File-playback options. Declared ONCE and mixed into the public prop unions
 * AND the internal player, because these were hand-copied into four places and
 * every new prop had to be added to all of them (18 props x 4 sites before this
 * collapse). The dispatcher forwards them with a spread, so a prop added here
 * reaches FilePlayer for free.
 */
interface VideoFilePlaybackProps {
    /**
     * SRT raw content. Deprecated: pass `captionsUrl` (VTT) instead.
     * Native `<track>` requires a URL; raw SRT can't be rendered without
     * a custom overlay. Setting this without `captionsUrl` is a no-op
     * with a dev warning.
     */
    srtContent?: string | null;
    /** HTTPS URL to a VTT captions file. Rendered as a native `<track>`. */
    captionsUrl?: string | null;
    /** Autoplay muted on mount (forwarded as MuxPlayer `autoPlay="muted"`). */
    autoPlay?: boolean;
    /** Loop playback — short bite previews. */
    loop?: boolean;
    /** Hide all player chrome (MuxPlayer `--controls: none`). */
    chromeless?: boolean;
    /** Play while the pointer hovers, pause on leave. Tries WITH sound at 50%
     *  first; falls back to muted when autoplay policy rejects unmuted. */
    playOnHover?: boolean;
    /** CONTROLLED variant of playOnHover: the host owns the hover state. */
    playWhenHovered?: boolean;
    /** Media preload hint. When omitted the SSOT default applies. */
    preload?: 'none' | 'metadata' | 'auto';
    /** object-fit for the media element. */
    fit?: 'contain' | 'cover';
    /** Start position in seconds (applied at LOAD time). */
    startTime?: number;
    /** Imperative handle for snapshot/control (mini-player continuation). */
    playerHandleRef?: React.Ref<VideoPlayerHandle>;
    /** Attempt UNMUTED autoplay on mount; falls back to muted on rejection. */
    autoPlayUnmuted?: boolean;
    /** Arm the muted-fallback state (host renders its own unmute affordance). */
    startMuted?: boolean;
    /** Host's standing mute intent — hover playback must not override it. */
    mutedIntent?: boolean;
    /** Suppress the INTERNAL center unmute glyph. Hosts whose own overlay
     *  button sits above the media render their own reachable control. */
    hideMutedBadge?: boolean;
    /** Reports muted-fallback state changes — see `VideoMutedFallbackState`. */
    onMutedFallbackChange?: (state: VideoMutedFallbackState) => void;
    /** Fired on the media element's `ended` event. */
    onEnded?: () => void;
}
interface VideoFileProps extends VideoCommonProps, VideoFilePlaybackProps {
    kind: 'file';
    url: string;
    firstFrameOnly?: boolean;
}
/** YouTube-facade behavior props, declared ONCE and reused by every layer that
 *  forwards them (the two union members, the facade, its inner). Same reason as
 *  `VideoFilePlaybackProps`: four hand-kept copies drift silently. */
interface VideoYouTubeFacadeProps {
    /** Activate the facade (mount the iframe) immediately — for surfaces whose
     *  opening interaction IS the play gesture (the walkthrough theater). The
     *  embed URL already carries `autoplay=1`. */
    autoActivate?: boolean;
    /** Edge-triggered pause signal: when this flips false→true while activated,
     *  the facade posts a `pauseVideo` command over its existing
     *  `enablejsapi=1` postMessage channel. Lets a closing dialog stop iframe
     *  audio BEFORE the exit animation finishes unmounting it. */
    suspended?: boolean;
}
interface VideoYouTubeProps extends VideoCommonProps, VideoYouTubeFacadeProps {
    kind: 'youtube';
    /** Either a full YT URL or just the video id. */
    url: string;
}
interface VideoAutoProps extends VideoCommonProps, VideoFilePlaybackProps, VideoYouTubeFacadeProps {
    kind?: 'auto';
    url: string;
    firstFrameOnly?: boolean;
}
export type VideoProps = VideoFileProps | VideoYouTubeProps | VideoAutoProps;
export declare function Video(props: VideoProps): React.ReactElement | null;
export {};
//# sourceMappingURL=video.d.ts.map