@kromatv/sdk 0.1.39-canary.3579809

package/types/ui/src/components/organisms/player/lib/nav.d.ts

@@ -0,0 +1,41 @@
+import type { PlayerFlags } from '#ui/components/organisms/player/types';
+import type { RemoteKey } from '#ui/lib/remote-keys';
+/**
+ * The unified input model. ONE navigation contract drives both the D-pad (TV
+ * remote) and the mouse (hover = focus, click = OK), so every control responds
+ * to both without per-platform branches (§15). Logical keys come from
+ * `resolveRemoteKey`, shared with the rest of the TV shell.
+ */
+export type { RemoteKey } from '#ui/lib/remote-keys';
+/** The vertical zones the player is split into (§3), top to bottom. The bottom
+ * "À suivre" zone is the {@link Overlay} `sheet`, opened by ▼ from the controls
+ * (never on hover).
+ *
+ * `back` is the top chrome's round Back button. It is a ZONE rather than a
+ * control because this player drives its own D-pad chain instead of the
+ * spatial navigator: anything not named here cannot be reached at all, which
+ * is exactly how the Back button spent its life unreachable by ▲. */
+export type Zone = 'back' | 'resume' | 'progress' | 'controls';
+/** An open panel that captures navigation until dismissed. */
+export type Overlay = 'settings' | 'audio' | 'subtitles' | 'sheet' | null;
+/**
+ * Every focusable control in the middle row, in visual order. The cluster stops
+ * (`volume`, `pip`, `fullscreen`) are gated by feature flags a disabled flag
+ * removes the control AND its focus stop (§4c), computed by {@link controlOrder}.
+ */
+export type ControlId = 'rewind' | 'play' | 'forward' | 'next' | 'volume' | 'subtitles' | 'audio' | 'settings' | 'cast' | 'pip' | 'fullscreen';
+/** Build the present control row from the flags + whether there's a next episode.
+ * Absent controls leave no gap and no trapped D-pad stop. */
+export declare function controlOrder(flags: PlayerFlags, hasNext: boolean): ControlId[];
+/**
+ * Imperative handle an open panel exposes so the player shell can route D-pad
+ * keys into it (useImperativeHandle). `onKey` returns true when the panel
+ * consumed the key (so the shell stops), false to let the shell handle it (e.g.
+ * an unhandled Back bubbles up to close the panel).
+ */
+export interface PanelHandle {
+    onKey(key: RemoteKey): boolean;
+    /** Tab's reading-order walk. Return false to hand the press back; omit it and
+     *  Tab arrives through `onKey` as a direction. */
+    onTab?(backwards: boolean): boolean;
+}

package/types/ui/src/components/organisms/player/lib/panel-header.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+export interface PanelHeader {
+    /** OK on the header: what the Back button does. */
+    activate: () => void;
+    /** Whether the header currently holds the focus. */
+    report: (focused: boolean) => void;
+}
+export declare function usePanelHeader(): PanelHeader | null;
+export declare function PanelHeaderProvider({ value, children, }: Readonly<{
+    value: PanelHeader;
+    children: ReactNode;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/lib/panel-slide.d.ts

@@ -0,0 +1,16 @@
+/** How long the picture takes to reach the settings card, and the panel to
+ *  reach its edge. One number for both, so the two read as one movement. */
+export declare const CARD_MS = 340;
+export interface PanelSlide {
+    mounted: boolean;
+    shown: boolean;
+    /** Bumped on every open. Keyed on, it starts the panel's own state fresh
+     *  while the wrapper stays mounted long enough for the exit to play. */
+    run: number;
+}
+/**
+ * Keeps the settings panel in the tree while it leaves, so the picture expands
+ * from under a panel that is still sliding out rather than one that vanished a
+ * frame earlier.
+ */
+export declare function usePanelSlide(open: boolean): PanelSlide;

package/types/ui/src/components/organisms/player/lib/player-keys.d.ts

@@ -0,0 +1,58 @@
+import type { RefObject } from 'react';
+import type { PlayerNav } from '#ui/components/organisms/player/hooks/use-player-nav';
+import type { SeekPress } from '#ui/components/organisms/player/hooks/use-seek-nudge';
+import type { PlayerController, PlayerFlags } from '#ui/components/organisms/player/types';
+import type { RemoteKey } from '#ui/lib/remote-keys';
+import type { PanelHandle } from './nav';
+export interface PlayerKeysParams {
+    nav: PlayerNav;
+    controller: PlayerController;
+    flags: PlayerFlags;
+    panelRef: RefObject<PanelHandle | null>;
+    locked: boolean;
+    /** The keyboard's seek: arrows and j / l go through the nudge machine, so a
+     *  held key ramps, a run of taps adds up and the stage can echo them. */
+    seekNudge(dir: -1 | 1, press: SeekPress): void;
+    /** The keyboard's volume: ArrowUp / Down land here so the stage can echo the
+     *  level, rather than on the controller directly. */
+    setVolume(level: number): void;
+    intro?: {
+        active: boolean;
+        onSkip: () => void;
+    };
+    /** The resumed-at prompt while it is up. It takes Back (the keyboard's Escape)
+     *  and nothing else: unlike the skip pill it must not answer OK, or a film that
+     *  opened where it was left would restart on a press of play. */
+    resume?: {
+        active: boolean;
+        onDismiss: () => void;
+    };
+    credits?: {
+        active: boolean;
+        onKey: (key: RemoteKey) => boolean;
+    };
+    /** The end-of-film screen. While it is up there is no film left to drive, so
+     *  it takes every key rather than getting first refusal on some. */
+    postPlay?: {
+        active: boolean;
+        onKey: (key: RemoteKey) => void;
+    };
+}
+/**
+ * Route one logical remote key (§3, §15). While locked only Back / OK get
+ * through, and both mean "dismiss". The end-of-film screen takes everything.
+ * Then the open panel, then the three things drawn over the film: the resume
+ * prompt, the skip pill and the credits card. Only after those does a hidden
+ * chrome reveal and swallow the key (§16), unless the key drives the film
+ * itself, or is the Back that leaves.
+ */
+export declare function routeRemoteKey(p: Readonly<PlayerKeysParams>, key: RemoteKey): void;
+/**
+ * Tab and Shift+Tab, which only a keyboard has.
+ *
+ * The chrome is NOT on the spatial navigator (it cannot be, since tvOS's own
+ * focus engine would adopt it in parallel with this machine, see
+ * lib/virtual-focus), and no single direction reaches the back button, the seek
+ * bar, every control and the sheet in turn.
+ */
+export declare function routeTab(p: Readonly<PlayerKeysParams>, backwards: boolean): void;

package/types/ui/src/components/organisms/player/lib/seek-track.d.ts

@@ -0,0 +1,19 @@
+/** Just enough of a chapter to lay one out. */
+interface TrackSegment {
+    startMs: number;
+    endMs: number;
+}
+declare const SEGMENT_GAP = 4;
+/** Each segment's width in px: the track's width, less the gaps, shared out in
+ * proportion to how long each chapter runs. This is what the layout produces
+ * from `flex={span}`, computed here so the maths can be checked without one. */
+declare function segmentWidths(segs: readonly TrackSegment[], trackWidth: number): number[];
+/** Where a moment in the film sits on the track, in px from its left edge.
+ * A time inside a gap (there are none - gaps sit exactly on chapter boundaries)
+ * resolves to the boundary itself. */
+declare function offsetAt(ms: number, segs: readonly TrackSegment[], trackWidth: number): number;
+/** The inverse: the moment under a pixel. A press in a gap lands on the start of
+ * the segment after it, which is the chapter boundary the user aimed at. */
+declare function msAtOffset(x: number, segs: readonly TrackSegment[], trackWidth: number): number;
+export type { TrackSegment };
+export { msAtOffset, offsetAt, SEGMENT_GAP, segmentWidths };

package/types/ui/src/components/organisms/player/lib/stage-card.d.ts

@@ -0,0 +1,31 @@
+import type { PlaneRect } from '../types';
+/** A rectangle on the stage, as fractions of the stage's own width and height. */
+export interface StageRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface StageCard {
+    /** The picture's box on the un-shrunken stage, or null while the stage is
+     *  unmeasured or the media has not declared its shape - the surface fills the
+     *  stage then, which is what the shrink assumed before aspects were known. */
+    picture: StageRect | null;
+    scale: number;
+    /** The horizontal transform origin, as a fraction of the stage width, that
+     *  makes `scale` land the picture on the card. The vertical origin is always
+     *  the middle: the picture is centred there, and the card is too. */
+    origin: number;
+    /** The same landing expressed for a scale about the DEFAULT origin: how far
+     *  to move the stage sideways afterwards, as a fraction of its width. What
+     *  Android uses, because a `transformOrigin` blanks a transformed view there. */
+    shift: number;
+    /** The same card as viewport fractions, for a native plane that cannot be
+     *  transformed and is moved with `setPlaneRect` instead. */
+    rect: PlaneRect;
+}
+/** The picture on a `width` x `height` stage, and the card it shrinks into
+ * beside the settings panel. `aspect` is the picture's display ratio (w/h); with
+ * none the picture is the whole stage, which is what the shrink used to assume.
+ * The two sizes are only ever read as a ratio, so their unit does not matter. */
+export declare function stageCard(width: number, height: number, aspect?: number): StageCard;

package/types/ui/src/components/organisms/player/lib/style.d.ts

@@ -0,0 +1,41 @@
+import { type ColorValue } from '#ui/core';
+export declare const FOCUS_SCALE = 1.07;
+export interface SeekBarPaint {
+    track: ColorValue;
+    buffered: ColorValue;
+    played: readonly [string, string];
+    playheadHalo: string;
+}
+/** The seek bar's paints, shared with the mobile touch scrub bar so both draw
+ *  the identical track. A function, so the accent follows the theme. */
+export declare const seekBarPaint: ({ colors }: import('#ui/core/theme').Theme) => SeekBarPaint;
+export declare const seekBar: (owner?: import("#ui/core/theme").ThemeRuntime) => SeekBarPaint;
+export declare const SCRIM = "rgba(0, 0, 0, 0.45)";
+export declare const playerStyle: import("../../../../core/styles").Styles<{
+    readonly eyebrow: {
+        readonly font: "ui";
+        readonly fontSize: 12;
+        readonly fontWeight: "700";
+        readonly letterSpacing: 1.68;
+        readonly textTransform: "uppercase";
+        readonly color: "textDim";
+    };
+    readonly panel: {
+        readonly absolute: true;
+        readonly top: 0;
+        readonly bottom: 0;
+        readonly right: 0;
+        readonly z: 42;
+        readonly bg: "playerSurface/94";
+    };
+    readonly body: {
+        readonly font: "ui";
+        readonly fontSize: 15;
+        readonly color: "text";
+    };
+    readonly meta: {
+        readonly font: "ui";
+        readonly fontSize: 13;
+        readonly color: "text/55";
+    };
+}>;

package/types/ui/src/components/organisms/player/lib/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const STAGE_STYLE_ID = "kroma-player-stage-style";
+/** Idempotent: injects the stage-surface rule once per document. */
+export declare function injectStageStyles(): void;

package/types/ui/src/components/organisms/player/lib/subtitle-appearance.d.ts

@@ -0,0 +1,54 @@
+import type { TextStyle, ViewStyle } from 'react-native';
+import { type StyleScope } from '#ui/core';
+/**
+ * Subtitle appearance (§8): size, colour, edge, font, opacity, background and
+ * window, persisted to localStorage. The option sets are CEA-708 (FCC-required,
+ * graded by Samsung's TV certification). Trimming one is a certification defect.
+ */
+/** Hold a 0-100 percentage inside its range: an rgba() alpha outside 0..1 is an
+ * invalid colour, and an invalid colour drops the whole declaration. */
+export declare const clampPct: (n: number) => number;
+export type SubSize = 'sm' | 'md' | 'lg' | 'xl';
+export type SubEdge = 'none' | 'raised' | 'depressed' | 'uniform' | 'shadow';
+export type SubFont = 'default' | 'monoSerif' | 'propSerif' | 'monoSans' | 'propSans' | 'casual' | 'cursive' | 'smallCaps';
+export interface SubtitleAppearance {
+    size: SubSize;
+    color: string;
+    edge: SubEdge;
+    font: SubFont;
+    /** 20–100 (§8). */
+    opacity: number;
+    bgColor: string;
+    /** 0–100; 0 = no background. */
+    bgOpacity: number;
+    windowColor: string;
+    /** 0–100; 0 = no window. */
+    windowOpacity: number;
+}
+export declare const SUB_COLORS: readonly ["#FFFFFF", "#000000", "#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF", "#00FFFF"];
+/** Deliberately not CEA-708's defaults (white on an opaque black box): a film
+ * should open with captions that sit on the picture, not a slab across it. */
+export declare const DEFAULT_SUB_APPEARANCE: SubtitleAppearance;
+/** CEA-708 order, also the order ◀▶ steps through them. The single source of
+ * truth: a treatment missing here would compile but be unreachable. */
+export declare const SUB_EDGES: readonly SubEdge[];
+export declare const SUB_FONTS: readonly SubFont[];
+/** Bring a stored choice onto the current model, mapping retired option names
+ * (`outline` → `uniform`, `box` → `none` edge + background) so a viewer's old
+ * choice isn't silently lost. */
+export declare function migrateAppearance(raw: unknown): SubtitleAppearance;
+/** Persisted subtitle appearance. SSR-safe: starts from defaults (matching the
+ * server render), then hydrates from localStorage on the client. */
+export declare function useSubtitleAppearance(): [
+    SubtitleAppearance,
+    (next: Partial<SubtitleAppearance>) => void
+];
+/** `#RRGGBB` + a 0–100 opacity as an rgba() the RN and DOM sides both take. */
+export declare function withOpacity(hex: string, pct: number): string;
+/** The caption window's style: the band the cue block sits in. A ViewStyle,
+ * not a TextStyle: RN's stricter native typings require it for a container. */
+export declare function subtitleWindowStyle(style: SubtitleAppearance, scope?: StyleScope): ViewStyle;
+/** The text style for a subtitle line, from the viewer's appearance choice.
+ * The edge treatment is the one piece that differs per platform (see
+ * subtitle-edge.ts); everything else is one set of numbers. */
+export declare function subtitleStyle(style: SubtitleAppearance, scope?: StyleScope): TextStyle;

package/types/ui/src/components/organisms/player/lib/subtitle-name.d.ts

@@ -0,0 +1,6 @@
+import type { Translate } from '@kromatv/i18n';
+import type { PlayerSub } from '#ui/components/organisms/player/types';
+/** What a row calls a subtitle track: a generated track's own label, else the
+ * language in the viewer's locale, followed by the track's own title where the
+ * file gave it one (`Anglais · SDH`). */
+export declare function subtitleName(t: Translate, sub: PlayerSub | null | undefined): string;

package/types/ui/src/components/organisms/player/lib/surface-shrink.d.ts

@@ -0,0 +1,17 @@
+import type { PlayerSurface } from '../types';
+/**
+ * The hold the settings card can take on a video surface.
+ *
+ * `transform` scales the stage the surface sits in - an in-page `<video>`, a
+ * `<VideoView>`, the libVLC TextureView - about the origin `stageCard` picked,
+ * and carries everything drawn on the picture down with it. `plane` is a
+ * hardware plane BEHIND the page, which React does not lay out at all and which
+ * moves through `setPlaneRect`.
+ *
+ * There is no third answer. A native view React lays out takes a transform only
+ * if it draws inside the view hierarchy, so a surface that would need its BOX
+ * moved instead (an Android SurfaceView) is given a texture-backed one on the
+ * shell side rather than a shrink of its own.
+ */
+export type SurfaceShrink = 'transform' | 'plane';
+export declare function surfaceShrink(surface: PlayerSurface): SurfaceShrink;

package/types/ui/src/components/organisms/player/lib/tab-walk.d.ts

@@ -0,0 +1,21 @@
+import type { ControlId, Zone } from './nav';
+export type TabStop = {
+    zone: 'back';
+} | {
+    zone: 'resume';
+} | {
+    zone: 'progress';
+} | {
+    zone: 'controls';
+    control: ControlId;
+} | {
+    zone: 'sheet';
+};
+export interface TabWalk {
+    zone: Zone;
+    control: ControlId | null;
+    drawnControls: readonly ControlId[];
+    sheetHasItems: boolean;
+    resumeShown: boolean;
+}
+export declare function nextTabStop(at: TabWalk, backwards: boolean): TabStop | null;

package/types/ui/src/components/organisms/player/media-types.d.ts

@@ -0,0 +1,55 @@
+/** What the chrome renders about a film, declared here rather than imported from
+ * a wire schema: the player is a design-system component and must not move when
+ * a payload does. Each one is structurally what `@kromatv/client` sends, so an
+ * app passes its parsed objects straight in.
+ */
+/** A stretch of the film the server recognised. */
+export interface PlayerMarker {
+    kind: 'intro' | 'credits';
+    startMs: number;
+    endMs: number;
+}
+/** One selectable audio track. */
+export interface PlayerAudioTrack {
+    index: number;
+    codec: string;
+    channels: number | null;
+    language: string | null;
+    title?: string | null;
+    default: boolean;
+}
+/** The picture, as the stats panel reports it. */
+export interface PlayerVideoTrack {
+    codec: string;
+    width: number | null;
+    height: number | null;
+    hdr: boolean;
+    bitDepth: number | null;
+    hdrFormat?: 'hdr10' | 'hdr10Plus' | 'dolbyVision' | 'hlg' | null;
+}
+/** What a viewer can report about the thing they are watching. */
+export type PlayerReportCategory = 'metadata' | 'video' | 'audio' | 'subtitles' | 'other';
+/** Which kinds of subtitle generation the server offers for this film. */
+export interface PlayerSubCapabilities {
+    transcribe: boolean;
+    translate: boolean;
+}
+/** A subtitle generation the panel is following. `id` and `subId` are opaque to
+ * the chrome, which only hands them back to the host's callbacks. */
+export interface PlayerSubtitleGeneration {
+    id: string;
+    mode: 'transcribe' | 'translate';
+    lang: string | null;
+    stage: string;
+    status: 'running' | 'done' | 'error';
+    progress: number;
+    etaSec: number | null;
+    error: string | null;
+    subId: string | null;
+}
+/** The little the stats panel reads off the film itself. */
+export interface PlayerStatsItem {
+    title: string;
+    container: string | null;
+    video: PlayerVideoTrack | null;
+}

package/types/ui/src/components/organisms/player/parts/control-cluster/circle-control.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+import type { ControlId } from '#ui/components/organisms/player/lib/nav';
+interface CircleProps {
+    id: ControlId;
+    diameter: number;
+    focused: boolean;
+    label: string;
+    onActivate: (id: ControlId) => void;
+    onFocus: (id: ControlId) => void;
+    children: ReactNode;
+}
+export declare function Circle({ id, diameter, focused, label, onActivate, onFocus, children, }: Readonly<CircleProps>): import("react").JSX.Element;
+export type CircleId = Exclude<ControlId, 'play' | 'volume'>;
+interface CircleControlProps {
+    id: CircleId;
+    focused: boolean;
+    scale: number;
+    pipActive: boolean;
+    fullscreen: boolean;
+    onActivate: (id: ControlId) => void;
+    onFocus: (id: ControlId) => void;
+}
+export declare const CircleControl: import("react").MemoExoticComponent<({ id, focused, scale, pipActive, fullscreen, onActivate, onFocus, }: Readonly<CircleControlProps>) => import("react").JSX.Element>;
+export {};

package/types/ui/src/components/organisms/player/parts/control-cluster/control-cluster.d.ts

@@ -0,0 +1,35 @@
+import { type ChromeMetrics } from '#ui/components/organisms/player/lib/metrics';
+import type { ControlId } from '#ui/components/organisms/player/lib/nav';
+export interface ControlClusterProps {
+    focused: ControlId | null;
+    playing: boolean;
+    muted: boolean;
+    volume: number;
+    /** The loudest the rail reaches. Above 1 the last quarter is a boost zone
+     *  past a notch at 100%. Defaults to 1. */
+    volumeMax?: number;
+    pipActive: boolean;
+    fullscreen: boolean;
+    /** How the row fits the stage it is drawn on (see ../lib/metrics): WHICH
+     *  controls there is room for, the scale they are drawn at, and whether the
+     *  volume rail survived. The list is not a separate prop because the row and
+     *  the nav machine must agree on it exactly - they read the same one. */
+    metrics: ChromeMetrics;
+    /** Run a control (mouse click shares this with D-pad OK). */
+    onActivate: (id: ControlId) => void;
+    /** Hover moves focus (§15). */
+    onFocus: (id: ControlId) => void;
+    onVolume: (v: number) => void;
+}
+/**
+ * The middle control row (§4): centered transport (rewind/play/forward) plus the
+ * feature-flagged cluster (next/volume/subtitles/audio/settings/cast/pip/
+ * fullscreen). Renders exactly `metrics.controls` (already filtered by feature
+ * flags and available width), so it never draws a dead button, and always fits
+ * on one line by shrinking then shedding controls (see ../lib/metrics
+ * `chromeMetrics`); a shed control is reported via `metrics.overflow`.
+ *
+ * Memoized: every prop is stable between playback ticks, so the row skips the
+ * ~4 Hz timeupdate re-renders the rest of the chrome makes.
+ */
+export declare const ControlCluster: import("react").MemoExoticComponent<({ focused, playing, muted, volume, volumeMax, pipActive, fullscreen, metrics, onActivate, onFocus, onVolume, }: Readonly<ControlClusterProps>) => import("react").JSX.Element>;

package/types/ui/src/components/organisms/player/parts/control-cluster/index.d.ts

@@ -0,0 +1 @@
+export * from './control-cluster';

package/types/ui/src/components/organisms/player/parts/control-cluster/volume-control.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+import { type Px } from '#ui/components/organisms/player/lib/metrics';
+export declare function volumeGlyph(level: number, size: number): ReactNode;
+export declare function VolumeControl({ focused, muted, volume, max, px, onFocus, onToggle, onVolume, label, muteLabel, }: Readonly<{
+    focused: boolean;
+    muted: boolean;
+    volume: number;
+    max: number;
+    px: Px;
+    onFocus: () => void;
+    onToggle: () => void;
+    onVolume: (v: number) => void;
+    label: string;
+    muteLabel: string;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/credits-card/credits-card.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Minimal shape the credits card needs from the up-next item. Declared locally
+ * (rather than importing `UpNextItem`) so this file never hard-depends on the
+ * sheet module's build order; the orchestrator passes a compatible object.
+ */
+export interface CreditsCardItem {
+    title: string;
+    /** The "kind" line under the title (e.g. "S1 E4" or a genre). */
+    subtitle?: string;
+    posterUrl?: string | null;
+}
+export interface CreditsCardProps {
+    item: CreditsCardItem;
+    /** Remaining whole seconds before autoplay (e.g. 5..0). */
+    secondsLeft: number;
+    /** Countdown length the ring drains against (e.g. 5). */
+    total: number;
+    playFocused: boolean;
+    cancelFocused: boolean;
+    /** The chrome's scale (see ../lib/metrics). 1 on a television stage. */
+    scale?: number;
+    onPlay: () => void;
+    onCancel: () => void;
+}
+export declare function CreditsCard({ item, secondsLeft, total, playFocused, cancelFocused, scale, onPlay, onCancel, }: Readonly<CreditsCardProps>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/credits-card/index.d.ts

@@ -0,0 +1 @@
+export * from './credits-card';

package/types/ui/src/components/organisms/player/parts/icons.d.ts

@@ -0,0 +1,42 @@
+import { type IconName } from '#ui/components/atoms/icon';
+import type { ColorToken } from '#ui/core';
+type P = Readonly<{
+    size?: number;
+    thickness?: number;
+    color?: ColorToken | (string & {});
+}>;
+export declare const IconPlay: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconPause: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const BACK_10_ICON: IconName;
+export declare const FWD_10_ICON: IconName;
+export declare const IconBack10: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconFwd10: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconNext: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconVolHigh: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconVolLow: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconVolMin: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconMute: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconSubtitles: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconAudioTrack: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconGear: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconPip: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconCast: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconFullscreen: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconFullscreenExit: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconForward: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconExpand: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconCollapse: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconClose: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconOk: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconAi: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconDelete: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconStats: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconQuality: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconAudioFilter: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconAppearance: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconSpeed: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconReport: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconStop: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconEndsAt: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export declare const IconRestart: ({ size, thickness, color }: P) => import("react").JSX.Element;
+export {};

package/types/ui/src/components/organisms/player/parts/post-play/index.d.ts

@@ -0,0 +1 @@
+export { POST_PLAY_ART_W, PostPlay, type PostPlayFocus, type PostPlayItem } from './post-play';

package/types/ui/src/components/organisms/player/parts/post-play/post-play.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The film offered once this one is over. Declared here rather than reusing
+ * `UpNextItem` because a full-bleed hero wants what a card does not: art at
+ * stage width, a rating and a synopsis.
+ */
+export interface PostPlayItem {
+    id: string;
+    title: string;
+    /** The line under the title: year, runtime, codec, already formatted. */
+    subtitle?: string;
+    /** Out of ten. Drawn as its own amber mark ahead of {@link subtitle}. */
+    rating?: number | null;
+    /** Synopsis. Drawn in at most three lines. */
+    overview?: string | null;
+    /** Wide art, requested at {@link POST_PLAY_ART_W}. */
+    artUrl?: string | null;
+}
+export type PostPlayFocus = 'play' | 'home';
+export interface PostPlayProps {
+    item: PostPlayItem;
+    /** The film that just ended, named at the top so the screen says where the
+     *  viewer is before it says where they could go. */
+    finished: string;
+    /** Which control wears the ring. The player's nav machine owns it, so both
+     *  buttons are controlled and neither is a platform focus target. */
+    focus: PostPlayFocus;
+    /** The stage's width, which is what picks the type tier: this is a page
+     *  rather than chrome, so it is typed for three metres or for a desk. */
+    stageWidth: number;
+    onPlay: () => void;
+    onHome: () => void;
+}
+/** The width the hero is drawn at, and so the width to ask the server for. */
+export declare const POST_PLAY_ART_W = 1920;
+/**
+ * The end of a film (§10): a full screen naming what just finished, offering
+ * the next one to watch, and holding the way back to the home screen. It
+ * replaces the chrome rather than sitting over it, and it is the only thing the
+ * remote can reach while it is up.
+ */
+export declare function PostPlay({ item, finished, focus, stageWidth, onPlay, onHome, }: Readonly<PostPlayProps>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/resume-prompt/index.d.ts

@@ -0,0 +1 @@
+export * from './resume-prompt';

package/types/ui/src/components/organisms/player/parts/resume-prompt/resume-prompt.d.ts

@@ -0,0 +1,18 @@
+export interface ResumePromptProps {
+    /** The second playback opened on, drawn as the timecode it reads. */
+    at: number;
+    /** False plays the prompt out, after which it draws nothing. */
+    shown: boolean;
+    /** Whole seconds before the prompt leaves on its own; null draws no rule. */
+    secondsLeft?: number | null;
+    /** The window `secondsLeft` drains against. Defaults to the one
+     *  `useResumeNotice` counts. */
+    total?: number;
+    focused?: boolean;
+    /** The chrome's scale (see ../../lib/metrics). 1 on a television stage. */
+    scale?: number;
+    /** How high it sits above the bottom edge, in real pixels (already scaled). */
+    lift: number;
+    onStartOver: () => void;
+}
+export declare function ResumePrompt({ at, shown, secondsLeft, total, focused, scale, lift, onStartOver, }: Readonly<ResumePromptProps>): import("react").JSX.Element | null;

package/types/ui/src/components/organisms/player/parts/seek-bar/index.d.ts

@@ -0,0 +1 @@
+export * from './seek-bar';

package/types/ui/src/components/organisms/player/parts/seek-bar/seek-bar.d.ts

@@ -0,0 +1,22 @@
+import type { Chapter } from '#ui/components/organisms/player/types';
+import type { StoryboardTile } from '#ui/services/storyboard';
+export interface SeekBarProps {
+    cur: number;
+    dur: number;
+    /** How far ahead the backend holds, in absolute seconds. `null` when it has
+     *  none to report, and then the track carries no buffered fill at all. */
+    bufEnd: number | null;
+    seekPreview: number | null;
+    /** Empty = one continuous segment over the whole runtime. */
+    chapters: Chapter[];
+    tileAt: (sec: number) => StoryboardTile | null;
+    focused: boolean;
+    elapsed: string;
+    chapterLabel?: string;
+    total: string;
+    endsAt: string;
+    scale?: number;
+    onScrub: (sec: number) => void;
+    onScrubCommit: () => void;
+}
+export declare function SeekBar({ cur, dur, bufEnd, seekPreview, chapters, tileAt, focused, elapsed, chapterLabel, total, endsAt, scale, onScrub, onScrubCommit, }: Readonly<SeekBarProps>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/settings-panel/index.d.ts

@@ -0,0 +1 @@
+export * from './settings-panel';