@pipedog/core 0.0.0 → 0.1.0

package/dist/processors/frameworks/rtvi/models.d.ts

@@ -0,0 +1,1741 @@
+/**
+ * RTVI protocol v2 message models.
+ *
+ * Contains all RTVI protocol v2 message definitions and data structures.
+ * Import this module under the `RTVI` alias to use as a namespace.
+ *
+ * @example
+ * import * as RTVI from "@pipedog/core/processors/frameworks/rtvi/models";
+ *
+ * const msg = new RTVI.BotReady({
+ *   id: "1",
+ *   data: new RTVI.BotReadyData({ version: RTVI.PROTOCOL_VERSION }),
+ * });
+ *
+ * Porting notes:
+ * - Upstream models are pydantic `BaseModel`s. Here each model is a class
+ *   extending the small `BaseModel` below: fields are camelCase and the
+ *   constructor takes one options object, while `modelValidate()` reads and
+ *   `modelDump()` / `toJSON()` write the upstream snake_case wire keys, so
+ *   the RTVI wire format is unchanged. The constructor validates its options
+ *   like pydantic does and throws `ValidationError`.
+ * - Dropped (deprecated upstream): `LLMFunctionCallMessageData` and
+ *   `LLMFunctionCallMessage` (only the deprecated
+ *   `RTVIProcessor.handle_function_call` sends them).
+ * - Kept although deprecated upstream, because the observer still sends them
+ *   by default and clients read them: `BotLLMTextMessage`,
+ *   `BotTTSTextMessage`, `UserTranscriptionMessage(Data)` and the
+ *   `aggregated_by` wire field of `BotOutputMessageData`.
+ */
+import type { KeypadEntry } from "../../../audio/dtmf/types.ts";
+import { BotCapabilities, type BotCapabilitiesOptions } from "../../../pipeline/capabilities.ts";
+import type { TextType } from "../../../utils/text/base_text_aggregator.ts";
+/**
+ * Source type for an RTVI `send-file` message.
+ *
+ * Matches `FileSourceType` from frames: a file arrives either as inline base64
+ * bytes or as a URL, and both flow through to a `UserFileRawFrame`
+ * unresolved.
+ */
+export type RTVIFileSourceType = "bytes" | "url";
+export declare const PROTOCOL_VERSION = "2.2.0";
+export declare const LEGACY_SUPPORTED_MAJOR = 1;
+export declare const MESSAGE_LABEL = "rtvi-ai";
+export type MessageLiteral = "rtvi-ai";
+/** One validation problem: where it is (wire keys) and what is wrong. */
+export interface ValidationErrorDetail {
+    loc: (string | number)[];
+    msg: string;
+}
+/** Raised when data does not match a model, like pydantic's `ValidationError`. */
+declare const BuiltinError: ErrorConstructor;
+export declare class ValidationError extends BuiltinError {
+    name: string;
+    readonly title: string;
+    readonly details: ValidationErrorDetail[];
+    constructor(title: string, details: ValidationErrorDetail[]);
+    /** The list of problems (pydantic `ValidationError.errors()`). */
+    errors(): ValidationErrorDetail[];
+}
+/**
+ * Validates one value. `wire` is true when the value comes from wire data
+ * (`modelValidate`), where nested models use snake_case keys; constructor
+ * options use camelCase keys.
+ */
+type Parser<T> = (value: unknown, wire?: boolean) => T;
+interface FieldSpec<T = unknown> {
+    parse: Parser<T>;
+    /** Factory for the default value; absent when the field is required. */
+    default?: () => T;
+    /** Wire key; defaults to the snake_case form of the field name. */
+    key?: string;
+}
+type FieldSpecs = Record<string, FieldSpec>;
+/** Options for `modelDump()`. */
+export interface ModelDumpOptions {
+    /** Leave out fields whose value is `null`. */
+    excludeNone?: boolean;
+}
+/**
+ * Base class of the RTVI models (pydantic `BaseModel`).
+ *
+ * Subclasses declare their fields with `declare` and describe them in the
+ * static `fields` table. The constructor validates camelCase options;
+ * `modelValidate()` validates wire (snake_case) data; `modelDump()` produces
+ * wire data.
+ */
+export declare abstract class BaseModel {
+    /** Field table: name, parser, default and wire key. */
+    static readonly fields: FieldSpecs;
+    /** What to do with unknown wire keys: drop them, or keep them in `modelExtra`. */
+    static readonly extra: "ignore" | "allow";
+    /** Unknown keys kept by models created with `extra = "allow"` (pydantic `model_extra`). */
+    modelExtra: Record<string, unknown> | null;
+    constructor(options?: object);
+    /**
+     * Hook run on the (camelCase) input before the fields are validated, like
+     * pydantic's `@model_validator(mode="before")`.
+     */
+    protected static _beforeValidate(data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Validate wire data (snake_case keys) into a model (pydantic `model_validate`).
+     *
+     * @throws ValidationError If the data does not match the model.
+     */
+    static modelValidate<C extends abstract new (...args: any[]) => BaseModel>(this: C, data: unknown): InstanceType<C>;
+    /**
+     * The wire form of the model, with upstream's snake_case keys (pydantic
+     * `model_dump`). Nested models are dumped too.
+     */
+    modelDump(options?: ModelDumpOptions): Record<string, unknown>;
+    /** Serialize with the wire keys, as pydantic does. */
+    toJSON(): Record<string, unknown>;
+}
+export interface MessageOptions {
+    label?: MessageLiteral;
+    type: string;
+    id: string;
+    data?: Record<string, unknown> | null;
+}
+/**
+ * Base RTVI message structure.
+ *
+ * Represents the standard format for RTVI protocol messages.
+ */
+export declare class Message extends BaseModel {
+    label: MessageLiteral;
+    type: string;
+    id: string;
+    data: Record<string, unknown> | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: MessageOptions);
+}
+export interface RawClientMessageDataOptions {
+    t: string;
+    d?: unknown;
+}
+/** Data structure expected from client messages sent to the RTVI server. */
+export declare class RawClientMessageData extends BaseModel {
+    t: string;
+    d: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: RawClientMessageDataOptions);
+}
+export interface ClientMessageOptions {
+    msgId: string;
+    type: string;
+    data?: unknown;
+}
+/** Cleansed data structure for client messages for handling. */
+export declare class ClientMessage extends BaseModel {
+    msgId: string;
+    type: string;
+    data: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: ClientMessageOptions);
+}
+export interface RawServerResponseDataOptions {
+    t: string;
+    d?: unknown;
+}
+/** Data structure for server responses to client messages. */
+export declare class RawServerResponseData extends BaseModel {
+    t: string;
+    d: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: RawServerResponseDataOptions);
+}
+export interface ServerResponseOptions {
+    label?: MessageLiteral;
+    type?: "server-response";
+    id: string;
+    data: RawServerResponseData | RawServerResponseDataOptions;
+}
+/**
+ * The RTVI-formatted message response from the server to the client.
+ *
+ * This message is used to respond to custom messages sent by the client.
+ */
+export declare class ServerResponse extends BaseModel {
+    label: MessageLiteral;
+    type: "server-response";
+    id: string;
+    data: RawServerResponseData;
+    static readonly fields: FieldSpecs;
+    constructor(options: ServerResponseOptions);
+}
+export interface AboutClientDataOptions {
+    library: string;
+    libraryVersion?: string | null;
+    platform?: string | null;
+    platformVersion?: string | null;
+    platformDetails?: unknown;
+}
+/**
+ * Data about the RTVI client.
+ *
+ * Contains information about the client, including which RTVI library it is
+ * using, what platform it is on and any additional details, if available.
+ */
+export declare class AboutClientData extends BaseModel {
+    library: string;
+    libraryVersion: string | null;
+    platform: string | null;
+    platformVersion: string | null;
+    platformDetails: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: AboutClientDataOptions);
+}
+export interface ClientReadyDataOptions {
+    version: string;
+    about: AboutClientData | AboutClientDataOptions;
+}
+/**
+ * Data format of client ready messages.
+ *
+ * Contains the RTVI protocol version and client information.
+ */
+export declare class ClientReadyData extends BaseModel {
+    version: string;
+    about: AboutClientData;
+    static readonly fields: FieldSpecs;
+    constructor(options: ClientReadyDataOptions);
+}
+export interface ErrorResponseDataOptions {
+    error: string;
+}
+/**
+ * Data for an RTVI error response.
+ *
+ * Contains the error message to send back to the client.
+ */
+export declare class ErrorResponseData extends BaseModel {
+    error: string;
+    static readonly fields: FieldSpecs;
+    constructor(options: ErrorResponseDataOptions);
+}
+export interface ErrorResponseOptions {
+    label?: MessageLiteral;
+    type?: "error-response";
+    id: string;
+    data: ErrorResponseData | ErrorResponseDataOptions;
+}
+/**
+ * RTVI error response message.
+ *
+ * RTVI formatted error response message for relaying failed client requests.
+ */
+export declare class ErrorResponse extends BaseModel {
+    label: MessageLiteral;
+    type: "error-response";
+    id: string;
+    data: ErrorResponseData;
+    static readonly fields: FieldSpecs;
+    constructor(options: ErrorResponseOptions);
+}
+export interface ErrorDataOptions {
+    error: string;
+    /** Indicates the pipeline has stopped due to this error. */
+    fatal: boolean;
+}
+/**
+ * Data for an RTVI error event.
+ *
+ * Contains error information including whether it's fatal.
+ */
+export declare class ErrorData extends BaseModel {
+    error: string;
+    /** Indicates the pipeline has stopped due to this error. */
+    fatal: boolean;
+    static readonly fields: FieldSpecs;
+    constructor(options: ErrorDataOptions);
+}
+export interface ErrorOptions {
+    label?: MessageLiteral;
+    type?: "error";
+    data: ErrorData | ErrorDataOptions;
+}
+/**
+ * RTVI error event message.
+ *
+ * RTVI formatted error message for relaying errors in the pipeline.
+ */
+export declare class Error extends BaseModel {
+    label: MessageLiteral;
+    type: "error";
+    data: ErrorData;
+    static readonly fields: FieldSpecs;
+    constructor(options: ErrorOptions);
+}
+export interface BotReadyDataOptions {
+    version: string;
+    about?: Record<string, unknown> | null;
+    capabilities?: BotCapabilities | BotCapabilitiesOptions | null;
+}
+/**
+ * Data for bot ready notification.
+ *
+ * Contains protocol version and initial configuration.
+ *
+ * - `version`: the RTVI protocol version the bot speaks with this client.
+ * - `about`: information about the bot, such as the Pipecat library and version.
+ * - `capabilities`: what the bot does in this session (media sent and
+ *   received, metrics), so the client can show only the UI that applies.
+ *   Added in protocol 2.2.0.
+ */
+export declare class BotReadyData extends BaseModel {
+    version: string;
+    about: Record<string, unknown> | null;
+    capabilities: BotCapabilities | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: BotReadyDataOptions);
+}
+export interface BotReadyOptions {
+    label?: MessageLiteral;
+    type?: "bot-ready";
+    id: string;
+    data: BotReadyData | BotReadyDataOptions;
+}
+/**
+ * Message indicating bot is ready for interaction.
+ *
+ * Sent after bot initialization is complete.
+ */
+export declare class BotReady extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-ready";
+    id: string;
+    data: BotReadyData;
+    static readonly fields: FieldSpecs;
+    constructor(options: BotReadyOptions);
+}
+export interface SendTextOptionsOptions {
+    runImmediately?: boolean;
+    audioResponse?: boolean;
+}
+/**
+ * Options for sending text input to the LLM.
+ *
+ * Contains options for how the pipeline should process the text input.
+ */
+export declare class SendTextOptions extends BaseModel {
+    runImmediately: boolean;
+    audioResponse: boolean;
+    static readonly fields: FieldSpecs;
+    constructor(options?: SendTextOptionsOptions);
+}
+export interface SendTextDataOptions {
+    content: string;
+    options?: SendTextOptions | SendTextOptionsOptions | null;
+}
+/**
+ * Data format for sending text input to the LLM.
+ *
+ * Contains the text content to send and any options for how the pipeline
+ * should process it.
+ */
+export declare class SendTextData extends BaseModel {
+    content: string;
+    options: SendTextOptions | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: SendTextDataOptions);
+}
+export interface FileSourceOptions {
+    type: RTVIFileSourceType;
+}
+/** Base class for RTVI file sources. */
+export declare class FileSource extends BaseModel {
+    type: RTVIFileSourceType;
+    static readonly fields: FieldSpecs;
+    constructor(options: FileSourceOptions);
+}
+export interface FileBytesOptions {
+    type?: RTVIFileSourceType;
+    /** Base64-encoded string. */
+    bytes: string;
+    width?: number | null;
+    height?: number | null;
+}
+/** File source as base64-encoded bytes. */
+export declare class FileBytes extends FileSource {
+    /** Base64-encoded string. */
+    bytes: string;
+    width: number | null;
+    height: number | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: FileBytesOptions);
+}
+export interface FileUrlOptions {
+    type?: RTVIFileSourceType;
+    url: string;
+}
+/**
+ * File source as a URL.
+ *
+ * - `url`: the file's URL: whatever the `POST /files` upload endpoint
+ *   returned (`pipecat:<id>` with the default local storage, or a URL minted
+ *   by a custom storage backend), a cloud-storage URI (`s3://`, `gs://`), or a
+ *   plain `http(s)` URL. The URL is resolved at completion time: the LLM
+ *   provider fetches it itself when it can (public URLs, its own cloud IAM),
+ *   and otherwise the LLM service's `FileResolver` downloads the bytes and
+ *   inlines them.
+ */
+export declare class FileUrl extends FileSource {
+    url: string;
+    static readonly fields: FieldSpecs;
+    constructor(options: FileUrlOptions);
+}
+export interface FileOptions {
+    /** Mime format of the file, e.g. 'application/pdf'. */
+    format: string;
+    name?: string | null;
+    source: FileBytes | FileUrl | FileBytesOptions | FileUrlOptions;
+}
+/** File data structure for RTVI file sending. */
+export declare class File extends BaseModel {
+    /** Mime format of the file, e.g. 'application/pdf'. */
+    format: string;
+    name: string | null;
+    source: FileBytes | FileUrl;
+    static readonly fields: FieldSpecs;
+    constructor(options: FileOptions);
+}
+export interface SendFileOptionsOptions {
+    runImmediately?: boolean;
+    audioResponse?: boolean;
+    /** E.g. 'detail' in OpenAI or 'citations' in Bedrock. */
+    customOptions?: Record<string, unknown> | null;
+}
+/** Options for sending a file to the LLM. */
+export declare class SendFileOptions extends BaseModel {
+    runImmediately: boolean;
+    audioResponse: boolean;
+    /** E.g. 'detail' in OpenAI or 'citations' in Bedrock. */
+    customOptions: Record<string, unknown> | null;
+    static readonly fields: FieldSpecs;
+    constructor(options?: SendFileOptionsOptions);
+}
+export interface SendFileDataOptions {
+    /** Text to accompany the file. */
+    content: string;
+    file: File | FileOptions;
+    options?: SendFileOptions | SendFileOptionsOptions | null;
+}
+/**
+ * Data format for sending a file to the LLM.
+ *
+ * Contains the information of the file to send and any options for how the
+ * pipeline should process it.
+ */
+export declare class SendFileData extends BaseModel {
+    /** Text to accompany the file. */
+    content: string;
+    file: File;
+    options: SendFileOptions | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: SendFileDataOptions);
+}
+export interface DTMFInputDataOptions {
+    buttons: KeypadEntry[];
+}
+/**
+ * Data format for DTMF keypresses sent from the client.
+ *
+ * Carries one or more keypad entries (`0`-`9`, `*`, `#`), delivered in order,
+ * so the bot's DTMF handling (e.g. a `DTMFAggregator`) sees them exactly as a
+ * telephony transport would deliver rapid keypresses.
+ *
+ * Protocol 2.1.0 replaced the single `button` field with `buttons`.
+ */
+export declare class DTMFInputData extends BaseModel {
+    buttons: KeypadEntry[];
+    static readonly fields: FieldSpecs;
+    constructor(options: DTMFInputDataOptions);
+}
+export interface LLMFunctionCallStartMessageDataOptions {
+    functionName?: string | null;
+}
+/**
+ * Data for LLM function call start notification.
+ *
+ * Contains the function name being called. Fields may be omitted based on the
+ * configured function_call_report_level for security.
+ *
+ * - `functionName`: name of the function called.
+ */
+export declare class LLMFunctionCallStartMessageData extends BaseModel {
+    functionName: string | null;
+    static readonly fields: FieldSpecs;
+    constructor(options?: LLMFunctionCallStartMessageDataOptions);
+}
+export interface LLMFunctionCallStartMessageOptions {
+    label?: MessageLiteral;
+    type?: "llm-function-call-started";
+    data: LLMFunctionCallStartMessageData | LLMFunctionCallStartMessageDataOptions;
+}
+/**
+ * Message notifying that an LLM function call has started.
+ *
+ * Sent when the LLM begins a function call.
+ */
+export declare class LLMFunctionCallStartMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "llm-function-call-started";
+    data: LLMFunctionCallStartMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: LLMFunctionCallStartMessageOptions);
+}
+export interface LLMFunctionCallResultDataOptions {
+    functionName: string;
+    toolCallId: string;
+    arguments: Record<string, unknown>;
+    result: Record<string, unknown> | string;
+}
+/**
+ * Data for LLM function call result.
+ *
+ * Contains function call details and result.
+ */
+export declare class LLMFunctionCallResultData extends BaseModel {
+    functionName: string;
+    toolCallId: string;
+    arguments: Record<string, unknown>;
+    result: Record<string, unknown> | string;
+    static readonly fields: FieldSpecs;
+    constructor(options: LLMFunctionCallResultDataOptions);
+}
+export interface LLMFunctionCallInProgressMessageDataOptions {
+    toolCallId: string;
+    functionName?: string | null;
+    arguments?: Record<string, unknown> | null;
+}
+/**
+ * Data for LLM function call in-progress notification.
+ *
+ * Contains function call details including name, ID, and arguments. Fields
+ * may be omitted based on the configured function_call_report_level for
+ * security.
+ *
+ * - `toolCallId`: unique identifier of the call.
+ * - `functionName`: name of the function called.
+ * - `arguments`: arguments passed to the function.
+ */
+export declare class LLMFunctionCallInProgressMessageData extends BaseModel {
+    toolCallId: string;
+    functionName: string | null;
+    arguments: Record<string, unknown> | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: LLMFunctionCallInProgressMessageDataOptions);
+}
+export interface LLMFunctionCallInProgressMessageOptions {
+    label?: MessageLiteral;
+    type?: "llm-function-call-in-progress";
+    data: LLMFunctionCallInProgressMessageData | LLMFunctionCallInProgressMessageDataOptions;
+}
+/**
+ * Message notifying that an LLM function call is in progress.
+ *
+ * Sent when the LLM function call execution begins.
+ */
+export declare class LLMFunctionCallInProgressMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "llm-function-call-in-progress";
+    data: LLMFunctionCallInProgressMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: LLMFunctionCallInProgressMessageOptions);
+}
+export interface LLMFunctionCallStoppedMessageDataOptions {
+    toolCallId: string;
+    cancelled: boolean;
+    functionName?: string | null;
+    result?: unknown;
+}
+/**
+ * Data for LLM function call stopped notification.
+ *
+ * Contains details about the function call that stopped, including whether
+ * it was cancelled or completed with a result. Fields may be omitted based on
+ * the configured function_call_report_level for security.
+ *
+ * - `toolCallId`: unique identifier of the call.
+ * - `cancelled`: whether the call was cancelled rather than completed.
+ * - `functionName`: name of the function called.
+ * - `result`: the result, when the call completed with one.
+ */
+export declare class LLMFunctionCallStoppedMessageData extends BaseModel {
+    toolCallId: string;
+    cancelled: boolean;
+    functionName: string | null;
+    result: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: LLMFunctionCallStoppedMessageDataOptions);
+}
+export interface LLMFunctionCallStoppedMessageOptions {
+    label?: MessageLiteral;
+    type?: "llm-function-call-stopped";
+    data: LLMFunctionCallStoppedMessageData | LLMFunctionCallStoppedMessageDataOptions;
+}
+/**
+ * Message notifying that an LLM function call has stopped.
+ *
+ * Sent when a function call completes (with result) or is cancelled.
+ */
+export declare class LLMFunctionCallStoppedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "llm-function-call-stopped";
+    data: LLMFunctionCallStoppedMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: LLMFunctionCallStoppedMessageOptions);
+}
+/** Options of a message that only has a label and a type. */
+export interface SignalMessageOptions<T extends string> {
+    label?: MessageLiteral;
+    type?: T;
+}
+/** Message indicating bot LLM processing has started. */
+export declare class BotLLMStartedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-llm-started";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"bot-llm-started">);
+}
+/** Message indicating bot LLM processing has stopped. */
+export declare class BotLLMStoppedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-llm-stopped";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"bot-llm-stopped">);
+}
+/** Message indicating bot TTS processing has started. */
+export declare class BotTTSStartedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-tts-started";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"bot-tts-started">);
+}
+/** Message indicating bot TTS processing has stopped. */
+export declare class BotTTSStoppedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-tts-stopped";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"bot-tts-stopped">);
+}
+export interface TextMessageDataOptions {
+    text: string;
+}
+/**
+ * Data for text-based RTVI messages.
+ *
+ * Contains text content.
+ */
+export declare class TextMessageData extends BaseModel {
+    text: string;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageDataOptions);
+}
+export type SpokenStatus = "new" | "in-progress" | "completed" | null;
+export interface SpokenProgressDataOptions {
+    accumulatedText: string;
+    remainingText: string;
+}
+/**
+ * Word-level TTS progress within a spoken segment.
+ *
+ * - `accumulatedText`: text already spoken in this segment, including the
+ *   current word.
+ * - `remainingText`: text not yet spoken in this segment.
+ */
+export declare class SpokenProgressData extends BaseModel {
+    accumulatedText: string;
+    remainingText: string;
+    static readonly fields: FieldSpecs;
+    constructor(options: SpokenProgressDataOptions);
+}
+export interface BotOutputTransformResultOptions {
+    text: string;
+    accumulatedText?: string | null;
+    remainingText?: string | null;
+}
+/**
+ * Return type for bot output transform functions.
+ *
+ * - `text`: the transformed full text of the segment.
+ * - `accumulatedText`: transformed spoken-so-far portion. Only populated when
+ *   the transform is called from a progress context.
+ * - `remainingText`: transformed not-yet-spoken portion. Only populated when
+ *   the transform is called from a progress context.
+ */
+export declare class BotOutputTransformResult extends BaseModel {
+    text: string;
+    accumulatedText: string | null;
+    remainingText: string | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: BotOutputTransformResultOptions);
+}
+export interface BotOutputMessageDataOptions extends TextMessageDataOptions {
+    textType?: TextType | string;
+    aggregatedBy?: TextType | string | null;
+    segmentId?: number | null;
+    spoken?: boolean | null;
+    willBeSpoken?: boolean | null;
+    spokenStatus?: SpokenStatus;
+    spokenProgress?: SpokenProgressData | SpokenProgressDataOptions | null;
+}
+/**
+ * Data for bot output RTVI messages.
+ *
+ * Extends TextMessageData to include metadata about the output.
+ *
+ * This class supports both protocol v1 (1.4.x) and v2 (2.0.0+) clients. The
+ * observer populates different field subsets depending on the negotiated
+ * version; `sendRtviMessage` serialises with `excludeNone: true` so each
+ * client only sees the fields relevant to its version.
+ *
+ * - `textType`: what form the text is in (e.g., sentence, code, etc.).
+ * - `aggregatedBy`: what form the text is in, always the same as `textType`.
+ *   Deprecated upstream since 1.13.0 (use `textType`); kept because it is
+ *   still on the wire.
+ * - `segmentId`: ID of the source AggregatedTextFrame.
+ * - `spoken`: **(v1 only)** whether the text has been spoken by TTS.
+ * - `willBeSpoken`: **(v2+)** whether the text will be spoken by TTS.
+ * - `spokenStatus`: **(v2+)** lifecycle status of the segment: `"new"` on its
+ *   first message, the only one for text that isn't spoken; `"in-progress"`
+ *   as each of its words is spoken, for TTS services with word timestamps;
+ *   `"completed"` once its last word is spoken.
+ * - `spokenProgress`: **(v2+)** accumulated / remaining text breakdown.
+ *   Present when `willBeSpoken` is true.
+ */
+export declare class BotOutputMessageData extends TextMessageData {
+    textType: TextType | string;
+    aggregatedBy: TextType | string | null;
+    segmentId: number | null;
+    spoken: boolean | null;
+    willBeSpoken: boolean | null;
+    spokenStatus: SpokenStatus;
+    spokenProgress: SpokenProgressData | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: BotOutputMessageDataOptions);
+    /** Fill whichever of `textType` and `aggregatedBy` is missing from the other. */
+    protected static _beforeValidate(data: Record<string, unknown>): Record<string, unknown>;
+}
+export interface BotOutputMessageOptions {
+    label?: MessageLiteral;
+    type?: "bot-output";
+    data: BotOutputMessageData | BotOutputMessageDataOptions;
+}
+/**
+ * Message containing bot output text.
+ *
+ * An event meant to holistically represent what the bot is outputting, along
+ * with metadata about the output and if it has been spoken.
+ */
+export declare class BotOutputMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-output";
+    data: BotOutputMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: BotOutputMessageOptions);
+}
+/** Options of a message whose data is a `TextMessageData`. */
+export interface TextMessageOptions<T extends string> {
+    label?: MessageLiteral;
+    type?: T;
+    data: TextMessageData | TextMessageDataOptions;
+}
+/**
+ * Message containing bot transcription text.
+ *
+ * Sent when the bot's speech is transcribed.
+ */
+export declare class BotTranscriptionMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-transcription";
+    data: TextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageOptions<"bot-transcription">);
+}
+/**
+ * Message containing bot LLM text output.
+ *
+ * Sent when the bot's LLM generates text.
+ *
+ * Deprecated upstream since 1.13.0 (use `LLMRawTextMessage`); kept because
+ * the observer still sends it while `botLlmEnabled` is on.
+ */
+export declare class BotLLMTextMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-llm-text";
+    data: TextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageOptions<"bot-llm-text">);
+}
+export interface BotLLMMarkerMessageDataOptions {
+    text: string;
+    kind?: string | null;
+    raw?: string;
+    markers?: string[];
+}
+/**
+ * Data for a bot LLM marker message.
+ *
+ * - `text`: the marker as the LLM produced it; empty when the response
+ *   carried none.
+ * - `kind`: what the marker means, in the emitter's vocabulary (the
+ *   turn-completion mixin's `complete`, `short` or `long`), or `null` when the
+ *   emitter gave none.
+ * - `raw`: the response's text as the LLM produced it, markers included.
+ * - `markers`: every marker the emitter recognizes.
+ */
+export declare class BotLLMMarkerMessageData extends BaseModel {
+    text: string;
+    kind: string | null;
+    raw: string;
+    markers: string[];
+    static readonly fields: FieldSpecs;
+    constructor(options: BotLLMMarkerMessageDataOptions);
+}
+export interface BotLLMMarkerMessageOptions {
+    label?: MessageLiteral;
+    type?: "bot-llm-marker";
+    data: BotLLMMarkerMessageData | BotLLMMarkerMessageDataOptions;
+}
+/**
+ * Message reporting the sideband marker the bot's LLM emitted in a response.
+ *
+ * A marker is structured assistant output kept out of the spoken text, such
+ * as the turn-completion markers of `filterIncompleteUserTurns`. Sent once
+ * per response, when it ends, and only when the observer's
+ * `botLlmMarkerEnabled` is on.
+ */
+export declare class BotLLMMarkerMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-llm-marker";
+    data: BotLLMMarkerMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: BotLLMMarkerMessageOptions);
+}
+/**
+ * Message containing bot TTS text output.
+ *
+ * Sent when text is being processed by TTS.
+ *
+ * Deprecated upstream since 1.13.0 (use `TTSRawTextMessage`); kept because
+ * the observer still sends it while `botTtsEnabled` is on.
+ */
+export declare class BotTTSTextMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-tts-text";
+    data: TextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageOptions<"bot-tts-text">);
+}
+export interface AudioMessageDataOptions {
+    audio: string;
+    sampleRate: number;
+    numChannels: number;
+}
+/**
+ * Data for audio-based RTVI messages.
+ *
+ * Contains audio data and metadata.
+ */
+export declare class AudioMessageData extends BaseModel {
+    audio: string;
+    sampleRate: number;
+    numChannels: number;
+    static readonly fields: FieldSpecs;
+    constructor(options: AudioMessageDataOptions);
+}
+export interface BotTTSAudioMessageOptions {
+    label?: MessageLiteral;
+    type?: "bot-tts-audio";
+    data: AudioMessageData | AudioMessageDataOptions;
+}
+/**
+ * Message containing bot TTS audio output.
+ *
+ * Sent when the bot's TTS generates audio.
+ */
+export declare class BotTTSAudioMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-tts-audio";
+    data: AudioMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: BotTTSAudioMessageOptions);
+}
+export interface UserTranscriptionMessageDataOptions {
+    text: string;
+    userId: string;
+    timestamp: string;
+    final: boolean;
+}
+/**
+ * Data for user transcription messages.
+ *
+ * Contains transcription text and metadata.
+ *
+ * Deprecated upstream since 1.13.0 (use `STTRawTextMessageData`); kept
+ * because the observer still sends `user-transcription` messages.
+ */
+export declare class UserTranscriptionMessageData extends BaseModel {
+    text: string;
+    userId: string;
+    timestamp: string;
+    final: boolean;
+    static readonly fields: FieldSpecs;
+    constructor(options: UserTranscriptionMessageDataOptions);
+}
+export interface UserTranscriptionMessageOptions {
+    label?: MessageLiteral;
+    type?: "user-transcription";
+    data: UserTranscriptionMessageData | UserTranscriptionMessageDataOptions;
+}
+/**
+ * Message containing user transcription.
+ *
+ * Sent when user speech is transcribed.
+ *
+ * Deprecated upstream since 1.13.0 (use `STTRawTextMessage`, or
+ * `UserInputMessage` for what the user said); kept because the observer
+ * still sends it.
+ */
+export declare class UserTranscriptionMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-transcription";
+    data: UserTranscriptionMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: UserTranscriptionMessageOptions);
+}
+export type UserInputType = "transcription" | "chat" | "backchannel";
+export interface UserInputMessageDataOptions {
+    text: string;
+    inputType: UserInputType;
+    timestamp: string;
+    final: boolean;
+    userId?: string | null;
+    msgId?: string | null;
+}
+/**
+ * Data for user input messages.
+ *
+ * - `text`: what the user said or typed.
+ * - `inputType`: what kind of input it is: `"transcription"` for speech
+ *   transcribed by the STT, `"chat"` for text the client sent, or
+ *   `"backchannel"` for a short acknowledgment the user said while the bot
+ *   talks, such as "mhm".
+ * - `timestamp`: when the user said or sent it.
+ * - `final`: whether the text is final. Only an interim transcription isn't.
+ * - `userId`: identifier for the user who spoke or typed. For chat, set only
+ *   when the transport knows the sender, such as Daily and LiveKit.
+ * - `msgId`: for chat, the id of the client's `send-text` message.
+ */
+export declare class UserInputMessageData extends BaseModel {
+    text: string;
+    inputType: UserInputType;
+    timestamp: string;
+    final: boolean;
+    userId: string | null;
+    msgId: string | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: UserInputMessageDataOptions);
+}
+export interface UserInputMessageOptions {
+    label?: MessageLiteral;
+    type?: "user-input";
+    data: UserInputMessageData | UserInputMessageDataOptions;
+}
+/**
+ * Message containing what the user said or typed.
+ *
+ * The user's counterpart of `bot-output`. A backchannel doesn't interrupt the
+ * bot or reach the LLM.
+ */
+export declare class UserInputMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-input";
+    data: UserInputMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: UserInputMessageOptions);
+}
+/**
+ * Message containing user text input for LLM.
+ *
+ * Sent when user text is processed by the LLM.
+ */
+export declare class UserLLMTextMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-llm-text";
+    data: TextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageOptions<"user-llm-text">);
+}
+export interface STTRawTextMessageDataOptions {
+    text: string;
+    userId: string;
+    timestamp: string;
+    final: boolean;
+}
+/**
+ * Data for STT raw text messages.
+ *
+ * - `text`: the transcribed text.
+ * - `userId`: identifier for the user who spoke.
+ * - `timestamp`: when the user said it.
+ * - `final`: whether the transcription is final, as opposed to interim.
+ */
+export declare class STTRawTextMessageData extends BaseModel {
+    text: string;
+    userId: string;
+    timestamp: string;
+    final: boolean;
+    static readonly fields: FieldSpecs;
+    constructor(options: STTRawTextMessageDataOptions);
+}
+export interface STTRawTextMessageOptions {
+    label?: MessageLiteral;
+    type?: "stt-raw-text";
+    data: STTRawTextMessageData | STTRawTextMessageDataOptions;
+}
+/** Message reporting a transcription as the STT produced it, interim ones included. */
+export declare class STTRawTextMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "stt-raw-text";
+    data: STTRawTextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: STTRawTextMessageOptions);
+}
+/** Message reporting a chunk of text as the LLM streamed it. */
+export declare class LLMRawTextMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "llm-raw-text";
+    data: TextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageOptions<"llm-raw-text">);
+}
+/** Message reporting text the TTS speaks, as it is spoken. */
+export declare class TTSRawTextMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "tts-raw-text";
+    data: TextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageOptions<"tts-raw-text">);
+}
+/** Message indicating user has started speaking. */
+export declare class UserStartedSpeakingMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-started-speaking";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"user-started-speaking">);
+}
+/** Message indicating user has stopped speaking. */
+export declare class UserStoppedSpeakingMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-stopped-speaking";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"user-stopped-speaking">);
+}
+/**
+ * Message indicating VAD detected the user started speaking.
+ *
+ * Raw VAD signal, emitted independently of turn finalization (unlike
+ * `user-started-speaking`, which a turn strategy may gate or defer).
+ */
+export declare class VADUserStartedSpeakingMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "vad-user-started-speaking";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"vad-user-started-speaking">);
+}
+/**
+ * Message indicating VAD detected the user stopped speaking.
+ *
+ * Raw VAD signal, emitted independently of turn finalization (unlike
+ * `user-stopped-speaking`, which a turn strategy may gate or defer).
+ */
+export declare class VADUserStoppedSpeakingMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "vad-user-stopped-speaking";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"vad-user-stopped-speaking">);
+}
+/** Message indicating user has been muted. */
+export declare class UserMuteStartedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-mute-started";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"user-mute-started">);
+}
+/** Message indicating user has been unmuted. */
+export declare class UserMuteStoppedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-mute-stopped";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"user-mute-stopped">);
+}
+/** Message indicating bot has started speaking. */
+export declare class BotStartedSpeakingMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-started-speaking";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"bot-started-speaking">);
+}
+/** Message indicating bot has stopped speaking. */
+export declare class BotStoppedSpeakingMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-stopped-speaking";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"bot-stopped-speaking">);
+}
+/**
+ * Message indicating the bot was interrupted and its in-flight output cut off.
+ *
+ * Fires for any pipeline interruption (a VAD-detected user barge-in or a
+ * programmatic interrupt, e.g. `send-text` with `run_immediately`) so a
+ * client can drop whatever the bot was mid-saying.
+ */
+export declare class BotInterruptedMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-interrupted";
+    static readonly fields: FieldSpecs;
+    constructor(options?: SignalMessageOptions<"bot-interrupted">);
+}
+export interface MetricsMessageOptions {
+    label?: MessageLiteral;
+    type?: "metrics";
+    data: Record<string, unknown>;
+}
+/**
+ * Message containing performance metrics.
+ *
+ * Sent to provide performance and usage metrics.
+ */
+export declare class MetricsMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "metrics";
+    data: Record<string, unknown>;
+    static readonly fields: FieldSpecs;
+    constructor(options: MetricsMessageOptions);
+}
+export interface ServerMessageOptions {
+    label?: MessageLiteral;
+    type?: "server-message";
+    data: unknown;
+}
+/**
+ * Generic server message.
+ *
+ * Used for custom server-to-client messages.
+ */
+export declare class ServerMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "server-message";
+    data: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: ServerMessageOptions);
+}
+export interface AudioLevelMessageDataOptions {
+    value: number;
+}
+/** Data format for sending audio levels. */
+export declare class AudioLevelMessageData extends BaseModel {
+    value: number;
+    static readonly fields: FieldSpecs;
+    constructor(options: AudioLevelMessageDataOptions);
+}
+export interface AudioLevelMessageOptions<T extends string> {
+    label?: MessageLiteral;
+    type?: T;
+    data: AudioLevelMessageData | AudioLevelMessageDataOptions;
+}
+/** Message indicating user audio level. */
+export declare class UserAudioLevelMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "user-audio-level";
+    data: AudioLevelMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: AudioLevelMessageOptions<"user-audio-level">);
+}
+/** Message indicating bot audio level. */
+export declare class BotAudioLevelMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "bot-audio-level";
+    data: AudioLevelMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: AudioLevelMessageOptions<"bot-audio-level">);
+}
+/** Message including a system log. */
+export declare class SystemLogMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "system-log";
+    data: TextMessageData;
+    static readonly fields: FieldSpecs;
+    constructor(options: TextMessageOptions<"system-log">);
+}
+export interface UIEventDataOptions {
+    event: string;
+    payload?: unknown;
+}
+/**
+ * Inner `data` for a `ui-event` message.
+ *
+ * - `event`: app-defined event.
+ * - `payload`: app-defined payload, schemaless by design.
+ */
+export declare class UIEventData extends BaseModel {
+    event: string;
+    payload: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: UIEventDataOptions);
+}
+export interface UICommandDataOptions {
+    command: string;
+    payload?: unknown;
+}
+/**
+ * Inner `data` for a `ui-command` message.
+ *
+ * - `command`: app-defined command.
+ * - `payload`: app-defined payload (already a plain object by the time it
+ *   lands on the wire). The standard command payload models below produce the
+ *   right shape via `modelDump()`.
+ */
+export declare class UICommandData extends BaseModel {
+    command: string;
+    payload: unknown;
+    static readonly fields: FieldSpecs;
+    constructor(options: UICommandDataOptions);
+}
+export interface A11yNodeOptions {
+    ref: string;
+    role: string;
+    name?: string | null;
+    value?: string | null;
+    state?: string[] | null;
+    level?: number | null;
+    colcount?: number | null;
+    rowcount?: number | null;
+    children?: (A11yNode | A11yNodeOptions)[] | null;
+    /** Extra fields are allowed. */
+    [key: string]: unknown;
+}
+/**
+ * One node in the UI accessibility snapshot tree.
+ *
+ * Mirrors the client-side `A11yNode` wire shape. Extra fields are allowed
+ * (kept in `modelExtra`) so clients can add platform-specific or future
+ * metadata without breaking older servers.
+ *
+ * - `ref`: stable client-assigned element reference.
+ * - `role`: ARIA-style role for the node.
+ * - `name`: optional accessible name.
+ * - `value`: optional current value for inputs/progress/etc.
+ * - `state`: optional short state tags (e.g. `"focused"`, `"disabled"`,
+ *   `"offscreen"`).
+ * - `level`: optional heading level.
+ * - `colcount`: optional column count for grid-like containers.
+ * - `rowcount`: optional row count for grid-like containers.
+ * - `children`: optional child nodes.
+ */
+export declare class A11yNode extends BaseModel {
+    static readonly extra: "allow";
+    ref: string;
+    role: string;
+    name: string | null;
+    value: string | null;
+    state: string[] | null;
+    level: number | null;
+    colcount: number | null;
+    rowcount: number | null;
+    children: A11yNode[] | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: A11yNodeOptions);
+}
+export interface A11ySelectionOptions {
+    ref: string;
+    text: string;
+    startOffset?: number | null;
+    endOffset?: number | null;
+    /** Extra fields are allowed. */
+    [key: string]: unknown;
+}
+/**
+ * The user's current text selection in the UI snapshot.
+ *
+ * Extra fields are allowed for forward compatibility with client snapshot
+ * additions.
+ *
+ * - `ref`: ref of the element that carries the selection.
+ * - `text`: selected text.
+ * - `startOffset`: optional selection start offset.
+ * - `endOffset`: optional selection end offset.
+ */
+export declare class A11ySelection extends BaseModel {
+    static readonly extra: "allow";
+    ref: string;
+    text: string;
+    startOffset: number | null;
+    endOffset: number | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: A11ySelectionOptions);
+}
+export interface A11ySnapshotOptions {
+    root: A11yNode | A11yNodeOptions;
+    capturedAt: number;
+    selection?: A11ySelection | A11ySelectionOptions | null;
+    /** Extra fields are allowed. */
+    [key: string]: unknown;
+}
+/**
+ * Client accessibility snapshot sent in a `ui-snapshot` message.
+ *
+ * Mirrors the client-side `A11ySnapshot` wire shape. Extra fields are allowed
+ * so clients can add compatible metadata over time.
+ *
+ * - `root`: root accessibility node.
+ * - `capturedAt`: client-side epoch milliseconds when captured.
+ * - `selection`: optional current text selection.
+ */
+export declare class A11ySnapshot extends BaseModel {
+    static readonly extra: "allow";
+    root: A11yNode;
+    capturedAt: number;
+    selection: A11ySelection | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: A11ySnapshotOptions);
+}
+export interface UISnapshotDataOptions {
+    tree: A11ySnapshot | A11ySnapshotOptions;
+}
+/**
+ * Inner `data` for a `ui-snapshot` message.
+ *
+ * The accessibility snapshot tree mirrors the client-side `A11ySnapshot` wire
+ * shape and is kept forward-compatible by allowing extra fields on the
+ * snapshot models.
+ *
+ * - `tree`: the serialized accessibility tree.
+ */
+export declare class UISnapshotData extends BaseModel {
+    tree: A11ySnapshot;
+    static readonly fields: FieldSpecs;
+    constructor(options: UISnapshotDataOptions);
+}
+export interface UICancelJobGroupDataOptions {
+    jobId: string;
+    reason?: string | null;
+}
+/**
+ * Inner `data` for a `ui-cancel-job-group` message.
+ *
+ * - `jobId`: the job group id the client wants cancelled.
+ * - `reason`: optional human-readable reason.
+ */
+export declare class UICancelJobGroupData extends BaseModel {
+    jobId: string;
+    reason: string | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: UICancelJobGroupDataOptions);
+}
+export interface UIJobGroupStartedDataOptions {
+    kind?: "group_started";
+    jobId: string;
+    workers?: string[] | null;
+    label?: string | null;
+    cancellable?: boolean;
+    at?: number;
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `group_started`.
+ *
+ * - `kind`: always `"group_started"`.
+ * - `jobId`: shared job-group identifier for the group.
+ * - `workers`: names of the workers the work was dispatched to.
+ * - `label`: optional human-readable label for the group.
+ * - `cancellable`: whether the client may request cancellation.
+ * - `at`: epoch milliseconds when the group started.
+ */
+export declare class UIJobGroupStartedData extends BaseModel {
+    kind: "group_started";
+    jobId: string;
+    workers: string[] | null;
+    label: string | null;
+    cancellable: boolean;
+    at: number;
+    static readonly fields: FieldSpecs;
+    constructor(options: UIJobGroupStartedDataOptions);
+}
+export interface UIJobUpdateDataOptions {
+    kind?: "job_update";
+    jobId: string;
+    workerName: string;
+    data?: unknown;
+    at?: number;
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `job_update`.
+ *
+ * - `kind`: always `"job_update"`.
+ * - `jobId`: the shared job-group identifier.
+ * - `workerName`: the worker that produced the update.
+ * - `data`: the worker's update payload, forwarded verbatim.
+ * - `at`: epoch milliseconds when the update was emitted.
+ */
+export declare class UIJobUpdateData extends BaseModel {
+    kind: "job_update";
+    jobId: string;
+    workerName: string;
+    data: unknown;
+    at: number;
+    static readonly fields: FieldSpecs;
+    constructor(options: UIJobUpdateDataOptions);
+}
+export interface UIJobCompletedDataOptions {
+    kind?: "job_completed";
+    jobId: string;
+    workerName: string;
+    status: string;
+    response?: unknown;
+    at?: number;
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `job_completed`.
+ *
+ * - `kind`: always `"job_completed"`.
+ * - `jobId`: the shared job-group identifier.
+ * - `workerName`: the worker that produced the response.
+ * - `status`: completion status string.
+ * - `response`: the worker's response payload.
+ * - `at`: epoch milliseconds when the response was received.
+ */
+export declare class UIJobCompletedData extends BaseModel {
+    kind: "job_completed";
+    jobId: string;
+    workerName: string;
+    status: string;
+    response: unknown;
+    at: number;
+    static readonly fields: FieldSpecs;
+    constructor(options: UIJobCompletedDataOptions);
+}
+export interface UIJobGroupCompletedDataOptions {
+    kind?: "group_completed";
+    jobId: string;
+    at?: number;
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `group_completed`.
+ *
+ * - `kind`: always `"group_completed"`.
+ * - `jobId`: the shared job-group identifier.
+ * - `at`: epoch milliseconds when the group completed.
+ */
+export declare class UIJobGroupCompletedData extends BaseModel {
+    kind: "group_completed";
+    jobId: string;
+    at: number;
+    static readonly fields: FieldSpecs;
+    constructor(options: UIJobGroupCompletedDataOptions);
+}
+/**
+ * Discriminated union over the four job-group lifecycle data shapes, keyed
+ * by the `kind` field.
+ */
+export type UIJobGroupData = UIJobGroupStartedData | UIJobUpdateData | UIJobCompletedData | UIJobGroupCompletedData;
+export interface UIEventMessageOptions {
+    label?: MessageLiteral;
+    type?: "ui-event";
+    id: string;
+    data: UIEventData | UIEventDataOptions;
+}
+/** RTVI `ui-event` message (client -> server). */
+export declare class UIEventMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "ui-event";
+    id: string;
+    data: UIEventData;
+    static readonly fields: FieldSpecs;
+    constructor(options: UIEventMessageOptions);
+}
+export interface UICommandMessageOptions {
+    label?: MessageLiteral;
+    type?: "ui-command";
+    data: UICommandData | UICommandDataOptions;
+}
+/** RTVI `ui-command` message (server -> client). */
+export declare class UICommandMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "ui-command";
+    data: UICommandData;
+    static readonly fields: FieldSpecs;
+    constructor(options: UICommandMessageOptions);
+}
+export interface UISnapshotMessageOptions {
+    label?: MessageLiteral;
+    type?: "ui-snapshot";
+    id: string;
+    data: UISnapshotData | UISnapshotDataOptions;
+}
+/** RTVI `ui-snapshot` message (client -> server). */
+export declare class UISnapshotMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "ui-snapshot";
+    id: string;
+    data: UISnapshotData;
+    static readonly fields: FieldSpecs;
+    constructor(options: UISnapshotMessageOptions);
+}
+export interface UICancelJobGroupMessageOptions {
+    label?: MessageLiteral;
+    type?: "ui-cancel-job-group";
+    id: string;
+    data: UICancelJobGroupData | UICancelJobGroupDataOptions;
+}
+/** RTVI `ui-cancel-job-group` message (client -> server). */
+export declare class UICancelJobGroupMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "ui-cancel-job-group";
+    id: string;
+    data: UICancelJobGroupData;
+    static readonly fields: FieldSpecs;
+    constructor(options: UICancelJobGroupMessageOptions);
+}
+export interface UIJobGroupMessageOptions {
+    label?: MessageLiteral;
+    type?: "ui-job-group";
+    data: UIJobGroupData;
+}
+/**
+ * RTVI `ui-job-group` message (server -> client).
+ *
+ * The `data` field is one of the four job-group lifecycle shapes,
+ * discriminated by the `kind` field.
+ */
+export declare class UIJobGroupMessage extends BaseModel {
+    label: MessageLiteral;
+    type: "ui-job-group";
+    data: UIJobGroupData;
+    static readonly fields: FieldSpecs;
+    constructor(options: UIJobGroupMessageOptions);
+}
+export interface ToastOptions {
+    title: string;
+    subtitle?: string | null;
+    description?: string | null;
+    imageUrl?: string | null;
+    durationMs?: number | null;
+}
+/**
+ * A transient notification surface shown on the client.
+ *
+ * - `title`: required headline.
+ * - `subtitle`: optional second line beneath the title.
+ * - `description`: optional body text.
+ * - `imageUrl`: optional leading image.
+ * - `durationMs`: optional dismiss timer. Client default applies when null.
+ */
+export declare class Toast extends BaseModel {
+    title: string;
+    subtitle: string | null;
+    description: string | null;
+    imageUrl: string | null;
+    durationMs: number | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: ToastOptions);
+}
+export interface NavigateOptions {
+    view: string;
+    params?: Record<string, unknown> | null;
+}
+/**
+ * Client-side navigation to a named view.
+ *
+ * - `view`: app-defined view name (route, screen id, tab key, etc.).
+ * - `params`: optional view-specific parameters.
+ */
+export declare class Navigate extends BaseModel {
+    view: string;
+    params: Record<string, unknown> | null;
+    static readonly fields: FieldSpecs;
+    constructor(options: NavigateOptions);
+}
+export interface ScrollToOptions {
+    ref?: string | null;
+    targetId?: string | null;
+    behavior?: string | null;
+}
+/**
+ * Scroll a target element into view.
+ *
+ * The client resolves the target by `ref` first (a snapshot ref like `"e42"`
+ * assigned by the a11y walker), then falls back to `targetId`
+ * (`document.getElementById`). Supply whichever you have; `ref` is the normal
+ * choice when acting on a node from `<ui_state>`.
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client.
+ * - `behavior`: optional scroll behavior hint. Typical values: `"smooth"` or
+ *   `"instant"`. Clients may ignore.
+ */
+export declare class ScrollTo extends BaseModel {
+    ref: string | null;
+    targetId: string | null;
+    behavior: string | null;
+    static readonly fields: FieldSpecs;
+    constructor(options?: ScrollToOptions);
+}
+export interface HighlightOptions {
+    ref?: string | null;
+    targetId?: string | null;
+    durationMs?: number | null;
+}
+/**
+ * Briefly emphasize a target element (flash, glow, pulse).
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client.
+ * - `durationMs`: optional highlight duration. Client default applies when
+ *   null.
+ */
+export declare class Highlight extends BaseModel {
+    ref: string | null;
+    targetId: string | null;
+    durationMs: number | null;
+    static readonly fields: FieldSpecs;
+    constructor(options?: HighlightOptions);
+}
+export interface FocusOptions {
+    ref?: string | null;
+    targetId?: string | null;
+}
+/**
+ * Move input focus to a target element.
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client.
+ */
+export declare class Focus extends BaseModel {
+    ref: string | null;
+    targetId: string | null;
+    static readonly fields: FieldSpecs;
+    constructor(options?: FocusOptions);
+}
+export interface ClickOptions {
+    ref?: string | null;
+    targetId?: string | null;
+}
+/**
+ * Click an element on the client.
+ *
+ * Closes the form-fill loop for non-text inputs (checkboxes, radios) and
+ * exposes the rest of the action vocabulary (submit buttons, links,
+ * app-specific clickable nodes). The standard handler silently no-ops on
+ * `disabled` targets so the worker can't bypass UI affordances the user is
+ * meant to control.
+ *
+ * For native `<select>`, prefer `SetInputValue` (clicking options doesn't
+ * reliably change the selection); for custom comboboxes (ARIA listbox +
+ * popup), apps wire their own command matching the library's interaction
+ * model.
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client. Used as a fallback when
+ *   `ref` is not set or has gone stale.
+ */
+export declare class Click extends BaseModel {
+    ref: string | null;
+    targetId: string | null;
+    static readonly fields: FieldSpecs;
+    constructor(options?: ClickOptions);
+}
+export interface SetInputValueOptions {
+    value?: string;
+    ref?: string | null;
+    targetId?: string | null;
+    replace?: boolean;
+}
+/**
+ * Write a value into a text input or textarea on the client.
+ *
+ * Use this for form-filling: the worker has decided what should go into a
+ * field (clarifying answer, tax form entry, etc.) and asks the client to
+ * populate it. With `replace: true` (the default), the existing value is
+ * overwritten; with `replace: false` the value is appended.
+ *
+ * The standard handler silently no-ops on `disabled`, `readonly`, and
+ * `<input type="hidden">` targets so the worker can't write into fields the
+ * user can't.
+ *
+ * - `value`: the text to write.
+ * - `ref`: snapshot ref from `<ui_state>`. Typically the ref of an `<input>`
+ *   or `<textarea>`.
+ * - `targetId`: element id registered on the client. Used as a fallback when
+ *   `ref` is not set or has gone stale.
+ * - `replace`: when true (the default), overwrite the current value. When
+ *   false, append to it.
+ */
+export declare class SetInputValue extends BaseModel {
+    value: string;
+    ref: string | null;
+    targetId: string | null;
+    replace: boolean;
+    static readonly fields: FieldSpecs;
+    constructor(options?: SetInputValueOptions);
+}
+export interface SelectTextOptions {
+    ref?: string | null;
+    targetId?: string | null;
+    startOffset?: number | null;
+    endOffset?: number | null;
+}
+/**
+ * Select text on the page so the user can see what the worker means.
+ *
+ * Mirror of the `selection` field surfaced in the snapshot. Use this to point
+ * the user's attention at a specific paragraph or range after the worker has
+ * decided what it's referring to.
+ *
+ * With `startOffset` and `endOffset` omitted, the entire target's text
+ * content is selected (`Range.selectNodeContents` for document elements;
+ * `el.select()` for `<input>` / `<textarea>`).
+ *
+ * - `ref`: snapshot ref from `<ui_state>`. Typically the ref of a paragraph
+ *   or input element.
+ * - `targetId`: element id registered on the client. Used as a fallback when
+ *   `ref` is not set or has gone stale.
+ * - `startOffset`: character offset within the target's text where the
+ *   selection should start. For `<input>` and `<textarea>` this is the value
+ *   offset; for document elements it is computed against the concatenation of
+ *   descendant text nodes in document order.
+ * - `endOffset`: end character offset, exclusive. Same coordinate system as
+ *   `startOffset`.
+ */
+export declare class SelectText extends BaseModel {
+    ref: string | null;
+    targetId: string | null;
+    startOffset: number | null;
+    endOffset: number | null;
+    static readonly fields: FieldSpecs;
+    constructor(options?: SelectTextOptions);
+}
+export {};
+//# sourceMappingURL=models.d.ts.map