tempest-react-sdk 0.55.0 → 0.57.0

package/dist/tempest-react-sdk.d.ts

@@ -242,7 +242,7 @@ export declare interface AIChatComposerHandle {
     getValue: () => string;
 }
 
-export declare interface AIChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_8> {
+export declare interface AIChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_9> {
     /** Called with the trimmed prompt. The field clears only when this does not throw. */
     onSend: (text: string) => void | Promise<void>;
     /**
@@ -313,7 +313,7 @@ export declare interface AIChatMessage {
     data?: Record<string, unknown>;
 }
 
-export declare interface AIChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_7> {
+export declare interface AIChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_8> {
     /** The transcript, **oldest first**. Never reordered by the component. */
     messages: readonly AIChatMessage[];
     /** Renders the composer when given. Receives the trimmed prompt. */
@@ -1221,7 +1221,7 @@ export declare interface AudioPlayerHandle {
     current: () => HTMLAudioElement | null;
 }
 
-export declare interface AudioPlayerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_4> {
+export declare interface AudioPlayerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_5> {
     /**
      * What to play — a URL, or a `Blob`/`File` straight from a recorder.
      *
@@ -1324,7 +1324,7 @@ export declare interface AudioRecorderOptions {
     onError?: (error: unknown) => void;
 }
 
-export declare interface AudioRecorderProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_5> {
+export declare interface AudioRecorderProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_6> {
     /**
      * Called once a recording is finished and (when asked) converted.
      *
@@ -1601,7 +1601,7 @@ export declare interface BarcodePoint {
  */
 export declare function BarcodeScanner({ onScan, formats, paused, detector, intervalMs, repeatDelayMs, torch, aspectRatio, locale, footer, unsupported, onError, className, ...rest }: BarcodeScannerProps): JSX.Element;
 
-export declare interface BarcodeScannerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_6> {
+export declare interface BarcodeScannerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_7> {
     /** Called for every accepted read — repeats of the same value are suppressed. */
     onScan: (result: BarcodeScanResult) => void;
     /** Symbologies to look for. Defaults to QR + EAN-13 + Code 128. */
@@ -2381,7 +2381,7 @@ export declare interface ChatComposerHandle {
     setValue: (text: string) => void;
 }
 
-export declare interface ChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_3> {
+export declare interface ChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_4> {
     /** Called with the trimmed text. The field clears only when this does not throw. */
     onSend: (text: string) => void | Promise<void>;
     /** Locale for the placeholder and the send label. Default `"pt-BR"`. */
@@ -2437,7 +2437,7 @@ export declare interface ChatMessage {
     data?: Record<string, unknown>;
 }
 
-export declare interface ChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_2> {
+export declare interface ChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_3> {
     /** The thread, **oldest first**. Never reordered by the component. */
     messages: readonly ChatMessage[];
     /** Author id treated as "own" — decides side, colour and status ticks. */
@@ -5085,6 +5085,17 @@ export declare const DEFAULT_MAX_GAIN = 3;
  */
 export declare const DEFAULT_MODE_DURATION_FACTORS: Record<TravelMode, number>;
 
+/**
+ * The speed presets the player offers, and why they stop at 2×.
+ *
+ * The spec lets a browser drop the audio once `playbackRate` leaves a range it
+ * considers useful, and that limit varies by engine. These four sit inside every
+ * range measured, so the default control never silences a clip by accident. A
+ * caller who wants 4× can pass it — and should test it with sound on the
+ * browsers they support before promising it.
+ */
+export declare const DEFAULT_PLAYBACK_RATES: readonly number[];
+
 /**
  * COSE algorithms offered when the server sends no `pubKeyCredParams`, in
  * preference order.
@@ -5810,7 +5821,7 @@ export declare interface Filter {
  */
 export declare function FilterBar({ fields, value, onChange, locale, actions, className, ...rest }: FilterBarProps): JSX.Element;
 
-export declare interface FilterBarProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_12> {
+export declare interface FilterBarProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_13> {
     /** Fields the user may filter by. */
     fields: readonly FilterField[];
     /** Applied filters. Controlled. */
@@ -7854,6 +7865,43 @@ export declare interface LinkStats {
     fps: number;
     /** Round trip to the peer in milliseconds, or `null` before the first reading. */
     rttMs: number | null;
+    /**
+     * Uplink the transport estimates for this path, in kbps, or `null`.
+     *
+     * `null` and not `0`, because the two mean opposite things: no estimate yet
+     * is the normal state for the first seconds of every call and the permanent
+     * state on an engine that publishes none, while `0` is indistinguishable
+     * from a path that died. A consumer that reads absence as zero drops the
+     * quality at the start of every call.
+     *
+     * This is the field that separates "healthy at 2.5 Mbps" from "capped at
+     * 2.5 Mbps and drowning" — `kbps` reports the cap being honoured either
+     * way, while the queue behind it grows.
+     */
+    availableKbps: number | null;
+    /**
+     * What the encoder says is holding the picture back, or `null` for nothing.
+     *
+     * `"bandwidth"` wins over the other values when senders disagree, because
+     * it is the only one a lower cap answers. Reacting to bandwidth on a
+     * machine that is actually CPU-bound buys a worse picture and no relief.
+     *
+     * The spec's `"none"` is reported as `null`: a consumer should not have to
+     * know that one of the truthy strings means "nothing".
+     */
+    limitedBy: RTCQualityLimitationReason | null;
+    /**
+     * Whether the link is travelling through a TURN relay.
+     *
+     * On a self-hosted mesh this is the hosting bill: a relayed stream goes up
+     * and down through the machine somebody is paying for, and the person who
+     * picked 4K is not that somebody.
+     *
+     * Resolved only from the pair the transport **names**, never from a merely
+     * `succeeded` one — guessing the route from a pair that carries nothing
+     * would report a cost nobody is paying.
+     */
+    relayed: boolean;
 }
 
 /** Which media a sampler counts. */
@@ -8110,7 +8158,7 @@ export declare type MarkdownInline = {
     type: "break";
 };
 
-export declare interface MarkdownProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_11> {
+export declare interface MarkdownProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_12> {
     /** The Markdown source. */
     source: string;
     /**
@@ -8148,7 +8196,7 @@ export declare interface MarkdownProps extends Omit<HTMLAttributes<HTMLDivElemen
  */
 export declare function Masonry<T>({ items, children, itemKey, columns, gap, className, style, ...rest }: MasonryProps<T>): JSX.Element;
 
-export declare interface MasonryProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_10> {
+export declare interface MasonryProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_11> {
     /** What to lay out. */
     items: readonly T[];
     /** Render one card. */
@@ -8418,6 +8466,14 @@ export declare interface MeshPeer {
     connection: RTCPeerConnectionState;
     /** Inbound stream per slot name, `null` for a slot the peer is not sending. */
     streams: Record<string, MediaStream | null>;
+    /**
+     * The last sample for this link, when the mesh was asked to measure.
+     *
+     * Absent unless {@link PeerMeshOptions.stats} was given: measuring costs a
+     * `getStats()` per link per tick, and a mesh that shows no badge should not
+     * pay it.
+     */
+    stats?: LinkStats;
 }
 
 /** Encoder limits, before the room divides them. */
@@ -8440,6 +8496,21 @@ export declare interface MeshQuality {
     maxFramerate?: number;
     /** What a video encoder gives up first. */
     degradationPreference?: RTCDegradationPreference;
+    /**
+     * Which video slot decides whether `maintain-framerate` still holds.
+     *
+     * Without it the decision reads the **largest** cap across every video
+     * slot, which is right for a mesh whose slots are interchangeable and wrong
+     * for one where they are not. Somebody who picked fluidity was thinking
+     * about the screen — code, a spreadsheet, a video at 60 fps — and with only
+     * a camera on, that choice ends up being decided by a stream it was never
+     * about.
+     *
+     * Name the slot the choice was about and it decides alone. A slot the caps
+     * do not mention keeps the preference: nothing has been said about the
+     * thing being asked about, and a modest camera beside it is not an answer.
+     */
+    degradationAnchor?: string;
     /**
      * Total uplink to divide among the peers, in kbps.
      *
@@ -8493,6 +8564,37 @@ export declare type MeshSlotKind = "audio" | "video";
  */
 export declare type MeshState = "connecting" | "connected" | "reconnecting" | "failed" | "closed";
 
+/** Options for `createPeerMesh`. */
+/**
+ * Ask the mesh to measure its own links.
+ *
+ * The rule this exists to keep is the one a hand-rolled loop gets wrong: **one
+ * sampler per connection**. The rate is a delta, so a sampler shared across
+ * peers subtracts one connection's counter from another's and reports nonsense
+ * — and the mesh is the only place that knows how many links there are and when
+ * one goes away. It also owns a single timer instead of one per peer.
+ *
+ * Sampling only runs for a link whose connection is `connected`. A link still
+ * gathering candidates has no traffic to measure, and asking anyway spends a
+ * `getStats()` to learn that.
+ */
+export declare interface MeshStatsOptions {
+    /** How often to sample each connected link, in milliseconds. Default `2000`. */
+    intervalMs?: number;
+    /** Which media the throughput counts. Passed straight to the sampler. */
+    kind?: LinkStatsKind;
+    /**
+     * Called with each link's sample, as it is taken.
+     *
+     * The same value lands on {@link MeshPeer.stats}, so a consumer that reads
+     * the peer list needs no callback at all. Note that measuring therefore
+     * makes {@link PeerMeshOptions.onPeers} fire on the interval — which is the
+     * point for a badge, and worth knowing for anything that does real work in
+     * that handler.
+     */
+    onStats?: (peerId: string, stats: LinkStats) => void;
+}
+
 export declare type Messages = Record<string, string>;
 
 /** Lifecycle of a microphone stream. */
@@ -9532,37 +9634,49 @@ export { Outlet }
 declare type OverriddenDomProps = "children" | "title" | "onSelect";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_10 = "children";
+declare type OverriddenDomProps_10 = "children" | "onChange" | "defaultValue";
 
 /** DOM attributes this component redefines. */
 declare type OverriddenDomProps_11 = "children";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_12 = "children" | "onChange";
+declare type OverriddenDomProps_12 = "children";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_2 = "children" | "onSubmit";
+declare type OverriddenDomProps_13 = "children" | "onChange";
 
-/** DOM attributes the composer redefines. */
-declare type OverriddenDomProps_3 = "onSubmit" | "value" | "defaultValue" | "rows";
+/**
+ * DOM attributes this component redefines.
+ *
+ * `onRateChange` is a real collision, not tidiness: React types it on every
+ * element as the media `ratechange` handler, `ReactEventHandler`. Ours carries
+ * the rate the viewer picked, and a `(rate: number) => void` is not assignable
+ * to a handler that receives an event — same shape of clash as `Input`'s `size`
+ * against `HTMLInputElement.size`. The DOM one is useless on a `<div>` anyway:
+ * the event fires on the media element inside, which this component owns.
+ */
+declare type OverriddenDomProps_2 = "children" | "onRateChange";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_4 = "children";
+declare type OverriddenDomProps_3 = "children" | "onSubmit";
+
+/** DOM attributes the composer redefines. */
+declare type OverriddenDomProps_4 = "onSubmit" | "value" | "defaultValue" | "rows";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_5 = "children" | "onError";
+declare type OverriddenDomProps_5 = "children";
 
 /** DOM attributes this component redefines. */
 declare type OverriddenDomProps_6 = "children" | "onError";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_7 = "children" | "onSubmit";
-
-/** DOM attributes the composer redefines. */
-declare type OverriddenDomProps_8 = "onSubmit" | "value" | "defaultValue" | "rows";
+declare type OverriddenDomProps_7 = "children" | "onError";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_9 = "children" | "onChange" | "defaultValue";
+declare type OverriddenDomProps_8 = "children" | "onSubmit";
+
+/** DOM attributes the composer redefines. */
+declare type OverriddenDomProps_9 = "onSubmit" | "value" | "defaultValue" | "rows";
 
 /**
  * Page wrapper with header + (optional) toolbar + content + footer. Pairs
@@ -9981,9 +10095,26 @@ export declare interface PeerMesh {
     stop: () => void;
     /** The peers as the mesh currently sees them. */
     readonly peers: MeshPeer[];
+    /**
+     * The connection carrying one peer's link, or `null`.
+     *
+     * The escape hatch for everything this mesh does not model. `getStats()`,
+     * `getSenders()`, an `RTCDataChannel`, an encoding tweak the `quality`
+     * shape has no field for — all of it lives on the connection, and a mesh
+     * that keeps it private turns adopting the mesh into losing a feature.
+     *
+     * {@link MeshPeer.connection} is the *state*, which is what a view needs;
+     * this is the object, which is what a measurement needs. For the common
+     * case of measuring, {@link PeerMeshOptions.stats} spares you the loop —
+     * including the one-sampler-per-connection rule that a hand-rolled version
+     * gets wrong.
+     *
+     * @param peerId - The id the peer was added under.
+     * @returns The connection, or `null` when there is no link for that id.
+     */
+    getConnection: (peerId: string) => RTCPeerConnection | null;
 }
 
-/** Options for `createPeerMesh`. */
 export declare interface PeerMeshOptions {
     /** The lanes every link negotiates, in the order they are allocated. */
     slots: readonly MeshSlot[];
@@ -9999,6 +10130,8 @@ export declare interface PeerMeshOptions {
     onNotice?: (reason: string) => void;
     /** Initial encoder limits. */
     quality?: MeshQuality;
+    /** Measure every link, on one timer the mesh owns. See {@link MeshStatsOptions}. */
+    stats?: MeshStatsOptions;
     /**
      * Applies a local description, so the SDP can be rewritten on the way out.
      *
@@ -10737,6 +10870,26 @@ export declare interface RatingStarsProps {
  */
 export declare function readableForeground(background: string, light?: string, dark?: string): string;
 
+/**
+ * Read the uplink the transport estimates for this path, in kbps.
+ *
+ * This is the field that tells a cap being honoured apart from a cap that is
+ * drowning: `bytesSent` reports the same 2500 kbps whether the path has room
+ * for it or the queue behind it is growing. No fixed budget can stand in for it
+ * — a domestic uplink of 1 Mbps and a fibre link differ by an order of
+ * magnitude, and in Brazil the upload routinely is a tenth of the download
+ * beside it.
+ *
+ * @param report - A report from `RTCPeerConnection.getStats()`.
+ * @returns The estimate in kbps, or `null` while there is none. Every reader
+ *   needs a fallback for that, not a default of zero.
+ *
+ * @example
+ * const headroom = readAvailableOutgoingKbps(await pc.getStats());
+ * if (headroom !== null && headroom < asked) lowerTheCap(headroom);
+ */
+export declare function readAvailableOutgoingKbps(report: RTCStatsReport): number | null;
+
 /**
  * Sample the device capabilities the browser reports.
  *
@@ -10754,18 +10907,41 @@ export declare function readableForeground(background: string, light?: string, d
 export declare function readDeviceProfile(): DeviceProfile;
 
 /**
- * Read the round trip of the candidate pair actually carrying the link.
+ * Read what the encoder says is holding the picture back.
  *
- * A connection routinely keeps several viable pairs alive at once — host,
- * server-reflexive, relayed — and only one of them carries traffic. Reading the
- * first `succeeded` pair makes the number jump between paths that are not being
- * travelled: 8 ms on an idle host pair alternating with 180 ms on the TURN pair
- * doing the work. The pair the transport names in `selectedCandidatePairId` is
- * the one being used.
+ * `"bandwidth"` wins when senders disagree, because it is the only reason a
+ * lower cap answers. The spec's `"none"` comes back as `null`.
  *
- * A succeeded pair is kept as a fallback because not every browser fills that
- * field in — losing the reading entirely is worse than an occasionally
- * optimistic one.
+ * @param report - A report from `RTCPeerConnection.getStats()`.
+ * @returns The reason, or `null` when nothing is limiting the picture.
+ *
+ * @example
+ * if (readQualityLimitation(await pc.getStats()) === "cpu") stopBlurringTheBackground();
+ */
+export declare function readQualityLimitation(report: RTCStatsReport): RTCQualityLimitationReason | null;
+
+/**
+ * Read whether the link is travelling through a TURN relay.
+ *
+ * Resolved only from the pair the browser names, never from a merely
+ * `succeeded` one: a relayed route is somebody's hosting bill, and reporting
+ * one from a pair that carries nothing bills a cost nobody is paying.
+ *
+ * @param report - A report from `RTCPeerConnection.getStats()`.
+ * @returns `true` when the carrying pair's local candidate is a relay.
+ *
+ * @example
+ * if (readRelayed(await pc.getStats())) capTheStreamThatCostsMoney();
+ */
+export declare function readRelayed(report: RTCStatsReport): boolean;
+
+/**
+ * Read the round trip of the candidate pair actually carrying the link.
+ *
+ * A `succeeded` pair is kept as a last resort because not every browser names
+ * the selected one — losing the reading entirely is worse than an occasionally
+ * optimistic one. See {@link carryingPair} for the chain and why the middle
+ * step exists.
  *
  * @param report - A report from `RTCPeerConnection.getStats()`.
  * @returns Round trip in milliseconds, rounded, or `null` when nothing reported
@@ -11054,7 +11230,17 @@ export declare interface ResizableProps extends Omit<HTMLAttributes<HTMLDivEleme
  * is worse than the lower rate it replaced — so below that line the preference
  * is overridden rather than obeyed.
  *
- * @param quality - What was asked for.
+ * Two things decide *which* budget answers that question:
+ *
+ * - **`null` is the most generous case, not the absent one.** A slot with no cap
+ *   is unbounded, which is exactly where fluidity should hold. Reading it as
+ *   missing — and then deciding from a modest camera beside it — is the answer
+ *   backwards.
+ * - **{@link MeshQuality.degradationAnchor} names the slot the choice was
+ *   about.** Without it the largest cap across the video slots answers, which
+ *   is right when the slots are interchangeable and wrong when they are not.
+ *
+ * @param quality - What was asked for, including the anchor and the floor.
  * @param effective - What the room's share actually allows.
  * @returns The degradation preference to write onto the senders, or `undefined`
  *     when the caller expressed no preference.
@@ -13422,7 +13608,7 @@ export declare interface TransferItem {
     data?: Record<string, unknown>;
 }
 
-export declare interface TransferProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_9> {
+export declare interface TransferProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_10> {
     /** The whole catalogue. Both panes are derived from it. */
     items: readonly TransferItem[];
     /** Ids on the target side. Controlled. */
@@ -16654,6 +16840,88 @@ export declare interface ViaCEPResult {
     siafi?: string;
 }
 
+/**
+ * Playback transport for one video: play/pause, seek, volume, speed, fullscreen.
+ *
+ * Built on a real `<video>` element, and deliberately **not** an overlay: the
+ * controls sit in a bar under the frame rather than on top of it. Controls drawn
+ * over video have to earn their contrast against arbitrary pixels, which no
+ * `--tempest-*` token can promise — every text token in this SDK is resolved
+ * against a known surface, and the two contrast defects this repo shipped were
+ * both a text token used over a surface it was never checked against. A bar with
+ * its own surface inherits the theme and is legible by construction.
+ *
+ * The seek bar, the volume slider and the speed picker are bare `<input>` and
+ * `<select>` elements rather than the SDK's `Slider` and `Select`: those are form
+ * fields, with a label row and a value badge, and a transport wants neither. The
+ * native elements keep the keyboard and screen-reader behaviour that matters here
+ * for free.
+ *
+ * @example
+ * const rec = useVideoRecorder(screen.stream);
+ * {rec.recording && (
+ *     <VideoPlayer src={rec.recording.blob} durationMs={rec.recording.durationMs} />
+ * )}
+ */
+export declare function VideoPlayer({ src, durationMs, poster, tracks, aspectRatio, rate, rates, onRateChange, shiftPitch, fullscreen, autoPlay, loop, muted, locale, actions, onEnded, onError, disabled, className, ...rest }: VideoPlayerProps): JSX.Element;
+
+export declare interface VideoPlayerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_2> {
+    /**
+     * What to play — a URL, or a `Blob`/`File` straight from a recorder.
+     *
+     * A `Blob` is wrapped in an object URL that is revoked when it changes or the
+     * component unmounts, so a session that records twenty clips does not leak
+     * twenty URLs for the lifetime of the tab.
+     */
+    src: string | Blob | null;
+    /**
+     * Known length in milliseconds.
+     *
+     * Pass it whenever you have it — a recording from `useVideoRecorder` always
+     * does. Without it the element's own `duration` is used, and a fresh
+     * `MediaRecorder` blob may report `Infinity` until it is probed for one.
+     */
+    durationMs?: number;
+    /** Still shown before playback. Pair it with `captureFrame` from `/imaging`. */
+    poster?: string;
+    /** Caption and subtitle files. */
+    tracks?: readonly VideoTextTrack[];
+    /** Frame shape while the video has no intrinsic size yet. Default `16 / 9`. */
+    aspectRatio?: number;
+    /**
+     * Playback rate. Controlled when passed with `onRateChange`.
+     *
+     * Written to both `playbackRate` and `defaultPlaybackRate`, because the
+     * element resets the first to the second when a source loads — a player that
+     * only writes `playbackRate` silently drops back to 1× on every clip change.
+     */
+    rate?: number;
+    /** Presets the control offers. `[]` hides it. Default {@link DEFAULT_PLAYBACK_RATES}. */
+    rates?: readonly number[];
+    /** Called with the rate the viewer picked. */
+    onRateChange?: (rate: number) => void;
+    /** Let the pitch rise with the rate (`preservesPitch = false`). Default `false`. */
+    shiftPitch?: boolean;
+    /** Offer a fullscreen button where the browser supports it. Default `true`. */
+    fullscreen?: boolean;
+    /** Start playing as soon as `src` is ready. Default `false`. */
+    autoPlay?: boolean;
+    /** Loop. Default `false`. */
+    loop?: boolean;
+    /** Start muted. Autoplay without a gesture needs this. Default `false`. */
+    muted?: boolean;
+    /** Locale for the labels. Default `"pt-BR"`. */
+    locale?: "pt-BR" | "en";
+    /** Rendered at the end of the control row — a download button, a delete button. */
+    actions?: ReactNode;
+    /** Fired when playback reaches the end. */
+    onEnded?: () => void;
+    /** Fired when the element reports a decode/network error. */
+    onError?: (error: unknown) => void;
+    /** No `src` yet, or playback not allowed. */
+    disabled?: boolean;
+}
+
 /** Imperative video recorder. Same shape as the audio one. */
 export declare type VideoRecorderHandle = MediaRecorderHandle;
 
@@ -16699,6 +16967,20 @@ export declare interface VideoRecorderOptions {
  */
 export declare type VideoRecording = MediaRecording;
 
+/** One caption or subtitle file, rendered as a `<track>`. */
+export declare interface VideoTextTrack {
+    /** URL of the WebVTT file. */
+    src: string;
+    /** BCP 47 language tag, e.g. `"pt-BR"`. */
+    srcLang: string;
+    /** Name shown in the browser's own track menu. */
+    label: string;
+    /** Track kind. Default `"captions"`. */
+    kind?: "subtitles" | "captions" | "descriptions" | "chapters" | "metadata";
+    /** Whether this track is on unless the viewer picks another. */
+    default?: boolean;
+}
+
 /**
  * Fixed-height virtual list. Renders only the visible window plus a small
  * overscan buffer. Suitable for lists of thousands of identical rows.