@retoo/scena 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1235 @@
+export { default as Scena } from './app/entrypoint/ui/Scena.svelte';
+
+/** Event names emitted by the scena widget event bus. */
+declare enum ScenaEvent {
+    /** Fired when the scena component is mounted in the DOM. */
+    ON_SCENA_MOUNT = "scena:on-mount",
+    /** Fired when the scena instance is destroyed. */
+    ON_SCENA_DESTROY = "scena:on-destroy",
+    /** Fired when the video element is ready for playback. */
+    ON_VIDEO_READY = "video:on-ready",
+    /** Fired when video playback starts. */
+    ON_VIDEO_PLAY = "video:on-play",
+    /** Fired when the browser can start playing the video. */
+    ON_VIDEO_CAN_PLAY = "video:on-can-play",
+    /** Fired when video playback is paused. */
+    ON_VIDEO_PAUSE = "video:on-pause",
+    /** Fired while the video is seeking to a new position. */
+    ON_VIDEO_SEEKING = "video:on-seeking",
+    /** Fired when a seek operation completes. */
+    ON_VIDEO_SEEKED = "video:on-seeked",
+    /** Fired when the user begins a seek interaction. */
+    ON_VIDEO_SEEK_START = "video:on-seek-start",
+    /** Fired when the user ends a seek interaction. */
+    ON_VIDEO_SEEK_END = "video:on-seek-end",
+    /** Fired when the video reaches the end. */
+    ON_VIDEO_ENDED = "video:on-ended",
+    /** Fired when the browser begins loading video data. */
+    ON_VIDEO_LOAD_START = "video:on-load-start",
+    /** Fired when video metadata has been loaded. */
+    ON_VIDEO_LOADED = "video:on-loaded",
+    /** Fired periodically as video playback progresses. */
+    ON_VIDEO_TIME_UPDATE = "video:on-time-update",
+    /** Fired when the volume or muted state changes. */
+    ON_VIDEO_VOLUME_CHANGE = "video:on-volume-change",
+    /** Fired when the video playback state changes (e.g. playing → paused). */
+    ON_VIDEO_STATE_CHANGE = "video:on-state-change",
+    /** Fired when the video stalls and starts buffering. */
+    ON_VIDEO_WAITING = "video:on-waiting",
+    /** Fired when the video download progresses. */
+    ON_VIDEO_PROGRESSED = "video:on-progressed",
+    /** Fired when a video playback error occurs. */
+    ON_VIDEO_ERROR = "video:on-error",
+    /** Fired when the video container area is clicked. */
+    ON_VIDEO_CONTAINER_CLICK = "video-container:click",
+    /** Fired when the CTA button is clicked. */
+    ON_CTA_CLICK = "cta:click",
+    /** Fired when the close button is clicked. */
+    ON_CLOSE_CLICK = "close:click",
+    /** Fired when preview mode is activated. */
+    ON_PREVIEW_START = "preview:start",
+    /** Fired when preview mode is deactivated. */
+    ON_PREVIEW_STOP = "preview:stop",
+    /** Fired when the widget becomes visible. */
+    ON_VISIBILITY_SHOW = "visibility:show",
+    /** Fired when the widget becomes hidden. */
+    ON_VISIBILITY_HIDE = "visibility:hide"
+}
+
+/** Callback invoked when a subscribed event is emitted. */
+type ScenaEventHandler<T = unknown> = (data: T) => void;
+/** Internal storage: event name → set of handlers. */
+type ScenaEventMap<T = unknown> = Map<ScenaEvent, Set<ScenaEventHandler<T>>>;
+/** Pub/sub event bus for communication between scena components. */
+interface ScenaEventEmitter {
+    /** Subscribe a handler to an event. */
+    on(eventName: ScenaEvent, handler: ScenaEventHandler): void;
+    /** Unsubscribe a specific handler from an event. */
+    off(eventName: ScenaEvent, handler: ScenaEventHandler): void;
+    /** Emit an event, calling all subscribed handlers with optional data. */
+    emit<T>(eventName: ScenaEvent, data?: T): void;
+    /** Remove all handlers for a specific event. */
+    remove(eventName: ScenaEvent): void;
+    /** Remove all handlers for all events. */
+    clear(): void;
+}
+
+/** Creates a pub/sub event emitter instance. */
+declare function useEventEmitter(): ScenaEventEmitter;
+
+/** T-shirt size scale used for component sizing. */
+declare enum ComponentSize {
+    XS = "xs",
+    SM = "sm",
+    MD = "md",
+    LG = "lg",
+    XL = "xl",
+    XXL = "xxl"
+}
+/** Placement of a component within its container (3×3 grid). */
+declare enum ComponentPlacement {
+    TOP_START = "top-start",
+    TOP_CENTER = "top-center",
+    TOP_END = "top-end",
+    MIDDLE_START = "middle-start",
+    MIDDLE_CENTER = "middle-center",
+    MIDDLE_END = "middle-end",
+    BOTTOM_START = "bottom-start",
+    BOTTOM_CENTER = "bottom-center",
+    BOTTOM_END = "bottom-end"
+}
+/** CSS `position` values for component layout. */
+declare enum ComponentPosition {
+    STATIC = "static",
+    RELATIVE = "relative",
+    ABSOLUTE = "absolute",
+    FIXED = "fixed"
+}
+/** Shape variant for components (affects border-radius and aspect ratio). */
+declare enum ComponentShape {
+    CIRCLE = "circle",
+    LANDSCAPE = "landscape",
+    PORTRAIT = "portrait",
+    SQUARE = "square"
+}
+/** Possible values for the `aria-pressed` attribute. */
+declare enum ComponentAriaPressed {
+    MIXED = "mixed"
+}
+/** Possible values for the `aria-haspopup` attribute. */
+declare enum ComponentAriaHaspopup {
+    MENU = "menu",
+    TREE = "tree",
+    GRID = "grid",
+    DIALOG = "dialog",
+    LISTBOX = "listbox"
+}
+
+/** Named override layer. */
+declare enum OverrideLayer {
+    RESPONSIVE = "responsive",
+    PREVIEW = "preview"
+}
+
+/** Inline styles — a raw CSS string or a partial `CSSStyleDeclaration` object. */
+type ComponentStyles = string | Partial<CSSStyleDeclaration>;
+/**
+ * Class binding value.
+ * Accepts a string, falsy values (skipped), an object whose truthy keys
+ * are added as classes, or a nested array of the same.
+ */
+type ComponentClasses = string | number | false | null | undefined | Record<string, boolean> | ComponentClasses[];
+/** Common ARIA attributes shared across interactive components. */
+interface ComponentAriaProps {
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+    ariaDisabled?: boolean;
+    ariaExpanded?: boolean;
+    ariaControls?: string;
+    ariaPressed?: ComponentAriaPressed;
+    ariaHaspopup?: ComponentAriaHaspopup;
+}
+
+/** Internal return type for component snippets. */
+type ComponentSnippetReturn = any;
+/**
+ * Typed Svelte 5 snippet reference.
+ * Produces a descriptive compile-time error when used incorrectly
+ * (e.g. called as a function instead of `{@render ...}`).
+ */
+interface ComponentSnippet<Parameters extends unknown[] = []> {
+    (this: void, ...args: number extends Parameters['length'] ? never : Parameters): {
+        '{@render ...} must be called with a Snippet': "import type { ComponentSnippet } from '@retoo/scena'";
+    } & ComponentSnippetReturn;
+}
+
+/** Custom CSS class overrides for the outer container. */
+interface ScenaContainerCustomClasses {
+    root: ComponentClasses;
+}
+/** Custom inline style overrides for the outer container. */
+interface ScenaContainerCustomStyles {
+    root: ComponentStyles;
+}
+/** Configuration props for the scena outer container. */
+interface ScenaContainerProps {
+    id: string;
+    /** CSS `position` value for the container. */
+    position: ComponentPosition;
+    /** Placement within the viewport (e.g. bottom-end). */
+    placement: ComponentPlacement;
+    customClasses: Partial<ScenaContainerCustomClasses>;
+    customStyles: Partial<ScenaContainerCustomStyles>;
+}
+/** Snippet slots for the container widget. */
+interface ScenaContainerSnippets {
+    children: ComponentSnippet;
+}
+/** Component ref for the outer container. */
+interface ScenaContainerRef {
+    getElements: () => {
+        root: HTMLDivElement;
+    };
+}
+
+/** Possible values for `aria-pressed` on scena buttons. */
+declare enum ScenaButtonAriaPressed {
+    MIXED = "mixed"
+}
+/** Possible values for `aria-haspopup` on scena buttons. */
+declare enum ScenaButtonAriaHaspopup {
+    MENU = "menu",
+    LISTBOX = "listbox",
+    TREE = "tree",
+    GRID = "grid",
+    DIALOG = "dialog"
+}
+/** Shape of the button element. */
+declare enum ScenaButtonShape {
+    RECTANGLE = "rectangle",
+    CIRCLE = "circle",
+    SQUARE = "square"
+}
+/** Visual variant of the button. */
+declare enum ScenaButtonVariant {
+    /** Solid background fill. */
+    FILLED = "filled",
+    /** Transparent background, text only. */
+    TEXT = "text"
+}
+/** HTML `type` attribute for the button element. */
+declare enum ScenaButtonType {
+    BUTTON = "button",
+    SUBMIT = "submit",
+    RESET = "reset"
+}
+
+/** Custom CSS class overrides for the base button. */
+interface ScenaButtonComponentClasses {
+    root: ComponentClasses;
+}
+/** Custom inline style overrides for the base button. */
+interface ScenaButtonComponentStyles {
+    root: ComponentStyles;
+}
+/** Configuration props for the base scena button component. */
+interface ScenaButtonProps {
+    id: string;
+    autosize: boolean;
+    size: ComponentSize;
+    shape: ScenaButtonShape;
+    variant: ScenaButtonVariant;
+    type: ScenaButtonType;
+    aria: Partial<ComponentAriaProps>;
+    customClasses: Partial<ScenaButtonComponentClasses>;
+    customStyles: Partial<ScenaButtonComponentStyles>;
+}
+/** Event handlers for the base button. */
+interface ScenaButtonEvents {
+    onclick: (event: Event) => void;
+}
+/** Snippet slots for the base button. */
+interface ScenaButtonSnippets {
+    children: ComponentSnippet;
+}
+/** DOM element references for the base button. */
+interface ScenaButtonElements {
+    root: HTMLButtonElement;
+}
+
+interface ScenaIconCustomClasses {
+    root: ComponentClasses;
+}
+interface ScenaIconCustomStyles {
+    root: ComponentStyles;
+}
+interface ScenaIconProps {
+    id: string;
+    viewBox: string;
+    size: ComponentSize;
+    customClasses: Partial<ScenaIconCustomClasses>;
+    customStyles: Partial<ScenaIconCustomStyles>;
+}
+interface ScenaIconSnippets {
+    children: ComponentSnippet;
+}
+interface ScenaIconElements {
+    root: SVGSVGElement;
+}
+
+/** Custom CSS class overrides for the close button and its sub-components. */
+interface ScenaCloseButtonComponentClasses {
+    root: ComponentClasses;
+    button: ComponentClasses;
+    cross: ComponentClasses;
+}
+/** Custom inline style overrides for the close button and its sub-components. */
+interface ScenaCloseButtonComponentStyles {
+    root: ComponentStyles;
+    button: ComponentStyles;
+    cross: ComponentStyles;
+}
+/** Configuration props for the close button widget. */
+interface ScenaCloseButtonProps {
+    id: string;
+    size: ComponentSize;
+    shape: ComponentShape;
+    aria: Partial<ComponentAriaProps>;
+    customClasses: Partial<ScenaCloseButtonComponentClasses>;
+    customStyles: Partial<ScenaCloseButtonComponentStyles>;
+    onClick: (event: Event) => void;
+}
+/** Component ref for the close button. */
+interface ScenaCloseButtonRef {
+    getElements: () => {
+        root: HTMLDivElement;
+        button: ScenaButtonElements | undefined;
+        cross: ScenaIconElements | undefined;
+    };
+}
+
+declare enum ScenaCtaButtonPlacement {
+    INSIDE = "inside",
+    OUTSIDE = "outside"
+}
+
+/** Custom CSS class overrides for the CTA button. */
+interface ScenaCtaButtonComponentClasses {
+    root: ComponentClasses;
+    button: ComponentClasses;
+}
+/** Custom inline style overrides for the CTA button. */
+interface ScenaCtaButtonComponentStyles {
+    root: ComponentStyles;
+    button: ComponentStyles;
+}
+/** Adaptive display settings for the CTA button across screen sizes. */
+interface ScenaCtaButtonAdaptive {
+    sizes: ComponentSize[];
+    placement: ScenaCtaButtonPlacement;
+}
+/** Configuration props for the CTA (call-to-action) button widget. */
+interface ScenaCtaButtonProps {
+    id: string;
+    text: string;
+    size: ComponentSize;
+    placement: ScenaCtaButtonPlacement;
+    adaptive: ScenaCtaButtonAdaptive | false;
+    aria: Partial<ComponentAriaProps>;
+    customClasses: Partial<ScenaCtaButtonComponentClasses>;
+    customStyles: Partial<ScenaCtaButtonComponentStyles>;
+    onClick: (event: Event) => void;
+}
+/** Component ref for the CTA button. */
+interface ScenaCtaButtonRef {
+    getElements: () => {
+        root: HTMLDivElement;
+        button: ScenaButtonElements | undefined;
+    };
+}
+
+/** Preload strategy for the `<video>` element. */
+declare enum ScenaVideoPreload {
+    NONE = "none",
+    AUTO = "auto",
+    METADATA = "metadata"
+}
+/** CORS setting for the `<video>` element. */
+declare enum ScenaVideoCrossOrigin {
+    ANONYMOUS = "anonymous",
+    USE_CREDENTIALS = "use-credentials"
+}
+/** Playback state of the video player. */
+declare enum ScenaVideoState {
+    IDLE = "idle",
+    LOADING = "loading",
+    PLAYING = "playing",
+    PAUSED = "paused",
+    ENDED = "ended",
+    ERROR = "error"
+}
+
+/** Reactive state data of the video player. */
+interface ScenaVideoData {
+    /** Current playback state. */
+    state: ScenaVideoState;
+    /** Current playback position in seconds. */
+    currentTime: number;
+    /** Total video duration in seconds. */
+    duration: number;
+    /** Playback progress as a fraction (0–1). */
+    progress: number;
+    /** Active `requestAnimationFrame` ID for progress tracking, if any. */
+    progressAnimationFrameId: number | null;
+    /** Current volume level (0–1). */
+    volume: number;
+    /** Buffered amount as a fraction (0–1). */
+    buffer: number;
+    /** Raw `TimeRanges` from the video element. */
+    buffered: TimeRanges | null;
+    /** Whether the video is currently buffering. */
+    isBuffering: boolean;
+    /** Whether a seek operation is in progress. */
+    isSeeking: boolean;
+    /** Whether the video is muted. */
+    isMuted: boolean;
+}
+/** Imperative methods for controlling video playback. */
+interface ScenaVideoMethods {
+    /** Start or resume playback. */
+    play: () => Promise<void>;
+    /** Pause playback. */
+    pause: () => void;
+    /** Stop playback and reset to the beginning. */
+    stop: () => void;
+    /** Seek to a specific time in seconds. */
+    seek: (value: number) => void;
+    /** Set the volume level (0–1). */
+    setVolume: (value: number) => void;
+    /** Mute the video. */
+    mute: () => void;
+    /** Unmute the video. */
+    unmute: () => void;
+    /** Toggle between muted and unmuted. */
+    toggleMute: () => void;
+}
+/** Event handler callbacks bound to native `<video>` element events. */
+interface ScenaVideoCallbacks {
+    handleLoadedMetadata: (event: Event) => void;
+    handlePlay: (event: Event) => void;
+    handlePause: (event: Event) => void;
+    handleSeeking: (event: Event) => void;
+    handleSeeked: (event: Event) => void;
+    handleSeekStart: (event: Event, state: ScenaVideoState) => void;
+    handleSeekEnd: (event: Event, state: ScenaVideoState) => Promise<void>;
+    handleEnded: (event: Event) => void;
+    handleLoadStart: (event: Event) => void;
+    handleLoaded: (event: Event) => void;
+    handleWaiting: (event: Event) => void;
+    handleCanPlay: (event: Event) => void;
+    handleTimeUpdate: (event: Event) => void;
+    handleVolumeChange: (event: Event) => void;
+    handleProgress: (event: Event) => void;
+    handleError: (event: Event) => void;
+}
+/** Full video context combining reactive data, methods, and callbacks. */
+type ScenaVideoContext = ScenaVideoData & ScenaVideoMethods & ScenaVideoCallbacks;
+/** Event options carrying the original DOM event. */
+interface ScenaVideoEventOptionsWithEvent {
+    state: ScenaVideoState;
+    event: Event;
+}
+/** Event options carrying an error payload. */
+interface ScenaVideoEventOptionsWithError {
+    state: ScenaVideoState;
+    error: unknown;
+}
+/** Discriminated union of video event option types. */
+type ScenaVideoEventOptions = ScenaVideoEventOptionsWithEvent | ScenaVideoEventOptionsWithError;
+
+declare const getScenaVideoContext: () => ScenaVideoContext;
+declare const setScenaVideoContext: (context: ScenaVideoContext) => ScenaVideoContext;
+
+/** Custom CSS class overrides for the video widget. */
+interface ScenaVideoComponentClasses {
+    /** Classes for the wrapper `<div>`. */
+    root: ComponentClasses;
+    /** Classes for the `<video>` element. */
+    video: ComponentClasses;
+}
+/** Custom inline style overrides for the video widget. */
+interface ScenaVideoComponentStyles {
+    /** Styles for the wrapper `<div>`. */
+    root: ComponentStyles;
+    /** Styles for the `<video>` element. */
+    video: ComponentStyles;
+}
+/** Configuration props for the `<video>` element and its wrapper. */
+interface ScenaVideoProps {
+    id: string;
+    src: string;
+    type: string;
+    media: string;
+    poster: string;
+    preload: ScenaVideoPreload;
+    crossorigin: ScenaVideoCrossOrigin;
+    autoplay: boolean;
+    playsinline: boolean;
+    loop: boolean;
+    muted: boolean;
+    controls: boolean;
+    volume: number;
+    startTime: number;
+    customClasses: Partial<ScenaVideoComponentClasses>;
+    customStyles: Partial<ScenaVideoComponentStyles>;
+}
+/** Snippet slots for the video widget. */
+interface ScenaVideoSnippets {
+    children: ComponentSnippet;
+}
+/** Options for creating the video controller. */
+interface UseVideoControllerOptions {
+    /** Getter that returns the underlying `<video>` DOM element. */
+    getVideoElement: () => HTMLVideoElement;
+    /** Event emitter to broadcast video lifecycle events. */
+    eventEmitter: ScenaEventEmitter;
+}
+/** Return value of `useVideoController` — combines reactive data, methods, and callbacks. */
+type UseVideoControllerReturns = ScenaVideoData & ScenaVideoMethods & ScenaVideoCallbacks;
+/** Component ref for the video widget. */
+interface ScenaVideoRef {
+    /** Video playback controller. */
+    controller: UseVideoControllerReturns;
+    /** Returns references to the root wrapper and video DOM elements. */
+    getElements: () => {
+        root: HTMLDivElement;
+        video: HTMLVideoElement;
+    };
+}
+
+declare function useVideoController({ getVideoElement, eventEmitter }: UseVideoControllerOptions): UseVideoControllerReturns;
+
+/** Custom CSS class overrides for the video container. */
+interface ScenaVideoContainerCustomClasses {
+    root: ComponentClasses;
+}
+/** Custom inline style overrides for the video container. */
+interface ScenaVideoContainerCustomStyles {
+    root: ComponentStyles;
+}
+/** Configuration props for the video container widget. */
+interface ScenaVideoContainerProps {
+    id: string;
+    /** Size of the video container. */
+    size: ComponentSize;
+    /** Shape of the video container (affects aspect ratio and border-radius). */
+    shape: ComponentShape;
+    /** ARIA attributes for accessibility. */
+    aria: Partial<ComponentAriaProps>;
+    customClasses: Partial<ScenaVideoContainerCustomClasses>;
+    customStyles: Partial<ScenaVideoContainerCustomStyles>;
+}
+/** Snippet slots for the video container. */
+interface ScenaVideoContainerSnippets {
+    children: ComponentSnippet;
+}
+/** Component ref for the video container. */
+interface ScenaVideoContainerRef {
+    getElements: () => {
+        root: HTMLDivElement;
+    };
+}
+
+/** Custom CSS class overrides for the video play/pause controls. */
+interface ScenaVideoControlsComponentClasses {
+    root: ComponentClasses;
+    play: ComponentClasses;
+    pause: ComponentClasses;
+}
+/** Custom inline style overrides for the video play/pause controls. */
+interface ScenaVideoControlsComponentStyles {
+    root: ComponentStyles;
+    play: ComponentStyles;
+    pause: ComponentStyles;
+}
+/** Per-button ARIA overrides for video controls. */
+interface ScenaVideoControlsComponentAria {
+    play: Partial<ComponentAriaProps>;
+    pause: Partial<ComponentAriaProps>;
+}
+/** Configuration props for the video play/pause controls widget. */
+interface ScenaVideoControlsProps {
+    id: string;
+    size: ComponentSize;
+    aria: Partial<ScenaVideoControlsComponentAria>;
+    customClasses: Partial<ScenaVideoControlsComponentClasses>;
+    customStyles: Partial<ScenaVideoControlsComponentStyles>;
+}
+/** Component ref for the video play/pause controls. */
+interface ScenaVideoControlsRef {
+    getElements: () => {
+        root: HTMLDivElement | null;
+        pauseButton: ScenaButtonElements | undefined;
+        pauseIcon: ScenaIconElements | undefined;
+        playButton: ScenaButtonElements | undefined;
+        playIcon: ScenaIconElements | undefined;
+    };
+}
+
+/** Custom CSS class overrides for the loader spinner. */
+interface ScenaLoaderCustomClasses {
+    root: ComponentClasses;
+}
+/** Custom inline style overrides for the loader spinner. */
+interface ScenaLoaderCustomStyles {
+    root: ComponentStyles;
+}
+/** Configuration props for the loading spinner component. */
+interface ScenaLoaderProps {
+    id: string;
+    size: ComponentSize;
+    customClasses: Partial<ScenaLoaderCustomClasses>;
+    customStyles: Partial<ScenaLoaderCustomStyles>;
+}
+/** DOM element references for the loader spinner. */
+interface ScenaLoaderElements {
+    root: SVGSVGElement;
+}
+
+/** Custom CSS class overrides for the video loader widget. */
+interface ScenaVideoLoaderComponentClasses {
+    root: ComponentClasses;
+    loader: ComponentClasses;
+}
+/** Custom inline style overrides for the video loader widget. */
+interface ScenaVideoLoaderComponentStyles {
+    root: ComponentStyles;
+    loader: ComponentStyles;
+}
+/** Configuration props for the video buffering/loading indicator. */
+interface ScenaVideoLoaderProps {
+    id: string;
+    size: ComponentSize;
+    customClasses: Partial<ScenaVideoLoaderComponentClasses>;
+    customStyles: Partial<ScenaVideoLoaderComponentStyles>;
+}
+/** Component ref for the video loader. */
+interface ScenaVideoLoaderRef {
+    getElements: () => {
+        root: HTMLDivElement;
+        loader: ScenaLoaderElements | undefined;
+    };
+}
+
+declare enum ScenaVideoProgressVariant {
+    LINE = "line",
+    CIRCLE = "circle"
+}
+
+declare const scenaProgressLineThicknessMap: ScenaProgressComponentThickness;
+declare const scenaProgressCircleThicknessMap: ScenaProgressComponentThickness;
+
+/** Thickness values for the progress indicator in default and hover states. */
+interface ScenaProgressThickness {
+    default: number;
+    hover: number;
+}
+/** Maps each component size to its progress thickness settings. */
+type ScenaProgressComponentThickness = Record<ComponentSize, ScenaProgressThickness>;
+/** Custom CSS class overrides for the circular progress indicator. */
+interface ScenaProgressCircleComponentClasses {
+    root: ComponentClasses;
+    track: ComponentClasses;
+    buffer: ComponentClasses;
+    progress: ComponentClasses;
+}
+/** Custom inline style overrides for the circular progress indicator. */
+interface ScenaProgressCircleComponentStyles {
+    root: ComponentStyles;
+    track: ComponentStyles;
+    buffer: ComponentStyles;
+    progress: ComponentStyles;
+}
+/** Configuration props for the circular progress indicator. */
+interface ScenaProgressCircleProps {
+    id: string;
+    size: ComponentSize;
+    buffer: number;
+    progress: number;
+    hasBuffer: boolean;
+    aria: Partial<ComponentAriaProps>;
+    customThickness: Partial<ScenaProgressComponentThickness>;
+    customClasses: Partial<ScenaProgressCircleComponentClasses>;
+    customStyles: Partial<ScenaProgressCircleComponentStyles>;
+}
+/** Seek event callbacks for the circular progress indicator. */
+interface ScenaProgressCircleEvents {
+    onSeek: (progress: number, event: Event) => void;
+    onSeekStart?: (event: Event) => void;
+    onSeekEnd?: (event: Event) => void;
+}
+/** Custom CSS class overrides for the linear progress bar. */
+interface ScenaProgressLineComponentClasses {
+    root: ComponentClasses;
+    track: ComponentClasses;
+    buffer: ComponentClasses;
+    progress: ComponentClasses;
+}
+/** Custom inline style overrides for the linear progress bar. */
+interface ScenaProgressLineComponentStyles {
+    root: ComponentStyles;
+    track: ComponentStyles;
+    buffer: ComponentStyles;
+    progress: ComponentStyles;
+}
+/** Configuration props for the linear progress bar. */
+interface ScenaProgressLineProps {
+    id: string;
+    size: ComponentSize;
+    buffer: number;
+    progress: number;
+    hasBuffer: boolean;
+    customThickness: Partial<ScenaProgressComponentThickness>;
+    customClasses: Partial<ScenaProgressLineComponentClasses>;
+    customStyles: Partial<ScenaProgressLineComponentStyles>;
+    aria: Partial<ComponentAriaProps>;
+}
+/** Seek event callbacks for the linear progress bar. */
+interface ScenaProgressLineEvents {
+    onSeek: (progress: number, event: Event) => void;
+    onSeekStart?: (event: Event) => void;
+    onSeekEnd?: (event: Event) => void;
+}
+/** DOM event handlers bound by the line progress hook. */
+interface UseProgressLineReturnEvents {
+    onpointerup: (event: PointerEvent) => void;
+    onpointermove: (event: PointerEvent) => void;
+    onpointerdown: (event: PointerEvent) => void;
+    onpointercancel: (event: PointerEvent) => void;
+    onmouseenter: () => void;
+    onmouseleave: () => void;
+}
+/** Reactive state returned by the line progress hook. */
+interface UseProgressLineReturn {
+    isFocused: boolean;
+    isDragging: boolean;
+    isDisabledTransition: boolean;
+    thickness: number;
+    transition: string | undefined;
+    events: UseProgressLineReturnEvents;
+}
+/** Props accepted by the line progress hook. */
+interface UseProgressLineProps {
+    getRootElement: () => HTMLElement;
+    getSize: () => ComponentSize;
+    getCustomThickness: () => ScenaProgressComponentThickness;
+    getProgress: () => number;
+}
+/** Seek event callbacks used internally by the line progress hook. */
+interface UseProgressLineEvents {
+    onSeek: (progress: number, event: Event) => void;
+    onSeekStart: (event: Event) => void;
+    onSeekEnd: (event: Event) => void;
+}
+/** Props accepted by the circle progress hook. */
+interface UseProgressCircleProps {
+    getRootElement: () => SVGSVGElement;
+    getSize: () => ComponentSize;
+    getCustomThickness: () => ScenaProgressComponentThickness;
+    getProgress: () => number;
+    getBuffer: () => number;
+}
+/** Seek event callbacks used internally by the circle progress hook. */
+interface UseProgressCircleEvents {
+    onSeek: (progress: number, event: Event) => void;
+    onSeekStart: (event: Event) => void;
+    onSeekEnd: (event: Event) => void;
+}
+/** DOM event handlers bound by the circle progress hook. */
+interface UseProgressCircleReturnEvents {
+    onclick: (event: MouseEvent) => void;
+    onpointerdown: (event: PointerEvent) => void;
+    onpointermove: (event: PointerEvent) => void;
+    onpointerup: (event: PointerEvent) => void;
+    onpointercancel: (event: PointerEvent) => void;
+    onmouseenter: () => void;
+    onmouseleave: () => void;
+}
+/** DOM element references for the linear progress bar. */
+interface ScenaProgressLineElements {
+    root: HTMLDivElement;
+    track: HTMLDivElement;
+    buffer: HTMLDivElement | null;
+    progress: HTMLDivElement;
+}
+/** DOM element references for the circular progress indicator. */
+interface ScenaProgressCircleElements {
+    root: SVGSVGElement;
+    track: SVGCircleElement | null;
+    buffer: SVGCircleElement | null;
+    progress: SVGCircleElement | null;
+}
+/** Reactive state returned by the circle progress hook. */
+interface UseProgressCircleReturn {
+    isFocused: boolean;
+    isDragging: boolean;
+    radialSize: number;
+    radialRadius: number;
+    radialCircumference: number;
+    radialProgressOffset: number;
+    radialBufferOffset: number;
+    thickness: number;
+    hitAreaThickness: number;
+    transition: string | undefined;
+    events: UseProgressCircleReturnEvents;
+}
+
+declare function useProgressLine({ getRootElement, getSize, getProgress, getCustomThickness, onSeek, onSeekStart, onSeekEnd }: UseProgressLineProps & Partial<UseProgressLineEvents>): UseProgressLineReturn;
+
+declare function useProgressCircle({ getRootElement, getSize, getBuffer, getProgress, getCustomThickness, onSeek, onSeekStart, onSeekEnd }: UseProgressCircleProps & Partial<UseProgressCircleEvents>): UseProgressCircleReturn;
+
+/** Custom CSS class overrides for the video progress bar. */
+interface ScenaVideoProgressComponentClasses {
+    root: ComponentClasses;
+    track: ComponentClasses;
+    progress: ComponentClasses;
+    buffered: ComponentClasses;
+}
+/** Custom inline style overrides for the video progress bar. */
+interface ScenaVideoProgressComponentStyles {
+    root: ComponentStyles;
+    track: ComponentStyles;
+    progress: ComponentStyles;
+    buffered: ComponentStyles;
+}
+/** Thickness values for the progress bar in default and hover states. */
+interface ScenaVideoProgressThickness {
+    default: number;
+    hover: number;
+}
+/** Maps each component size to its progress thickness values. */
+type ScenaVideoProgressThicknessMap = Record<ComponentSize, ScenaVideoProgressThickness>;
+/** Thickness config per progress variant (line/circle) and size. */
+type ScenaVideoProgressComponentThickness = Record<ScenaVideoProgressVariant, ScenaVideoProgressThicknessMap>;
+/** Configuration props for the video progress widget. */
+interface ScenaVideoProgressProps {
+    id: string;
+    size: ComponentSize;
+    shape: ComponentShape;
+    hasBuffer: boolean;
+    aria: Partial<ComponentAriaProps>;
+    customThickness: Partial<ScenaVideoProgressComponentThickness>;
+    customClasses: Partial<ScenaVideoProgressComponentClasses>;
+    customStyles: Partial<ScenaVideoProgressComponentStyles>;
+}
+/** Component ref for the video progress bar. */
+interface ScenaVideoProgressRef {
+    getElements: () => ScenaProgressLineElements | ScenaProgressCircleElements | null;
+}
+
+/** Custom CSS class overrides for the volume mute/unmute controls. */
+interface ScenaVideoVolumeComponentClasses {
+    root: ComponentClasses;
+    mute: ComponentClasses;
+    unmute: ComponentClasses;
+}
+/** Custom inline style overrides for the volume mute/unmute controls. */
+interface ScenaVideoVolumeComponentStyles {
+    root: ComponentStyles;
+    mute: ComponentStyles;
+    unmute: ComponentStyles;
+}
+/** Per-button ARIA overrides for volume controls. */
+interface ScenaVideoVolumeComponentAria {
+    mute: Partial<ComponentAriaProps>;
+    unmute: Partial<ComponentAriaProps>;
+}
+/** Configuration props for the volume control widget. */
+interface ScenaVideoVolumeProps {
+    id: string;
+    size: ComponentSize;
+    shape: ComponentShape;
+    aria: Partial<ScenaVideoVolumeComponentAria>;
+    customClasses: Partial<ScenaVideoVolumeComponentClasses>;
+    customStyles: Partial<ScenaVideoVolumeComponentStyles>;
+}
+/** Component ref for the volume control widget. */
+interface ScenaVideoVolumeRef {
+    getElements: () => {
+        root: HTMLDivElement | null;
+        unmuteButton: ScenaButtonElements | undefined;
+        unmuteIcon: ScenaIconElements | undefined;
+        muteButton: ScenaButtonElements | undefined;
+        muteIcon: ScenaIconElements | undefined;
+    };
+}
+
+/** Return value of {@link useScenaOverrides}. */
+interface UseScenaOverridesReturns {
+    /** The resolved config with all override layers applied (reactive). */
+    resolved: ScenaConfig;
+    /** Compute and return the resolved config snapshot. */
+    resolve: () => ScenaConfig;
+    /** Set an override factory function for a named layer, or `null` to clear that layer. */
+    set: (layer: OverrideLayer, value: (() => Partial<ScenaConfig>) | null) => void;
+}
+
+/** Public API for controlling preview mode at runtime. */
+interface ScenaPreviewApi {
+    /** Whether preview mode is currently active. */
+    isPreviewing: boolean;
+    /** Whether video position is preserved when expanding from preview. */
+    isKeepTimeOnExpand: boolean;
+    /** Whether mute state is preserved when expanding from preview. */
+    isKeepMuteOnExpand: boolean;
+    /** Activate preview mode, applying preview overrides. */
+    start: () => void;
+    /** Deactivate preview mode, removing preview overrides. */
+    stop: () => void;
+}
+/** Return value of {@link useScenaPreview}. */
+interface UseScenaPreviewReturns {
+    /** Apply initial preview state from config. */
+    apply: () => void;
+    /** Reactive public API for controlling preview mode. */
+    api: ScenaPreviewApi;
+}
+/** Behavioral options for preview mode. */
+interface ScenaPreviewBehavior {
+    /** When true, preserves video playback position when expanding from preview. */
+    keepTimeOnExpand: boolean;
+    /** When true, preserves mute state when expanding from preview. */
+    keepMuteOnExpand: boolean;
+}
+/** Preview config — same shape as {@link ScenaOverrides}. */
+type ScenaPreviewConfig = ScenaOverrides & ScenaPreviewBehavior;
+/** Options for constructing the preview feature. */
+interface UseScenaPreviewOptions {
+    config: UseScenaConfigReturns;
+    configOverrides: UseScenaOverridesReturns;
+}
+
+/** Public API for the responsive feature. */
+interface ScenaResponsiveApi {
+    /** The currently active breakpoint (max-width in px), or `null` if none matched. */
+    activeBreakpoint: number | null;
+}
+/** Return value of {@link useScenaResponsive}. */
+interface UseScenaResponsiveReturns {
+    /** Set up matchMedia listeners and apply the initial breakpoint. */
+    apply: () => void;
+    /** Remove all listeners and clear responsive overrides. */
+    destroy: () => void;
+    /** Reactive responsive API. */
+    api: ScenaResponsiveApi;
+}
+/** Responsive config — object of breakpoints mapped to partial overrides. */
+type ScenaResponsiveConfig = Record<number, Partial<ScenaOverrides>>;
+
+/** Return value of {@link useScenaVisibility}. */
+interface UseScenaVisibilityReturns {
+    /** Apply initial visibility state from config defaults. */
+    apply: () => void;
+    /** Reactive public API for controlling widget visibility. */
+    api: ScenaVisibilityApi;
+}
+/** Public API for controlling widget visibility at runtime. */
+interface ScenaVisibilityApi {
+    /** Whether the widget is currently hidden. */
+    isHidden: boolean;
+    /** Whether the widget should auto-show when the video is ready. */
+    isShownOnReady: boolean;
+    /** Show the widget (set `isHidden` to `false`). */
+    show: () => void;
+    /** Hide the widget (set `isHidden` to `true`). */
+    hide: () => void;
+}
+/** Visibility feature configuration options. */
+interface ScenaVisibilityConfig {
+    /** Start the widget in a hidden state. */
+    isHidden?: boolean;
+    /** Enable CSS animations for show/hide transitions. */
+    isAnimated?: boolean;
+    /** Automatically show the widget when the video is ready. Defaults to `true`. */
+    isShownOnReady?: boolean;
+}
+
+/** Per-component property overrides. Pass `false` to disable a component entirely. */
+interface ScenaOverrides {
+    size: ComponentSize;
+    shape: ComponentShape;
+    container: Partial<ScenaContainerProps>;
+    video: Partial<ScenaVideoProps> & Pick<ScenaVideoProps, 'src'>;
+    videoContainer: Partial<ScenaVideoContainerProps>;
+    videoLoader: Partial<ScenaVideoLoaderProps> | false;
+    videoProgress: Partial<ScenaVideoProgressProps> | false;
+    videoControls: Partial<ScenaVideoControlsProps> | false;
+    videoVolume: Partial<ScenaVideoVolumeProps> | false;
+    closeButton: Partial<ScenaCloseButtonProps> | false;
+    ctaButton: Partial<ScenaCtaButtonProps> | false;
+}
+/** Component override config. All overrides are optional except `video` which requires at least `src`. */
+type ScenaConfigOverrides = Partial<ScenaOverrides> & Pick<ScenaOverrides, 'video'>;
+/** Feature-specific sections of the widget config. */
+interface ScenaFeatures {
+    preview: Partial<ScenaPreviewConfig>;
+    visibility: Partial<ScenaVisibilityConfig>;
+    responsive: ScenaResponsiveConfig;
+}
+/** Optional feature config. All feature sections are optional at the top level. */
+type ScenaConfigFeatures = Partial<ScenaFeatures>;
+/** Root configuration object accepted by `scena.mount()`. */
+type ScenaConfig = ScenaConfigOverrides & ScenaConfigFeatures;
+/** Reactive config store returned by {@link useScenaConfig}. */
+interface UseScenaConfigReturns {
+    /** Current resolved config snapshot. */
+    current: ScenaConfig;
+    /** Returns the current config object. */
+    getConfig: () => ScenaConfig;
+    /** Replaces the entire config with a new value. */
+    setConfig: (value: ScenaConfig) => void;
+    /** Deeply merges a partial config into the current one. */
+    mergeConfig: (partial: Partial<ScenaConfig>) => void;
+}
+
+/** Mount target — a regular DOM element or a Shadow DOM root. */
+type ScenaTarget = HTMLElement | ShadowRoot;
+/** Handle returned after mounting; provides runtime access to the widget. */
+interface ScenaInstance {
+    /** Public widget API (e.g. play, pause, destroy). */
+    api: ScenaApi;
+    /** Reference to the mounted Svelte component. */
+    component: ScenaRef;
+    /** Reactive config store for reading and updating the widget config. */
+    config: UseScenaConfigReturns;
+    /** Preview feature API (start, stop, isPreviewing). */
+    preview: ScenaPreviewApi;
+    /** Responsive feature API (activeBreakpoint). */
+    responsive: ScenaResponsiveApi;
+    /** Visibility feature API (show, hide, isHidden). */
+    visibility: ScenaVisibilityApi;
+}
+/** Registry of all component refs within a mounted scena widget. Nullable refs correspond to optional components. */
+interface ScenaComponents {
+    container: ScenaContainerRef;
+    video: ScenaVideoRef;
+    videoContainer: ScenaVideoContainerRef;
+    videoLoader: ScenaVideoLoaderRef | null;
+    videoProgress: ScenaVideoProgressRef | null;
+    videoControls: ScenaVideoControlsRef | null;
+    videoVolume: ScenaVideoVolumeRef | null;
+    closeButton: ScenaCloseButtonRef | null;
+    ctaButton: ScenaCtaButtonRef | null;
+}
+/** Top-level API returned by {@link useScena}. */
+interface UseScenaReturns {
+    /** Library name. */
+    NAME: string;
+    /** Library version. */
+    VERSION: string;
+    /** Mount the widget into a target element with the given config. */
+    mount: (config: ScenaConfig, target?: ScenaTarget) => Promise<ScenaInstance>;
+    /** Unmount a previously mounted widget instance. */
+    unmount: (instance: ScenaInstance) => Promise<void>;
+}
+/** Internal props passed to the root Scena Svelte component. */
+interface ScenaProps {
+    /** Resolved widget config (with overrides applied). */
+    config: ScenaConfig;
+    /** Shared event bus created by the factory. */
+    eventEmitter: ScenaEventEmitter;
+    /** Callback invoked when the component is mounted. */
+    mount: () => void;
+    /** Callback invoked when the component requests unmount. */
+    unmount: () => void;
+}
+/** Top-level API surface exposed by a mounted scena widget. */
+interface ScenaApi {
+    /** Video playback controller (play, pause, seek, volume, etc.). */
+    controller: UseVideoControllerReturns;
+    /** References to all child component instances. */
+    components: ScenaComponents;
+    /** Pub/sub event bus for widget events. */
+    events: ScenaEventEmitter;
+}
+/** Reference to the root Scena Svelte component. */
+interface ScenaRef {
+    /** Top-level widget API. */
+    api: ScenaApi;
+}
+
+/**
+ * Creates a scena widget factory.
+ *
+ * Returns an object with `mount` and `unmount` methods
+ * for managing the widget lifecycle in the DOM.
+ *
+ * @example
+ * ```ts
+ * const scena = useScena();
+ * const instance = await scena.mount({ video: { src: 'video.mp4' } });
+ * // later...
+ * await scena.unmount(instance);
+ * ```
+ */
+declare function useScena(): UseScenaReturns;
+
+/**
+ * Creates a reactive config store for the scena widget.
+ *
+ * Provides getter, setter, and deep-merge methods for managing
+ * the widget configuration at runtime.
+ *
+ * @param initial - The initial widget configuration.
+ * @returns A reactive config store with `current`, `getConfig`, `setConfig`, and `mergeConfig`.
+ */
+declare function useScenaConfig(initial: ScenaConfig): UseScenaConfigReturns;
+
+/**
+ * Manages runtime config overrides via named layers and a deep-merge strategy.
+ *
+ * Each layer is identified by name and merged in a fixed order
+ * (responsive → preview), so higher-priority layers always win.
+ *
+ * @param config - The reactive config store to overlay overrides on.
+ * @returns A reactive `resolved` config and methods to `set`/`resolve` overrides.
+ */
+declare function useScenaOverrides(config: UseScenaConfigReturns): UseScenaOverridesReturns;
+
+/**
+ * Manages the preview mode feature for the scena widget.
+ *
+ * When active, applies preview-specific config overrides (e.g. preview styles)
+ * on top of the base config. Stops preview on video container click.
+ *
+ * @param config - The reactive config store.
+ * @param configOverrides - The config overrides manager.
+ * @param eventEmitter - The shared event bus for emitting preview events.
+ * @returns Methods to apply/start/stop preview and a reactive API.
+ */
+declare function useScenaPreview(config: UseScenaConfigReturns, configOverrides: UseScenaOverridesReturns, eventEmitter: ScenaEventEmitter): UseScenaPreviewReturns;
+
+/**
+ * Manages the show/hide visibility feature for the scena widget.
+ *
+ * Reads initial visibility settings from config and provides
+ * `show`/`hide` methods to toggle the widget at runtime.
+ *
+ * @param config - The reactive config store.
+ * @param eventEmitter - The shared event bus for emitting visibility events.
+ * @returns Methods to apply initial state, and a reactive visibility API.
+ */
+declare function useScenaVisibility(config: UseScenaConfigReturns, eventEmitter: ScenaEventEmitter): UseScenaVisibilityReturns;
+
+/**
+ * Manages responsive breakpoint overrides for the scena widget.
+ *
+ * Listens to viewport width changes via `matchMedia` and applies
+ * the matching breakpoint's component overrides as a named layer
+ * in the overrides system (below preview priority).
+ *
+ * @param config - The reactive config store.
+ * @param configOverrides - The config overrides manager.
+ * @returns Methods to apply/destroy and a reactive API with activeBreakpoint.
+ */
+declare function useScenaResponsive(config: UseScenaConfigReturns, configOverrides: UseScenaOverridesReturns): UseScenaResponsiveReturns;
+
+/**
+ * Returns the custom element constructor if it has already been registered.
+ *
+ * @returns The registered `CustomElementConstructor`, or `undefined` if not yet defined.
+ */
+declare function getScenaElement(): CustomElementConstructor | undefined;
+/**
+ * Registers the `<scena-video-widget>` custom element in the browser.
+ *
+ * Safe to call multiple times — skips registration if the element is already defined.
+ */
+declare function defineScenaElement(): void;
+
+/** The HTML tag name used for the scena custom element. */
+type ScenaElementTag = 'scena-video-widget';
+
+/**
+ * SSR-safe `HTMLElement` constructor.
+ *
+ * On the server `HTMLElement` is undefined, which would throw at module
+ * evaluation time when used as a base class. Falling back to an empty stub
+ * lets the module be imported in SSR environments (Nuxt, Next, etc.) without
+ * forcing consumers to client-only the import itself.
+ */
+declare const SAFE_HTML_ELEMENT: typeof HTMLElement;
+
+/**
+ * Custom HTML element that wraps the scena video widget.
+ *
+ * Register via {@link defineScenaElement}, then use as `<scena-video-widget>` in HTML.
+ * Dispatches `scena:mount` and `scena:unmount` custom events on the element.
+ *
+ * @example
+ * ```ts
+ * defineScenaElement();
+ * const el = document.createElement('scena-video-widget');
+ * document.body.appendChild(el);
+ * const instance = await el.mount({ video: { src: 'video.mp4' } });
+ * ```
+ */
+declare class ScenaElement extends SAFE_HTML_ELEMENT {
+    static readonly tagName: "scena-video-widget";
+    private _instance;
+    private _scena;
+    private _connected;
+    /** Mount promise; concurrent calls share this instead of racing. */
+    private _mountPending;
+    /** Unmount promise; concurrent calls share this instead of racing. */
+    private _unmountPending;
+    /** The scena factory used to create and destroy the widget. */
+    get scena(): UseScenaReturns | null;
+    /** The mounted widget instance, or `null` if not yet mounted. */
+    get instance(): ScenaInstance | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Mounts the scena widget inside this custom element.
+     *
+     * If already mounted, updates the config instead.
+     * If a mount or unmount is in flight, waits for it before proceeding —
+     * concurrent calls share the same promise instead of racing.
+     * Dispatches a `scena:mount` CustomEvent with the instance as `detail`.
+     *
+     * @param config - Widget configuration.
+     * @returns A promise resolving with the {@link ScenaInstance}.
+     */
+    mount(config: ScenaConfig): Promise<ScenaInstance>;
+    private _mount;
+    /**
+     * Unmounts the scena widget and dispatches a `scena:unmount` event.
+     * No-op if the widget is not currently mounted.
+     * Concurrent calls share the same in-flight promise.
+     */
+    unmount(): Promise<void>;
+    private _unmount;
+}
+
+/** Svelte context shared across all scena child components. */
+interface ScenaContext {
+    /** Widget-wide event bus. */
+    eventEmitter: ScenaEventEmitter;
+    /** Trigger the component mount lifecycle. */
+    mount: () => void;
+    /** Trigger the component unmount lifecycle. */
+    unmount: () => void;
+}
+
+/**
+ * Svelte context pair for sharing {@link ScenaContext} across the component tree.
+ *
+ * - `getScenaContext` — retrieve the context in a child component.
+ * - `setScenaContext` — provide the context in a parent component.
+ */
+declare const getScenaContext: () => ScenaContext;
+declare const setScenaContext: (context: ScenaContext) => ScenaContext;
+
+export { ComponentAriaHaspopup, ComponentAriaPressed, ComponentPlacement, ComponentPosition, ComponentShape, ComponentSize, OverrideLayer, ScenaButtonAriaHaspopup, ScenaButtonAriaPressed, ScenaButtonShape, ScenaButtonType, ScenaButtonVariant, ScenaCtaButtonPlacement, ScenaElement, ScenaEvent, ScenaVideoCrossOrigin, ScenaVideoPreload, ScenaVideoProgressVariant, ScenaVideoState, defineScenaElement, getScenaContext, getScenaElement, getScenaVideoContext, scenaProgressCircleThicknessMap, scenaProgressLineThicknessMap, setScenaContext, setScenaVideoContext, useEventEmitter, useProgressCircle, useProgressLine, useScena, useScenaConfig, useScenaOverrides, useScenaPreview, useScenaResponsive, useScenaVisibility, useVideoController };
+export type { ComponentAriaProps, ComponentClasses, ComponentSnippet, ComponentSnippetReturn, ComponentStyles, ScenaApi, ScenaButtonComponentClasses, ScenaButtonComponentStyles, ScenaButtonElements, ScenaButtonEvents, ScenaButtonProps, ScenaButtonSnippets, ScenaCloseButtonComponentClasses, ScenaCloseButtonComponentStyles, ScenaCloseButtonProps, ScenaCloseButtonRef, ScenaComponents, ScenaConfig, ScenaConfigFeatures, ScenaConfigOverrides, ScenaContainerCustomClasses, ScenaContainerCustomStyles, ScenaContainerProps, ScenaContainerRef, ScenaContainerSnippets, ScenaContext, ScenaCtaButtonAdaptive, ScenaCtaButtonComponentClasses, ScenaCtaButtonComponentStyles, ScenaCtaButtonProps, ScenaCtaButtonRef, ScenaElementTag, ScenaEventEmitter, ScenaEventHandler, ScenaEventMap, ScenaFeatures, ScenaIconCustomClasses, ScenaIconCustomStyles, ScenaIconElements, ScenaIconProps, ScenaIconSnippets, ScenaInstance, ScenaLoaderCustomClasses, ScenaLoaderCustomStyles, ScenaLoaderElements, ScenaLoaderProps, ScenaOverrides, ScenaPreviewApi, ScenaPreviewConfig, ScenaProgressCircleComponentClasses, ScenaProgressCircleComponentStyles, ScenaProgressCircleElements, ScenaProgressCircleEvents, ScenaProgressCircleProps, ScenaProgressComponentThickness, ScenaProgressLineComponentClasses, ScenaProgressLineComponentStyles, ScenaProgressLineElements, ScenaProgressLineEvents, ScenaProgressLineProps, ScenaProgressThickness, ScenaProps, ScenaRef, ScenaResponsiveApi, ScenaResponsiveConfig, ScenaTarget, ScenaVideoCallbacks, ScenaVideoComponentClasses, ScenaVideoComponentStyles, ScenaVideoContainerCustomClasses, ScenaVideoContainerCustomStyles, ScenaVideoContainerProps, ScenaVideoContainerRef, ScenaVideoContainerSnippets, ScenaVideoContext, ScenaVideoControlsComponentAria, ScenaVideoControlsComponentClasses, ScenaVideoControlsComponentStyles, ScenaVideoControlsProps, ScenaVideoControlsRef, ScenaVideoData, ScenaVideoEventOptions, ScenaVideoEventOptionsWithError, ScenaVideoEventOptionsWithEvent, ScenaVideoLoaderComponentClasses, ScenaVideoLoaderComponentStyles, ScenaVideoLoaderProps, ScenaVideoLoaderRef, ScenaVideoMethods, ScenaVideoProgressComponentClasses, ScenaVideoProgressComponentStyles, ScenaVideoProgressComponentThickness, ScenaVideoProgressProps, ScenaVideoProgressRef, ScenaVideoProgressThickness, ScenaVideoProgressThicknessMap, ScenaVideoProps, ScenaVideoRef, ScenaVideoSnippets, ScenaVideoVolumeComponentAria, ScenaVideoVolumeComponentClasses, ScenaVideoVolumeComponentStyles, ScenaVideoVolumeProps, ScenaVideoVolumeRef, ScenaVisibilityApi, ScenaVisibilityConfig, UseProgressCircleEvents, UseProgressCircleProps, UseProgressCircleReturn, UseProgressCircleReturnEvents, UseProgressLineEvents, UseProgressLineProps, UseProgressLineReturn, UseProgressLineReturnEvents, UseScenaConfigReturns, UseScenaOverridesReturns, UseScenaPreviewOptions, UseScenaPreviewReturns, UseScenaResponsiveReturns, UseScenaReturns, UseScenaVisibilityReturns, UseVideoControllerOptions, UseVideoControllerReturns };