@reactor-models/h3-reference-to-video-turbo-realtime 0.3.0

package/dist/core.d.mts

@@ -0,0 +1,621 @@
+import { FileRef, Reactor } from '@reactor-team/js-sdk';
+export { FileRef } from '@reactor-team/js-sdk';
+
+declare const MODEL_NAME: "reactor/h3-reference-to-video-turbo-realtime";
+declare const MODEL_VERSION: "v0.3.0";
+/**
+ * Preset media tracks for the H3ReferenceToVideoTurboRealtime model.
+ *
+ * Declared in the model's OpenAPI schema and passed to the SDK as
+ * `modelTracks` so the transport can prepare the SDP offer in
+ * parallel with session polling (faster first-frame latency).
+ */
+declare const H3ReferenceToVideoTurboRealtimeTracks: readonly [{
+    readonly name: "main_video";
+    readonly kind: "video";
+    readonly direction: "recvonly";
+}, {
+    readonly name: "main_audio";
+    readonly kind: "audio";
+    readonly direction: "recvonly";
+}];
+/** Track names the client can subscribe to (recvonly, from the client's perspective). */
+type H3ReferenceToVideoTurboRealtimeRecvTrackName = "main_video" | "main_audio";
+/** Remove a clip from its queue; reply clip_popped and emit queue_update and state_update. A running build finishes but is discarded. Refuses with command_error for a missing/unknown id. Use stop for the playing clip. */
+interface H3ReferenceToVideoTurboRealtimePopParams {
+    /**
+     * UUID of the clip to remove from either queue.
+     * @default ""
+     */
+    clip_id?: string;
+}
+/** Reposition within the current queue, 0 = front. A running build is unaffected. Replies clip_moved and emits queue_update; refuses with command_error for a missing/unknown id or invalid position. */
+interface H3ReferenceToVideoTurboRealtimeMoveParams {
+    /**
+     * UUID of a queued clip.
+     * @default ""
+     */
+    clip_id?: string;
+    /**
+     * Position in its current queue; past the end appends.
+     * @minimum 0
+     * @default 0
+     */
+    position?: number;
+}
+/** Play the front ready clip, or a named ready clip. Consumes it and emits clip_started, queue_update and state_update. Refuses with command_error if already playing or no matching ready clip exists. */
+interface H3ReferenceToVideoTurboRealtimePlayParams {
+    /**
+     * UUID of a ready clip; blank takes the playout front.
+     * @default ""
+     */
+    clip_id?: string;
+}
+/** Queue a clip with 1–9 reference images at position, or at the back. Each clip keeps its own prompt and ordered references: new images do not alter earlier requests. The images guide appearance, not a fixed first or last frame. Replies clip_queued and broadcasts queue_update and state_update; completion emits clip_generated. Refuses with command_error for empty text, missing/invalid reference, invalid parameters or a full generation queue. */
+interface H3ReferenceToVideoTurboRealtimeEnqueueParams {
+    /**
+     * Omitted or null uses and advances the default seed. An explicit seed leaves the default unchanged.
+     * @minimum 0
+     * @default null
+     */
+    seed?: number | null;
+    /**
+     * What the clip should show and sound like; stored unchanged and never truncated. A prompt past the model's text budget fails the clip with clip_failed instead.
+     * @default ""
+     */
+    prompt?: string;
+    /**
+     * Requested duration between 5 and 15.084 seconds, rounded to frames then aligned upward to a supported length. Actual output ranges from 5.167 to 15.083 seconds. Null uses the session default.
+     * @minimum 5
+     * @maximum 15.084
+     * @default null
+     */
+    seconds?: number | null;
+    /**
+     * Opaque client string, up to 2000 characters, echoed unchanged with the clip.
+     * @maxLength 2000
+     * @default ""
+     */
+    metadata?: string;
+    /**
+     * Generation queue position: 0 is the next build; omitted or past the end appends. The running build is unaffected.
+     * @minimum 0
+     * @default null
+     */
+    position?: number | null;
+    /**
+     * One JPEG, PNG or WebP reference for this clip. Guides subjects and appearance, not a keyframe. Supply this or reference_images, not both.
+     * @default null
+     */
+    reference_image?: FileRef | null;
+    /**
+     * Ordered list of 1–9 uploaded JPEG, PNG or WebP references. In the prompt, Picture 1 names the first image, Picture 2 the second, and so on. Supply this or reference_image, not both. Each clip retains its own list, including while other clips build or play.
+     * @default null
+     */
+    reference_images?: FileRef[] | null;
+    /**
+     * UUID of a generated clip to continue temporally from: this clip's motion, camera and audio carry across the boundary while its own references still drive appearance. Blank for an independent clip. The source must have finished generating; unknown or dropped ids fall back to an independent clip.
+     * @default ""
+     */
+    continue_from_clip_id?: string;
+}
+/** Set the advancing default seed for future enqueues. Replies seed_accepted and emits state_update; an invalid seed emits command_error. Explicit per-clip seeds do not advance it. */
+interface H3ReferenceToVideoTurboRealtimeSetSeedParams {
+    /**
+     * Nonnegative default seed; queued clips keep their seeds.
+     * @minimum 0
+     * @default 1000
+     */
+    seed?: number;
+}
+/** Set the canvas while both queues and playback are empty. Replies canvas_accepted and emits state_update; refuses with command_error for an unsupported aspect or nonempty session. */
+interface H3ReferenceToVideoTurboRealtimeSetCanvasParams {
+    /**
+     * Choose 16:9 (1344x768), 1:1 (768x768), 9:16 (768x1344), or 4:3 (1024x768).
+     * @default "16:9"
+     */
+    aspect?: "16:9" | "1:1" | "9:16" | "4:3";
+}
+/** Automatically play ready clips whenever idle. Empty queues wait; no prompts are generated automatically. Replies autoplay_accepted and emits state_update. */
+interface H3ReferenceToVideoTurboRealtimeSetAutoplayParams {
+    /**
+     * True plays the ready queue; false waits for play after each clip.
+     * @default false
+     */
+    enabled?: boolean;
+}
+/** Set the duration for future enqueues, aligned to a supported frame count. Replies clip_length_accepted and emits state_update; invalid lengths emit command_error. Queued clips keep their lengths. */
+interface H3ReferenceToVideoTurboRealtimeSetClipSecondsParams {
+    /**
+     * Requested duration between 5 and 15.084 seconds, rounded to frames then aligned upward to a supported length. The reply reports actual duration and frame count.
+     * @minimum 5
+     * @maximum 15.084
+     * @default 15
+     */
+    seconds?: number;
+}
+/** Choose black or a held last frame at boundaries. Off carries the playback clock across ready autoplay clips without flushing. Does not guarantee visual continuity; reset always clears tracks. Replies flush_accepted and emits state_update. */
+interface H3ReferenceToVideoTurboRealtimeSetFlushOnClipEndParams {
+    /**
+     * True flushes to black; false holds the last frame and avoids flushing between autoplay clips.
+     * @default true
+     */
+    enabled?: boolean;
+}
+/** Emitted as the correlated reply when move changes queue order. */
+interface H3ReferenceToVideoTurboRealtimeClipMovedMessage {
+    type: "clip_moved";
+    /** Repositioned clip. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+    /** Queue containing the clip: generation or playout. */
+    queue: string;
+    /** Resulting position, 0 = front. */
+    position: number;
+}
+/** Emitted when generation fails; the clip is removed and the queue moves on. */
+interface H3ReferenceToVideoTurboRealtimeClipFailedMessage {
+    type: "clip_failed";
+    /** Failed clip. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+    /** Why generation failed. */
+    reason: string;
+}
+/** Emitted as the correlated reply when pop removes a queued clip. */
+interface H3ReferenceToVideoTurboRealtimeClipPoppedMessage {
+    type: "clip_popped";
+    /** Removed clip; an in-flight result will be discarded. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+}
+/** Emitted as the correlated reply when enqueue accepts a clip. */
+interface H3ReferenceToVideoTurboRealtimeClipQueuedMessage {
+    type: "clip_queued";
+    /** Accepted clip, including its UUID; ready is false. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+}
+/** Emitted when a clip starts sending to the output tracks. */
+interface H3ReferenceToVideoTurboRealtimeClipStartedMessage {
+    type: "clip_started";
+    /** Clip now playing. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+}
+/** Emitted when stop or reset cuts a clip; it cannot be resumed. */
+interface H3ReferenceToVideoTurboRealtimeClipStoppedMessage {
+    type: "clip_stopped";
+    /** Interrupted clip. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+    /** Total seconds sent in the session. */
+    seconds_sent: number;
+}
+/** Emitted on connect and queue changes; also answers get_queue. */
+interface H3ReferenceToVideoTurboRealtimeQueueUpdateMessage {
+    type: "queue_update";
+    /** Always empty: a played clip is not listed here and cannot be replayed. To continue from a generated clip, pass its clip_id as `enqueue.continue_from_clip_id`. */
+    history: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    }[];
+    /** Built clips ready to play, front first. */
+    playout: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    }[];
+    /** Waiting/in-flight builds, front first. */
+    generation: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    }[];
+}
+/** Emitted on connect and after session state changes; also answers get_state. */
+interface H3ReferenceToVideoTurboRealtimeStateUpdateMessage {
+    type: "state_update";
+    /** Next automatically assigned seed. */
+    seed: number;
+    /** Output video width in pixels. */
+    width: number;
+    /** Session aspect ratio. */
+    aspect: string;
+    /** Output video height in pixels. */
+    height: number;
+    /** A clip is armed or playing on the output tracks. */
+    playing: boolean;
+    /** Ready clips start automatically when idle. */
+    autoplay: boolean;
+    /** Actual duration used by enqueues without their own seconds. */
+    clip_seconds: number;
+    /** Clips finished or stopped during this session. */
+    clips_played: number;
+    /** Seconds sent on the tracks during this session. */
+    seconds_sent: number;
+    /** Ready clips waiting to play. */
+    playout_queued: number;
+    /** Commands permitted by current queue/playback state; their arguments still need validation. */
+    valid_commands: string[];
+    /** Playing clip UUID, or null when idle. */
+    playing_clip_id: string | null;
+    /** Maximum accepted requested duration. */
+    clip_seconds_max: number;
+    /** Minimum accepted requested duration. */
+    clip_seconds_min: number;
+    /** Maximum ready queue size; building pauses while full. */
+    playout_capacity: number;
+    /** True flushes to black at boundaries; false holds the last frame and avoids flushing between ready autoplay clips. */
+    flush_on_clip_end: boolean;
+    /** Clips in the generation queue, including the running build. */
+    generation_queued: number;
+    /** Maximum generation queue size. */
+    generation_capacity: number;
+}
+/** Emitted when all frames and synchronized audio have been sent. */
+interface H3ReferenceToVideoTurboRealtimeClipFinishedMessage {
+    type: "clip_finished";
+    /** Completed clip. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+    /** Total seconds sent in the session, including this clip. */
+    seconds_sent: number;
+}
+/** Emitted when a command is refused without changing the queue/defaults. */
+interface H3ReferenceToVideoTurboRealtimeCommandErrorMessage {
+    type: "command_error";
+    /** Why the command was refused. */
+    reason: string;
+    /** Refused command name. */
+    command: string;
+}
+/** Emitted as the correlated reply when set_seed is accepted. */
+interface H3ReferenceToVideoTurboRealtimeSeedAcceptedMessage {
+    type: "seed_accepted";
+    /** Next automatically assigned seed. */
+    seed: number;
+}
+/** Emitted as the correlated reply when reset clears the playlist and defaults. */
+interface H3ReferenceToVideoTurboRealtimeSessionResetMessage {
+    type: "session_reset";
+    /** Whether reset cut an armed or playing clip. */
+    was_playing: boolean;
+    /** Clips removed from both queues, excluding the playing clip. */
+    cleared_clips: number;
+}
+/** Emitted when a build enters the playout queue. */
+interface H3ReferenceToVideoTurboRealtimeClipGeneratedMessage {
+    type: "clip_generated";
+    /** Built clip, ready to play. */
+    clip: {
+        "seed": number;
+        "ready": boolean;
+        "frames": number;
+        "prompt": string;
+        "clip_id": string;
+        "seconds": number;
+        "metadata": string;
+        "has_reference_image"?: boolean;
+        "reference_image_count"?: number;
+    };
+}
+/** Emitted as the correlated reply when set_flush_on_clip_end is accepted. */
+interface H3ReferenceToVideoTurboRealtimeFlushAcceptedMessage {
+    type: "flush_accepted";
+    /** Whether clip boundaries flush the output to black. */
+    enabled: boolean;
+}
+/** Emitted as the correlated reply when set_canvas is accepted. */
+interface H3ReferenceToVideoTurboRealtimeCanvasAcceptedMessage {
+    type: "canvas_accepted";
+    /** Video width in pixels. */
+    width: number;
+    /** Accepted aspect ratio. */
+    aspect: string;
+    /** Video height in pixels. */
+    height: number;
+}
+/** Emitted as the correlated reply when set_autoplay is accepted. */
+interface H3ReferenceToVideoTurboRealtimeAutoplayAcceptedMessage {
+    type: "autoplay_accepted";
+    /** Whether ready clips start automatically. */
+    enabled: boolean;
+}
+/** Emitted as the correlated reply when set_clip_seconds is accepted. */
+interface H3ReferenceToVideoTurboRealtimeClipLengthAcceptedMessage {
+    type: "clip_length_accepted";
+    /** Effective default frame count. */
+    frames: number;
+    /** Effective default duration, in seconds. */
+    clip_seconds: number;
+}
+type H3ReferenceToVideoTurboRealtimeMessage = H3ReferenceToVideoTurboRealtimeClipMovedMessage | H3ReferenceToVideoTurboRealtimeClipFailedMessage | H3ReferenceToVideoTurboRealtimeClipPoppedMessage | H3ReferenceToVideoTurboRealtimeClipQueuedMessage | H3ReferenceToVideoTurboRealtimeClipStartedMessage | H3ReferenceToVideoTurboRealtimeClipStoppedMessage | H3ReferenceToVideoTurboRealtimeQueueUpdateMessage | H3ReferenceToVideoTurboRealtimeStateUpdateMessage | H3ReferenceToVideoTurboRealtimeClipFinishedMessage | H3ReferenceToVideoTurboRealtimeCommandErrorMessage | H3ReferenceToVideoTurboRealtimeSeedAcceptedMessage | H3ReferenceToVideoTurboRealtimeSessionResetMessage | H3ReferenceToVideoTurboRealtimeClipGeneratedMessage | H3ReferenceToVideoTurboRealtimeFlushAcceptedMessage | H3ReferenceToVideoTurboRealtimeCanvasAcceptedMessage | H3ReferenceToVideoTurboRealtimeAutoplayAcceptedMessage | H3ReferenceToVideoTurboRealtimeClipLengthAcceptedMessage;
+/**
+ * Options for creating a H3ReferenceToVideoTurboRealtimeModel (model name is set automatically).
+ *
+ * Derived from `Reactor`'s own constructor options with `modelName`
+ * and `modelTracks` removed — those are supplied by this class.
+ * Any new option the SDK adds appears here automatically on the
+ * next `defaultSdkVersion` bump.
+ */
+type H3ReferenceToVideoTurboRealtimeOptions = Omit<ConstructorParameters<typeof Reactor>[0], "modelName" | "modelTracks">;
+/**
+ * Strongly-typed client for the H3ReferenceToVideoTurboRealtime model.
+ *
+ * Extends {@link Reactor} with the model name (and modelTracks) baked into the
+ * constructor, so every public method on Reactor — `connect`, `disconnect`,
+ * `sendCommand`, `on`/`off`, `getStats`, `publishTrack`/`unpublishTrack`,
+ * etc. — is reachable directly on the instance. The schema-derived sugar
+ * below adds typed wrappers for every declared event, message, and track.
+ */
+declare class H3ReferenceToVideoTurboRealtimeModel extends Reactor {
+    constructor(options?: H3ReferenceToVideoTurboRealtimeOptions);
+    /** @deprecated The model client now extends `Reactor` directly — call methods on `this` instead. This accessor returns `this` for backwards compatibility and will be removed in a future major release. */
+    get reactor(): this;
+    /**
+     * Remove a clip from its queue; reply clip_popped and emit queue_update and state_update. A running build finishes but is discarded. Refuses with command_error for a missing/unknown id. Use stop for the playing clip.
+     * @param params - Remove a clip from its queue; reply clip_popped and emit queue_update and state_update. A running build finishes but is discarded. Refuses with command_error for a missing/unknown id. Use stop for the playing clip.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipPoppedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    pop(params: H3ReferenceToVideoTurboRealtimePopParams): Promise<H3ReferenceToVideoTurboRealtimeClipPoppedMessage | undefined>;
+    /**
+     * Reposition within the current queue, 0 = front. A running build is unaffected. Replies clip_moved and emits queue_update; refuses with command_error for a missing/unknown id or invalid position.
+     * @param params - Reposition within the current queue, 0 = front. A running build is unaffected. Replies clip_moved and emits queue_update; refuses with command_error for a missing/unknown id or invalid position.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipMovedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    move(params: H3ReferenceToVideoTurboRealtimeMoveParams): Promise<H3ReferenceToVideoTurboRealtimeClipMovedMessage | undefined>;
+    /**
+     * Play the front ready clip, or a named ready clip. Consumes it and emits clip_started, queue_update and state_update. Refuses with command_error if already playing or no matching ready clip exists.
+     * @param params - Play the front ready clip, or a named ready clip. Consumes it and emits clip_started, queue_update and state_update. Refuses with command_error if already playing or no matching ready clip exists.
+     * @returns Resolves once the model's handler has completed; this command declares no reply payload.
+     */
+    play(params: H3ReferenceToVideoTurboRealtimePlayParams): Promise<undefined>;
+    /**
+     * Cut playback and emit clip_stopped and state_update; queues are untouched. Under autoplay this skips to the next clip. Refuses with command_error when nothing is playing.
+     * @returns Resolves once the model's handler has completed; this command declares no reply payload.
+     */
+    stop(): Promise<undefined>;
+    /**
+     * Drop both queues, cut playback, restore defaults and clear tracks. Replies session_reset; emits queue_update, state_update and clip_stopped if playing. In-flight results are discarded.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeSessionResetMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    reset(): Promise<H3ReferenceToVideoTurboRealtimeSessionResetMessage | undefined>;
+    /**
+     * Queue a clip with 1–9 reference images at position, or at the back. Each clip keeps its own prompt and ordered references: new images do not alter earlier requests. The images guide appearance, not a fixed first or last frame. Replies clip_queued and broadcasts queue_update and state_update; completion emits clip_generated. Refuses with command_error for empty text, missing/invalid reference, invalid parameters or a full generation queue.
+     * @param params - Queue a clip with 1–9 reference images at position, or at the back. Each clip keeps its own prompt and ordered references: new images do not alter earlier requests. The images guide appearance, not a fixed first or last frame. Replies clip_queued and broadcasts queue_update and state_update; completion emits clip_generated. Refuses with command_error for empty text, missing/invalid reference, invalid parameters or a full generation queue.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipQueuedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    enqueue(params: H3ReferenceToVideoTurboRealtimeEnqueueParams): Promise<H3ReferenceToVideoTurboRealtimeClipQueuedMessage | undefined>;
+    /**
+     * Set the advancing default seed for future enqueues. Replies seed_accepted and emits state_update; an invalid seed emits command_error. Explicit per-clip seeds do not advance it.
+     * @param params - Set the advancing default seed for future enqueues. Replies seed_accepted and emits state_update; an invalid seed emits command_error. Explicit per-clip seeds do not advance it.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeSeedAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    setSeed(params: H3ReferenceToVideoTurboRealtimeSetSeedParams): Promise<H3ReferenceToVideoTurboRealtimeSeedAcceptedMessage | undefined>;
+    /**
+     * Reply queue_update with both queues in full. The history field is always empty: a played clip is not listed and cannot be replayed, though a generated clip can still seed a new one through `enqueue.continue_from_clip_id`. Valid at any time.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeQueueUpdateMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    getQueue(): Promise<H3ReferenceToVideoTurboRealtimeQueueUpdateMessage | undefined>;
+    /**
+     * Reply state_update with defaults, capacities, playback progress and valid_commands. Valid at any time.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeStateUpdateMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    getState(): Promise<H3ReferenceToVideoTurboRealtimeStateUpdateMessage | undefined>;
+    /**
+     * Set the canvas while both queues and playback are empty. Replies canvas_accepted and emits state_update; refuses with command_error for an unsupported aspect or nonempty session.
+     * @param params - Set the canvas while both queues and playback are empty. Replies canvas_accepted and emits state_update; refuses with command_error for an unsupported aspect or nonempty session.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeCanvasAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    setCanvas(params: H3ReferenceToVideoTurboRealtimeSetCanvasParams): Promise<H3ReferenceToVideoTurboRealtimeCanvasAcceptedMessage | undefined>;
+    /**
+     * Automatically play ready clips whenever idle. Empty queues wait; no prompts are generated automatically. Replies autoplay_accepted and emits state_update.
+     * @param params - Automatically play ready clips whenever idle. Empty queues wait; no prompts are generated automatically. Replies autoplay_accepted and emits state_update.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeAutoplayAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    setAutoplay(params: H3ReferenceToVideoTurboRealtimeSetAutoplayParams): Promise<H3ReferenceToVideoTurboRealtimeAutoplayAcceptedMessage | undefined>;
+    /**
+     * Set the duration for future enqueues, aligned to a supported frame count. Replies clip_length_accepted and emits state_update; invalid lengths emit command_error. Queued clips keep their lengths.
+     * @param params - Set the duration for future enqueues, aligned to a supported frame count. Replies clip_length_accepted and emits state_update; invalid lengths emit command_error. Queued clips keep their lengths.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipLengthAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    setClipSeconds(params: H3ReferenceToVideoTurboRealtimeSetClipSecondsParams): Promise<H3ReferenceToVideoTurboRealtimeClipLengthAcceptedMessage | undefined>;
+    /**
+     * Choose black or a held last frame at boundaries. Off carries the playback clock across ready autoplay clips without flushing. Does not guarantee visual continuity; reset always clears tracks. Replies flush_accepted and emits state_update.
+     * @param params - Choose black or a held last frame at boundaries. Off carries the playback clock across ready autoplay clips without flushing. Does not guarantee visual continuity; reset always clears tracks. Replies flush_accepted and emits state_update.
+     * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeFlushAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+     */
+    setFlushOnClipEnd(params: H3ReferenceToVideoTurboRealtimeSetFlushOnClipEndParams): Promise<H3ReferenceToVideoTurboRealtimeFlushAcceptedMessage | undefined>;
+    /**
+     * Subscribe to typed model messages.
+     * @param handler - Called with a discriminated H3ReferenceToVideoTurboRealtimeMessage
+     * @returns Unsubscribe function
+     */
+    onMessage(handler: (message: H3ReferenceToVideoTurboRealtimeMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_moved" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipMoved(handler: (message: H3ReferenceToVideoTurboRealtimeClipMovedMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_failed" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipFailed(handler: (message: H3ReferenceToVideoTurboRealtimeClipFailedMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_popped" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipPopped(handler: (message: H3ReferenceToVideoTurboRealtimeClipPoppedMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_queued" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipQueued(handler: (message: H3ReferenceToVideoTurboRealtimeClipQueuedMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_started" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipStarted(handler: (message: H3ReferenceToVideoTurboRealtimeClipStartedMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_stopped" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipStopped(handler: (message: H3ReferenceToVideoTurboRealtimeClipStoppedMessage) => void): () => void;
+    /**
+     * Subscribe to "queue_update" messages only.
+     * @returns Unsubscribe function
+     */
+    onQueueUpdate(handler: (message: H3ReferenceToVideoTurboRealtimeQueueUpdateMessage) => void): () => void;
+    /**
+     * Subscribe to "state_update" messages only.
+     * @returns Unsubscribe function
+     */
+    onStateUpdate(handler: (message: H3ReferenceToVideoTurboRealtimeStateUpdateMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_finished" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipFinished(handler: (message: H3ReferenceToVideoTurboRealtimeClipFinishedMessage) => void): () => void;
+    /**
+     * Subscribe to "command_error" messages only.
+     * @returns Unsubscribe function
+     */
+    onCommandError(handler: (message: H3ReferenceToVideoTurboRealtimeCommandErrorMessage) => void): () => void;
+    /**
+     * Subscribe to "seed_accepted" messages only.
+     * @returns Unsubscribe function
+     */
+    onSeedAccepted(handler: (message: H3ReferenceToVideoTurboRealtimeSeedAcceptedMessage) => void): () => void;
+    /**
+     * Subscribe to "session_reset" messages only.
+     * @returns Unsubscribe function
+     */
+    onSessionReset(handler: (message: H3ReferenceToVideoTurboRealtimeSessionResetMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_generated" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipGenerated(handler: (message: H3ReferenceToVideoTurboRealtimeClipGeneratedMessage) => void): () => void;
+    /**
+     * Subscribe to "flush_accepted" messages only.
+     * @returns Unsubscribe function
+     */
+    onFlushAccepted(handler: (message: H3ReferenceToVideoTurboRealtimeFlushAcceptedMessage) => void): () => void;
+    /**
+     * Subscribe to "canvas_accepted" messages only.
+     * @returns Unsubscribe function
+     */
+    onCanvasAccepted(handler: (message: H3ReferenceToVideoTurboRealtimeCanvasAcceptedMessage) => void): () => void;
+    /**
+     * Subscribe to "autoplay_accepted" messages only.
+     * @returns Unsubscribe function
+     */
+    onAutoplayAccepted(handler: (message: H3ReferenceToVideoTurboRealtimeAutoplayAcceptedMessage) => void): () => void;
+    /**
+     * Subscribe to "clip_length_accepted" messages only.
+     * @returns Unsubscribe function
+     */
+    onClipLengthAccepted(handler: (message: H3ReferenceToVideoTurboRealtimeClipLengthAcceptedMessage) => void): () => void;
+    /**
+     * Subscribe to the "main_video" recvonly video track the model publishes.
+     *
+     * The handler fires once the model starts publishing this track; it receives the live MediaStreamTrack and the parent MediaStream (useful for attaching to a `<video>` / `<audio>` element via `srcObject`).
+     * @param handler - Called with the received track and its stream
+     * @returns Unsubscribe function
+     */
+    onMainVideo(handler: (track: MediaStreamTrack, stream: MediaStream) => void): () => void;
+    /**
+     * Subscribe to the "main_audio" recvonly audio track the model publishes.
+     *
+     * The handler fires once the model starts publishing this track; it receives the live MediaStreamTrack and the parent MediaStream (useful for attaching to a `<video>` / `<audio>` element via `srcObject`).
+     * @param handler - Called with the received track and its stream
+     * @returns Unsubscribe function
+     */
+    onMainAudio(handler: (track: MediaStreamTrack, stream: MediaStream) => void): () => void;
+}
+
+export { type H3ReferenceToVideoTurboRealtimeAutoplayAcceptedMessage, type H3ReferenceToVideoTurboRealtimeCanvasAcceptedMessage, type H3ReferenceToVideoTurboRealtimeClipFailedMessage, type H3ReferenceToVideoTurboRealtimeClipFinishedMessage, type H3ReferenceToVideoTurboRealtimeClipGeneratedMessage, type H3ReferenceToVideoTurboRealtimeClipLengthAcceptedMessage, type H3ReferenceToVideoTurboRealtimeClipMovedMessage, type H3ReferenceToVideoTurboRealtimeClipPoppedMessage, type H3ReferenceToVideoTurboRealtimeClipQueuedMessage, type H3ReferenceToVideoTurboRealtimeClipStartedMessage, type H3ReferenceToVideoTurboRealtimeClipStoppedMessage, type H3ReferenceToVideoTurboRealtimeCommandErrorMessage, type H3ReferenceToVideoTurboRealtimeEnqueueParams, type H3ReferenceToVideoTurboRealtimeFlushAcceptedMessage, type H3ReferenceToVideoTurboRealtimeMessage, H3ReferenceToVideoTurboRealtimeModel, type H3ReferenceToVideoTurboRealtimeMoveParams, type H3ReferenceToVideoTurboRealtimeOptions, type H3ReferenceToVideoTurboRealtimePlayParams, type H3ReferenceToVideoTurboRealtimePopParams, type H3ReferenceToVideoTurboRealtimeQueueUpdateMessage, type H3ReferenceToVideoTurboRealtimeRecvTrackName, type H3ReferenceToVideoTurboRealtimeSeedAcceptedMessage, type H3ReferenceToVideoTurboRealtimeSessionResetMessage, type H3ReferenceToVideoTurboRealtimeSetAutoplayParams, type H3ReferenceToVideoTurboRealtimeSetCanvasParams, type H3ReferenceToVideoTurboRealtimeSetClipSecondsParams, type H3ReferenceToVideoTurboRealtimeSetFlushOnClipEndParams, type H3ReferenceToVideoTurboRealtimeSetSeedParams, type H3ReferenceToVideoTurboRealtimeStateUpdateMessage, H3ReferenceToVideoTurboRealtimeTracks, MODEL_NAME, MODEL_VERSION };