import TypedEmitter from "typed-emitter";
/**
 * Copyright (c) 2026, Daily.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */
/** Payload for the built-in `toast` command. */
export interface ToastPayload {
    title: string;
    subtitle?: string | null;
    description?: string | null;
    image_url?: string | null;
    duration_ms?: number | null;
}
/** Payload for the built-in `navigate` command. */
export interface NavigatePayload {
    view: string;
    params?: Record<string, unknown> | null;
}
/** Payload for the built-in `scroll_to` command. */
export interface ScrollToPayload {
    /**
     * Snapshot ref (e.g. `"e42"`) assigned by the a11y walker. When
     * set, the default handler resolves this first; use when the server
     * is referencing an element it saw in `<ui_state>`.
     */
    ref?: string | null;
    /**
     * Element id (`document.getElementById`). Used as a fallback when
     * `ref` is not set or no longer resolves.
     */
    target_id?: string | null;
    /** Typically `"smooth"` or `"instant"`. Clients may ignore. */
    behavior?: string | null;
}
/** Payload for the built-in `highlight` command. */
export interface HighlightPayload {
    ref?: string | null;
    target_id?: string | null;
    duration_ms?: number | null;
}
/** Payload for the built-in `focus` command. */
export interface FocusPayload {
    ref?: string | null;
    target_id?: string | null;
}
/**
 * Payload for the built-in `click` command.
 *
 * 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 refuses on `disabled` targets.
 *
 * For native `<select>`, prefer `set_input_value` (clicking
 * options doesn't reliably change the selection); for custom
 * comboboxes, apps wire their own command matching the library's
 * interaction model.
 */
export interface ClickPayload {
    ref?: string | null;
    target_id?: string | null;
}
/**
 * Payload for the built-in `set_input_value` command.
 *
 * Asks the client to write `value` into a text input, textarea, or
 * native `<select>`. The default handler refuses to write into
 * `disabled`, `readonly`, or `<input type="hidden">` targets so the
 * worker can't bypass UI affordances the user is meant to control.
 *
 * For text inputs and textareas, `replace: false` appends the value
 * to whatever is already in the field; the default replaces. The
 * flag is ignored for native `<select>` (a select either has the
 * value or doesn't; "appending" is meaningless).
 */
export interface SetInputValuePayload {
    ref?: string | null;
    target_id?: string | null;
    value: string;
    /** When omitted, defaults to `true` (replace existing value). */
    replace?: boolean | null;
}
/**
 * Payload for the built-in `select_text` command.
 *
 * Mirror of the read-side {@link A11ySelection}: the worker asks the
 * client to make a text selection on the page so the user can see
 * what content the worker is referring to. With `start_offset` /
 * `end_offset` omitted, the entire target's text is selected.
 *
 * Document elements use a `Range` over descendant text nodes and the
 * default handler walks them to convert character offsets into
 * `(textNode, offsetInNode)` pairs. `<input>` and `<textarea>`
 * targets use `setSelectionRange(start, end)` (or `el.select()` when
 * offsets are absent).
 */
export interface SelectTextPayload {
    ref?: string | null;
    target_id?: string | null;
    /** Character offset within the target where the selection starts. */
    start_offset?: number | null;
    /** End character offset, exclusive. */
    end_offset?: number | null;
}
/**
 * Status of a worker within a job group.
 *
 * Mirrors the server's `pipecat.pipeline.job_context.JobStatus`.
 * Jobs are surfaced to the client as `"running"` from the moment the
 * group_started envelope arrives. The terminal status is set when
 * `job_completed` arrives.
 */
export type JobStatus = "running" | "completed" | "cancelled" | "failed" | "error";
/** Group dispatched: the worker list is now known. */
export interface UIJobGroupStartedEnvelope {
    kind: "group_started";
    /** Shared identifier for every job in the group. */
    job_id: string;
    /** Worker names in dispatch order. */
    workers: string[];
    /** Optional human-readable label set by the server. */
    label?: string | null;
    /** Whether the client may request cancellation via `cancelUIJobGroup`. */
    cancellable: boolean;
    /** Epoch ms when the group started. */
    at: number;
}
/** Per-worker progress: `data` is whatever the worker passed to `send_job_update`. */
export interface UIJobUpdateEnvelope {
    kind: "job_update";
    job_id: string;
    /** The worker that produced this update. */
    worker_name: string;
    /** Worker-defined payload. Forwarded verbatim. */
    data: unknown;
    at: number;
}
/** Per-worker terminal: status + final response. */
export interface UIJobCompletedEnvelope {
    kind: "job_completed";
    job_id: string;
    worker_name: string;
    status: JobStatus;
    /** Worker's final response payload. */
    response?: unknown;
    at: number;
}
/** Group terminal: every worker has responded (or the group was cancelled). */
export interface UIJobGroupCompletedEnvelope {
    kind: "group_completed";
    job_id: string;
    at: number;
}
/** Discriminated union of every `ui-job-group` envelope kind. */
export type UIJobGroupEnvelope = UIJobGroupStartedEnvelope | UIJobUpdateEnvelope | UIJobCompletedEnvelope | UIJobGroupCompletedEnvelope;
/**
 * Signature for a UI job-group lifecycle listener.
 *
 * Receives every `ui-job-group` envelope in arrival order. Switch on
 * `envelope.kind` to react to specific lifecycle phases. The React
 * `useUIJobGroups` hook is the recommended consumer for app code; this
 * lower-level listener is for hosts that want to drive their own
 * state.
 */
export type UIJobGroupListener = (envelope: UIJobGroupEnvelope) => void;
/**
 * One node in the accessibility snapshot tree.
 *
 * Shape is modeled on Playwright's accessibility snapshot and the
 * Playwright MCP server's LLM-facing serialization. Portable across
 * web, iOS (UIAccessibility), and Android (AccessibilityNodeInfo).
 *
 * Stability: this is the v1 wire format. Field names and semantics
 * are versioned via the SDK's package version; consumer servers
 * (e.g. `pipecat`'s `UIWorker`) track compatible client
 * releases in their own changelogs.
 */
export interface A11yNode {
    /**
     * Stable reference id of the form `e{N}`. The same DOM node keeps
     * the same ref across snapshots for as long as it is mounted. Lets
     * the LLM cross-reference elements between turns ("the button I
     * mentioned earlier").
     */
    ref: string;
    /** ARIA role (explicit or tag-derived). */
    role: string;
    /** Accessible name, truncated to 100 chars. */
    name?: string;
    /** Current value for inputs (omitted for passwords), progress, etc. */
    value?: string;
    /**
     * Short state tags. Known values: `"focused"`, `"selected"`,
     * `"expanded"`, `"checked"`, `"disabled"`, `"offscreen"`.
     * Apps may add their own, but should stick to single lowercase
     * words so they render cleanly as `[tag]` in `<ui_state>`.
     */
    state?: string[];
    /** Heading level, 1-6. */
    level?: number;
    /**
     * Column count for grid-like containers. Populated from
     * `aria-colcount` on the element. Lets the LLM compute
     * row/column positions from the flat reading order of children.
     */
    colcount?: number;
    /**
     * Row count for grid-like containers. Populated from
     * `aria-rowcount` on the element.
     */
    rowcount?: number;
    /** Child nodes. */
    children?: A11yNode[];
}
/**
 * The user's current text selection, when one exists.
 *
 * Lets the worker ground deictic references like "this paragraph",
 * "what I selected", or "the highlighted text" against actual on-page
 * content rather than re-asking the user to repeat it.
 *
 * Document selections (selecting text across paragraphs, headings,
 * etc.) carry the closest common-ancestor element's `ref` plus the
 * full selected text. Offsets are not provided for document
 * selections because they would require walking text-node positions
 * inside the ancestor; the worker reasons over the `text` field.
 *
 * Input/textarea selections do carry `start_offset` and
 * `end_offset` (taken straight from
 * `HTMLInputElement.selectionStart` / `selectionEnd`) so a
 * round-trip `select_text` command can reproduce the exact range.
 */
export interface A11ySelection {
    /**
     * Ref of the element that carries the selection. For document
     * selections this is the closest common-ancestor element with a
     * ref; for input/textarea it is the input element itself.
     */
    ref: string;
    /**
     * The selected text. Truncated at 2000 characters with a trailing
     * ellipsis to keep `<ui_state>` injections bounded.
     */
    text: string;
    /**
     * Character offset within the input's `value` where the
     * selection starts. Only set for `<input>` and `<textarea>`.
     */
    start_offset?: number;
    /**
     * Character offset within the input's `value` where the
     * selection ends. Only set for `<input>` and `<textarea>`.
     */
    end_offset?: number;
}
/**
 * Accessibility tree carried inside a first-class `ui-snapshot` RTVI
 * message.
 *
 * `PipecatClient.startUISnapshotStream(...)` sends snapshots with the
 * message data shape `{ tree: A11ySnapshot }`. A full tree is sent on
 * each update; the server keeps the latest and renders it into
 * `<ui_state>...</ui_state>` when a worker injects it.
 */
export interface A11ySnapshot {
    /** The root of the accessibility tree (usually `document.body`'s node). */
    root: A11yNode;
    /** Client-side timestamp (ms since epoch) when the snapshot was taken. */
    captured_at: number;
    /**
     * The user's current text selection, when one exists. Omitted when
     * nothing is selected (or the selection is collapsed to a single
     * cursor position with no characters in between). The server
     * renders this as a `<selection ref="...">...</selection>` block
     * inside `<ui_state>`.
     */
    selection?: A11ySelection;
}
/**
 * Resolve a ref string like `"e42"` back to a live DOM element.
 * Returns `null` if the ref was never assigned or the element has
 * since been garbage-collected. Command handlers use this to
 * act on nodes the server referenced from a snapshot.
 */
export function findElementByRef(ref: string): Element | null;
/**
 * Inverse of `findElementByRef`: return the snapshot ref the walker
 * has assigned to `el`, if any. Returns `null` for elements the
 * walker has not yet visited (refs are assigned during snapshot
 * walking; an element only has a ref if it appeared in a previous
 * snapshot).
 *
 * Useful when an app needs to associate a user interaction (e.g.
 * the current text selection, a click on a non-tracked element) with
 * a snapshot-known node. Walk up `el.parentElement` looking for the
 * first ancestor that has a ref to find the closest snapshot-known
 * container.
 */
export function findRefForElement(el: Element): string | null;
/**
 * Capture the user's current text selection as an `A11ySelection`.
 *
 * Returns `null` when nothing is selected, the selection is
 * collapsed (a bare cursor position), or no ancestor of the
 * selection has been assigned a ref by the walker (e.g. selection
 * landed entirely inside an `aria-hidden` subtree).
 *
 * Input/textarea takes precedence over the document selection
 * because `window.getSelection().toString()` is empty for those
 * elements; we read `selectionStart` / `selectionEnd` directly
 * and surface them as offsets so a round-trip `select_text`
 * command can reproduce the range.
 */
export function serializeSelection(): A11ySelection | null;
export interface SnapshotOptions {
    /**
     * When `true` (default), each emitted node gets `"offscreen"`
     * in its state list if its bounding rect sits entirely outside the
     * viewport. Set to `false` to skip the per-node layout
     * measurement (e.g. on very large pages where layout cost
     * outweighs the viewport signal).
     */
    trackViewport?: boolean;
}
/**
 * Produce an accessibility snapshot of a DOM subtree.
 *
 * @param root - Element to walk. Defaults to `document.body`.
 * @param options - Snapshot options; see `SnapshotOptions`.
 * @returns Snapshot with a `generic` root containing the walked
 *     children, plus a client-side capture timestamp.
 */
export function snapshotDocument(root?: Element, options?: SnapshotOptions): A11ySnapshot;
/** Options for `A11ySnapshotStreamer`. */
export interface A11ySnapshotStreamerOptions {
    /**
     * Minimum interval between snapshot emissions, in milliseconds.
     * Multiple mutations within the window coalesce into one snapshot.
     *
     * @default 300
     */
    debounceMs?: number;
    /**
     * When `true` (default), annotate every emitted node with
     * `"offscreen"` in its state list if its bounding rect sits
     * entirely outside the viewport. Set to `false` to skip the
     * per-node layout measurement.
     *
     * @default true
     */
    trackViewport?: boolean;
    /**
     * When `true`, log each emitted snapshot to the browser console
     * (node count, rough token estimate, raw tree). Mirrors the
     * server's `log_snapshots` flag on `UIWorker`.
     *
     * @default false
     */
    logSnapshots?: boolean;
}
/**
 * Stream accessibility snapshots through an emit callback on DOM
 * mutations, focus changes, scroll-end, resize, and visibility
 * change. Fires an initial snapshot shortly after `start()`.
 *
 * Usage (vanilla JS / any framework)::
 *
 *     const streamer = new A11ySnapshotStreamer((snapshot) => {
 *       // Send or persist the snapshot.
 *     });
 *     streamer.start();
 *     // ...later
 *     streamer.stop();
 *
 * In React, `useUISnapshot` handles lifecycle for you.
 *
 * Idempotent: calling `start()` twice is safe; `stop()` detaches
 * all observers/listeners and cancels pending timers.
 */
export type A11ySnapshotEmitter = (snapshot: A11ySnapshot) => void;
export class A11ySnapshotStreamer {
    constructor(emitSnapshot: A11ySnapshotEmitter, options?: A11ySnapshotStreamerOptions);
    /**
     * Begin streaming. Safe to call multiple times; subsequent calls
     * are no-ops until `stop()` runs.
     */
    start(): void;
    /** Stop streaming. Safe to call before `start()` or multiple times. */
    stop(): void;
}
export type TransportState = "disconnected" | "initializing" | "initialized" | "authenticating" | "authenticated" | "connecting" | "connected" | "ready" | "disconnecting" | "error";
export enum TransportStateEnum {
    DISCONNECTED = "disconnected",
    INITIALIZING = "initializing",
    INITIALIZED = "initialized",
    AUTHENTICATING = "authenticating",
    AUTHENTICATED = "authenticated",
    CONNECTING = "connecting",
    CONNECTED = "connected",
    READY = "ready",
    DISCONNECTING = "disconnecting",
    ERROR = "error"
}
export type Participant = {
    id: string;
    name: string;
    local: boolean;
};
/**
 * Per-device lifecycle state, tracked independently for the mic and the cam.
 * Modelled after daily-react's DailyDevices. Transitions are driven by
 * explicit calls to PipecatClient.initDevices() and by DeviceError events.
 * Never by transport connect/disconnect.
 */
export type DeviceState = 
/** initDevices() has not been called yet for this device */
"uninitialized"
/** initDevices() is in flight (enumeration / permission request) */
 | "initializing"
/** Device is enumerated and ready to use */
 | "granted"
/** Device is in an error state and could not be acquired */
 | "error";
/**
 * Per-device error categories. Only meaningful when DeviceStatus.state is
 * 'error'. Mirrors the shape of DeviceErrorType but expressed in
 * MediaState's own vocabulary so consumers can render UI without going
 * through the underlying error object.
 */
export type DeviceErrorReason = 
/** User explicitly denied permission */
"blocked"
/** Hardware is busy in another application */
 | "already-in-use"
/** No matching hardware was found */
 | "not-found"
/** getUserMedia constraints couldn't be satisfied */
 | "invalid-constraints"
/** Browser API is unavailable (legacy browser, insecure context) */
 | "not-supported"
/** Catch-all for errors we couldn't classify */
 | "unknown";
/**
 * Per-device status. A discriminated union: when `state` is `'error'`, the
 * `reason` field describes the error category (and `details` may carry the
 * raw error payload). Consumers branch on `state` to decide what to render.
 */
export type DeviceStatus = {
    state: "uninitialized" | "initializing" | "granted";
} | {
    state: "error";
    reason: DeviceErrorReason;
    details?: unknown;
};
/**
 * Per-device state on PipecatClient, exposed independently of TransportState.
 * Speakers are intentionally not tracked here: output devices have no
 * permission or in-use failure mode, only enumeration.
 */
export type MediaState = {
    mic: DeviceStatus;
    cam: DeviceStatus;
};
/**
 * Copyright (c) 2024, Daily.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */
export class RTVIError extends Error {
    readonly status: number | undefined;
    constructor(message?: string, status?: number | undefined);
}
export class ConnectionTimeoutError extends RTVIError {
    constructor(message?: string | undefined);
}
export class StartBotError extends RTVIError {
    readonly error: string;
    constructor(message?: string | undefined, status?: number);
}
export class TransportStartError extends RTVIError {
    constructor(message?: string | undefined);
}
export class InvalidTransportParamsError extends RTVIError {
    constructor(message?: string | undefined);
}
export class BotNotReadyError extends RTVIError {
    constructor(message?: string | undefined);
}
export class BotAlreadyStartedError extends RTVIError {
    constructor(message?: string | undefined);
}
export class UnsupportedFeatureError extends RTVIError {
    readonly feature: string;
    constructor(feature: string, source?: string, message?: string);
}
export class MessageTooLargeError extends RTVIError {
    constructor(message?: string | undefined);
}
export type DeviceArray = Array<"cam" | "mic" | "speaker">;
export type DeviceErrorType = "in-use" | "permissions" | "undefined-mediadevices" | "not-found" | "constraints" | "unknown";
export type DeviceErrorDetails = Record<string, string | boolean | number | Error>;
export class DeviceError extends RTVIError {
    readonly devices: DeviceArray;
    readonly type: DeviceErrorType;
    readonly details: DeviceErrorDetails | undefined;
    constructor(devices: DeviceArray, type: DeviceErrorType, message?: string, details?: DeviceErrorDetails);
}
export const RTVI_PROTOCOL_VERSION = "1.4.0";
export const RTVI_MESSAGE_LABEL = "rtvi-ai";
/**
 * Messages the corresponding server-side client expects to receive about
 * our client-side state.
 */
export enum RTVIMessageType {
    /** Outbound Messages */
    CLIENT_READY = "client-ready",
    DISCONNECT_BOT = "disconnect-bot",
    CLIENT_MESSAGE = "client-message",
    SEND_TEXT = "send-text",
    UI_EVENT = "ui-event",
    UI_SNAPSHOT = "ui-snapshot",
    UI_CANCEL_JOB_GROUP = "ui-cancel-job-group",
    APPEND_TO_CONTEXT = "append-to-context",
    /**
     * Inbound Messages
     * Messages the server-side client sends to our client-side client regarding
     * its state or other non-service-specific messaging.
     */
    BOT_READY = "bot-ready",// Bot is connected and ready to receive messages
    ERROR = "error",// Bot initialization error
    METRICS = "metrics",// Bot reporting metrics
    SERVER_MESSAGE = "server-message",// Custom server-to-client message
    SERVER_RESPONSE = "server-response",// Server response to client message
    ERROR_RESPONSE = "error-response",// Error message in response to an outbound message
    APPEND_TO_CONTEXT_RESULT = "append-to-context-result",// Result of appending to context
    UI_COMMAND = "ui-command",
    UI_JOB_GROUP = "ui-job-group",
    /** Speaking and Transcription Messages */
    USER_STARTED_SPEAKING = "user-started-speaking",// User started speaking
    USER_STOPPED_SPEAKING = "user-stopped-speaking",// User stopped speaking
    BOT_STARTED_SPEAKING = "bot-started-speaking",// Bot started speaking
    BOT_STOPPED_SPEAKING = "bot-stopped-speaking",// Bot stopped speaking
    USER_MUTE_STARTED = "user-mute-started",// User muted server-side.
    USER_MUTE_STOPPED = "user-mute-stopped",// User unmuted server-side.
    USER_TRANSCRIPTION = "user-transcription",// Local user speech to text transcription (partials and finals)
    BOT_OUTPUT = "bot-output",// A best effort aggregation of all bot output along with metadata like if it's spoken
    BOT_TRANSCRIPTION = "bot-transcription",// Bot full text transcription (sentence aggregated)
    /** LLM Messages */
    USER_LLM_TEXT = "user-llm-text",// Aggregated user input text which is sent to LLM
    BOT_LLM_TEXT = "bot-llm-text",// Streamed token returned by the LLM
    BOT_LLM_STARTED = "bot-llm-started",// Bot LLM inference starts
    BOT_LLM_STOPPED = "bot-llm-stopped",// Bot LLM inference stops
    LLM_FUNCTION_CALL = "llm-function-call",// Inbound function call from LLM
    LLM_FUNCTION_CALL_STARTED = "llm-function-call-started",// Inbound function call started
    LLM_FUNCTION_CALL_IN_PROGRESS = "llm-function-call-in-progress",// Inbound function call in progress
    LLM_FUNCTION_CALL_STOPPED = "llm-function-call-stopped",// Inbound function call stopped
    LLM_FUNCTION_CALL_RESULT = "llm-function-call-result",// Outbound result of function call
    BOT_LLM_SEARCH_RESPONSE = "bot-llm-search-response",// Bot LLM search response
    /** TTS Messages */
    BOT_TTS_TEXT = "bot-tts-text",// Bot TTS text output (streamed word as it is spoken)
    BOT_TTS_STARTED = "bot-tts-started",// Bot TTS response starts
    BOT_TTS_STOPPED = "bot-tts-stopped"
}
export type BotReadyData = {
    version: string;
    about?: unknown;
};
type PlatformDetailsValue = undefined | string | number | boolean;
type NestedPlatformDetails = PlatformDetailsValue | Record<string, PlatformDetailsValue>;
export interface AboutClientData {
    library: string;
    library_version?: string;
    platform?: string;
    platform_version?: string;
    platform_details?: Record<string, NestedPlatformDetails>;
}
export type ClientReadyData = {
    version: string;
    about: AboutClientData;
};
export type ErrorData = {
    message: string;
    fatal: boolean;
};
export type PipecatMetricData = {
    processor: string;
    value: number;
};
export type PipecatMetricsData = {
    processing?: PipecatMetricData[];
    ttfb?: PipecatMetricData[];
    characters?: PipecatMetricData[];
};
export type TranscriptData = {
    text: string;
    final: boolean;
    timestamp: string;
    user_id: string;
};
export enum AggregationType {
    WORD = "word",
    SENTENCE = "sentence"
}
export type BotOutputData = {
    text: string;
    spoken: boolean;
    aggregated_by?: AggregationType | string;
};
export type BotLLMTextData = {
    text: string;
};
export type BotTTSTextData = {
    text: string;
};
export type ServerMessageData = {
    data: any;
};
export type ClientMessageData = {
    t: string;
    d?: unknown;
};
export type UIEventData = {
    event: string;
    payload?: unknown;
};
export type UISnapshotData = {
    tree: A11ySnapshot;
};
export type UICancelJobGroupData = {
    job_id: string;
    reason?: string;
};
export type UICommandData = {
    command: string;
    payload: unknown;
};
export type UIJobGroupData = UIJobGroupEnvelope;
export type LLMSearchResult = {
    text: string;
    confidence: number[];
};
export type BotLLMSearchResponseData = {
    search_result?: string;
    rendered_content?: string;
    origins: LLMSearchOrigin[];
};
export type LLMSearchOrigin = {
    site_uri?: string;
    site_title?: string;
    results: LLMSearchResult[];
};
export type LLMFunctionCallStartedData = {
    function_name?: string;
};
export type LLMFunctionCallInProgressData = {
    function_name?: string;
    tool_call_id: string;
    arguments?: Record<string, unknown>;
};
/** @deprecated Use LLMFunctionCallInProgressData instead */
export type LLMFunctionCallData = {
    function_name?: string;
    tool_call_id: string;
    args: Record<string, unknown>;
};
export type LLMFunctionCallResult = Record<string, unknown> | string;
export type LLMFunctionCallResultResponse = {
    function_name: string;
    tool_call_id: string;
    arguments: Record<string, unknown>;
    result: LLMFunctionCallResult;
};
export type LLMFunctionCallStoppedData = {
    function_name?: string;
    tool_call_id: string;
    cancelled: boolean;
    result?: unknown;
};
export type SendTextOptions = {
    run_immediately?: boolean;
    audio_response?: boolean;
};
/** DEPRECATED */
export type LLMContextMessage = {
    role: "user" | "assistant";
    content: unknown;
    run_immediately?: boolean;
};
/** DEPRECATED */
export type AppendToContextResultData = {
    result: Record<string, unknown> | string;
};
export function setAboutClient(about: AboutClientData): void;
export class RTVIMessage {
    id: string;
    label: string;
    type: string;
    data: unknown;
    constructor(type: string, data: unknown, id?: string);
    static clientReady(): RTVIMessage;
    static disconnectBot(): RTVIMessage;
    static error(message: string, fatal?: boolean): RTVIMessage;
}
export enum RTVIEvent {
    /** local connection state events */
    Connected = "connected",
    Disconnected = "disconnected",
    TransportStateChanged = "transportStateChanged",
    /** remote connection state events */
    BotStarted = "botStarted",
    BotConnected = "botConnected",
    BotReady = "botReady",
    BotDisconnected = "botDisconnected",
    Error = "error",
    /** server messaging */
    ServerMessage = "serverMessage",
    ServerResponse = "serverResponse",
    MessageError = "messageError",
    /** UI Worker Protocol */
    UICommand = "uiCommand",
    UIJobGroup = "uiJobGroup",
    /** service events */
    Metrics = "metrics",
    BotStartedSpeaking = "botStartedSpeaking",
    BotStoppedSpeaking = "botStoppedSpeaking",
    UserStartedSpeaking = "userStartedSpeaking",
    UserStoppedSpeaking = "userStoppedSpeaking",
    UserMuteStarted = "userMuteStarted",
    UserMuteStopped = "userMuteStopped",
    UserTranscript = "userTranscript",
    BotOutput = "botOutput",
    BotTranscript = "botTranscript",
    BotLlmText = "botLlmText",
    BotLlmStarted = "botLlmStarted",
    BotLlmStopped = "botLlmStopped",
    LLMFunctionCall = "llmFunctionCall",
    LLMFunctionCallStarted = "llmFunctionCallStarted",
    LLMFunctionCallInProgress = "llmFunctionCallInProgress",
    LLMFunctionCallStopped = "llmFunctionCallStopped",
    BotLlmSearchResponse = "botLlmSearchResponse",
    BotTtsText = "botTtsText",
    BotTtsStarted = "botTtsStarted",
    BotTtsStopped = "botTtsStopped",
    /** participant events */
    ParticipantConnected = "participantConnected",
    ParticipantLeft = "participantLeft",
    /** media events */
    TrackStarted = "trackStarted",
    TrackStopped = "trackStopped",
    ScreenTrackStarted = "screenTrackStarted",
    ScreenTrackStopped = "screenTrackStopped",
    ScreenShareError = "screenShareError",
    LocalAudioLevel = "localAudioLevel",
    RemoteAudioLevel = "remoteAudioLevel",
    /** media device events */
    AvailableCamsUpdated = "availableCamsUpdated",
    AvailableMicsUpdated = "availableMicsUpdated",
    AvailableSpeakersUpdated = "availableSpeakersUpdated",
    CamUpdated = "camUpdated",
    MicUpdated = "micUpdated",
    SpeakerUpdated = "speakerUpdated",
    DeviceError = "deviceError",
    MediaStateUpdated = "mediaStateUpdated",
    UnsupportedFeature = "unsupportedFeature"
}
export type RTVIEvents = Partial<{
    /** local connection state events */
    connected: () => void;
    disconnected: () => void;
    transportStateChanged: (state: TransportState) => void;
    /** remote connection state events */
    botStarted: (botResponse: unknown) => void;
    botConnected: (participant: Participant) => void;
    botReady: (botData: BotReadyData) => void;
    botDisconnected: (participant: Participant) => void;
    error: (message: RTVIMessage) => void;
    /** server messaging */
    serverMessage: (data: any) => void;
    serverResponse: (data: any) => void;
    messageError: (message: RTVIMessage) => void;
    /** UI Worker Protocol */
    uiCommand: (data: UICommandData) => void;
    uiJobGroup: (data: UIJobGroupData) => void;
    /** service events */
    metrics: (data: PipecatMetricsData) => void;
    botStartedSpeaking: () => void;
    botStoppedSpeaking: () => void;
    userStartedSpeaking: () => void;
    userStoppedSpeaking: () => void;
    userMuteStarted: () => void;
    userMuteStopped: () => void;
    userTranscript: (data: TranscriptData) => void;
    botOutput: (data: BotOutputData) => void;
    botTranscript: (data: BotLLMTextData) => void;
    botLlmText: (data: BotLLMTextData) => void;
    botLlmStarted: () => void;
    botLlmStopped: () => void;
    /** @deprecated Use LLMFunctionCallInProgress instead */
    llmFunctionCall: (func: LLMFunctionCallData) => void;
    llmFunctionCallStarted: (data: LLMFunctionCallStartedData) => void;
    llmFunctionCallInProgress: (data: LLMFunctionCallInProgressData) => void;
    llmFunctionCallStopped: (data: LLMFunctionCallStoppedData) => void;
    botLlmSearchResponse: (data: BotLLMSearchResponseData) => void;
    botTtsText: (data: BotTTSTextData) => void;
    botTtsStarted: () => void;
    botTtsStopped: () => void;
    /** participant events */
    participantConnected: (participant: Participant) => void;
    participantLeft: (participant: Participant) => void;
    /** media events */
    trackStarted: (track: MediaStreamTrack, participant?: Participant) => void;
    trackStopped: (track: MediaStreamTrack, participant?: Participant) => void;
    screenTrackStarted: (track: MediaStreamTrack, p?: Participant) => void;
    screenTrackStopped: (track: MediaStreamTrack, p?: Participant) => void;
    screenShareError: (errorMessage: string) => void;
    localAudioLevel: (level: number) => void;
    remoteAudioLevel: (level: number, p: Participant) => void;
    /** media device events */
    availableCamsUpdated: (cams: MediaDeviceInfo[]) => void;
    availableMicsUpdated: (mics: MediaDeviceInfo[]) => void;
    availableSpeakersUpdated: (speakers: MediaDeviceInfo[]) => void;
    camUpdated: (cam: MediaDeviceInfo) => void;
    micUpdated: (mic: MediaDeviceInfo) => void;
    speakerUpdated: (speaker: MediaDeviceInfo) => void;
    deviceError: (error: DeviceError) => void;
    mediaStateUpdated: (mediaState: MediaState) => void;
    unsupportedFeature: (error: UnsupportedFeatureError) => void;
}>;
export type RTVIEventHandler<E extends RTVIEvent> = E extends keyof RTVIEvents ? RTVIEvents[E] : never;
/**
 * Copyright (c) 2024, Daily.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */
export enum LogLevel {
    NONE = 0,
    ERROR = 1,
    WARN = 2,
    INFO = 3,
    DEBUG = 4
}
declare class Logger {
    private constructor();
    static getInstance(): Logger;
    setLevel(level: LogLevel): void;
    debug(...args: unknown[]): void;
    info(...args: unknown[]): void;
    warn(...args: unknown[]): void;
    error(...args: unknown[]): void;
}
export const logger: Logger;
export type ILogger = Logger;
interface QueuedRTVIMessage {
    message: RTVIMessage;
    timestamp: number;
    timeout: number;
    resolve: (value: unknown) => void;
    reject: (reason?: unknown) => void;
}
export class MessageDispatcher {
    protected _sendMethod: (message: RTVIMessage) => void;
    protected _queue: QueuedRTVIMessage[];
    protected _gcInterval: ReturnType<typeof setInterval> | undefined;
    constructor(sendMethod: (message: RTVIMessage) => void);
    disconnect(): void;
    dispatch(message_data: unknown, type?: RTVIMessageType, timeout?: number): Promise<RTVIMessage>;
    clearQueue(): void;
    resolve(message: RTVIMessage): RTVIMessage;
    reject(message: RTVIMessage): RTVIMessage;
    protected _gc(): void;
}
type Serializable = string | number | boolean | null | Serializable[] | {
    [key: number | string]: Serializable;
};
export interface APIRequest {
    endpoint: string | URL | globalThis.Request;
    headers?: Headers;
    requestData?: Serializable;
    timeout?: number;
}
/**
 * @deprecated Use APIRequest instead
 */
export type ConnectionEndpoint = APIRequest;
export function isAPIRequest(value: unknown): boolean;
export function makeRequest(cxnOpts: APIRequest, abortController?: AbortController): Promise<unknown>;
export type Tracks = {
    local: {
        audio?: MediaStreamTrack;
        video?: MediaStreamTrack;
        screenAudio?: MediaStreamTrack;
        screenVideo?: MediaStreamTrack;
    };
    bot?: {
        audio?: MediaStreamTrack;
        screenAudio?: undefined;
        screenVideo?: undefined;
        video?: MediaStreamTrack;
    };
};
export type TransportConnectionParams = unknown;
export abstract class Transport {
    protected _options: PipecatClientOptions;
    protected _onMessage: (ev: RTVIMessage) => void;
    protected _callbacks: RTVIEventCallbacks;
    protected _abortController: AbortController | undefined;
    protected _state: TransportState;
    protected _startBotParams: APIRequest | undefined;
    /**
     * Maximum allowed size in bytes for a single signaling/message payload.
     *
     * The default is 64 KiB (`64 * 1024`), which is chosen to stay well within
     * typical WebSocket, proxy, and intermediary limits and to discourage
     * transports from sending very large payloads in a single message.
     *
     * Transport implementations may override this value in subclasses or
     * constructors if their underlying transport has stricter or more relaxed
     * limits, as long as they continue to honor this field when enforcing
     * message size constraints.
     */
    protected _maxMessageSize: number;
    constructor();
    /** called from PipecatClient constructor to wire up callbacks */
    abstract initialize(options: PipecatClientOptions, messageHandler: (ev: RTVIMessage) => void): void;
    /**
     * This method is intended to initialize cam/mic devices. It is wrapped
     * by PipecatClient.initDevices and should not be called directly. It is also
     * called as part of PipecatClient.connect if it has not already called.
     */
    abstract initDevices(): Promise<void>;
    /**
     * Establishes a connection with the remote server. This is the main entry
     * point for the transport to start sending and receiving media and messages.
     * This is called from PipecatClient.connect() and should not be called directly.
     * @param connectParams - This type will ultimately be defned by the transport
     * implementation. It is used to pass connection parameters to the transport.
     */
    connect(connectParams?: TransportConnectionParams): Promise<void>;
    /**
     * Allow the transports to determine how the bot was started.
     */
    get startBotParams(): APIRequest | undefined;
    /**
     * Set the parameters used to start the bot.
     * @param startBotParams
     */
    set startBotParams(startBotParams: APIRequest);
    abstract _validateConnectionParams(connectParams?: unknown): unknown;
    abstract _connect(connectParams?: TransportConnectionParams): Promise<void>;
    /**
     * Disconnects the transport from the remote server. This is called from
     * PipecatClient.disconnect() and should not be called directly.
     */
    disconnect(): Promise<void>;
    abstract _disconnect(): Promise<void>;
    abstract sendReadyMessage(): void;
    abstract get state(): TransportState;
    abstract set state(state: TransportState);
    abstract getAllMics(): Promise<MediaDeviceInfo[]>;
    abstract getAllCams(): Promise<MediaDeviceInfo[]>;
    abstract getAllSpeakers(): Promise<MediaDeviceInfo[]>;
    abstract updateMic(micId: string): void;
    abstract updateCam(camId: string): void;
    abstract updateSpeaker(speakerId: string): void;
    abstract get selectedMic(): MediaDeviceInfo | Record<string, never>;
    abstract get selectedCam(): MediaDeviceInfo | Record<string, never>;
    abstract get selectedSpeaker(): MediaDeviceInfo | Record<string, never>;
    abstract enableMic(enable: boolean): void;
    abstract enableCam(enable: boolean): void;
    abstract enableScreenShare(enable: boolean): void;
    abstract get isCamEnabled(): boolean;
    abstract get isMicEnabled(): boolean;
    abstract get isSharingScreen(): boolean;
    abstract sendMessage(message: RTVIMessage): void;
    /**
     * Maximum size, in bytes, of a single message that this transport will attempt
     * to send. Callers should ensure that any outbound {@link RTVIMessage} payloads
     * do not exceed this limit to avoid transport or server errors.
     */
    get maxMessageSize(): number;
    abstract tracks(): Tracks;
}
export class TransportWrapper {
    constructor(transport: Transport);
    get proxy(): Transport;
}
interface JSAboutClientData extends AboutClientData {
    platform_details: {
        browser?: string;
        browser_version?: string;
        platform_type?: string;
        engine?: string;
        device_memory?: number;
        language?: string;
        connection?: {
            effectiveType?: string;
            downlink?: number;
        };
    };
}
export function learnAboutClient(): JSAboutClientData;
export function messageSizeWithinLimit(message: unknown, maxSize: number): boolean;
export type FunctionCallParams = {
    functionName: string;
    arguments: Record<string, unknown>;
};
export type FunctionCallCallback = (fn: FunctionCallParams) => Promise<LLMFunctionCallResult | void>;
export type RTVIEventCallbacks = Partial<{
    onConnected: () => void;
    onDisconnected: () => void;
    onError: (message: RTVIMessage) => void;
    onTransportStateChanged: (state: TransportState) => void;
    onBotStarted: (botResponse: unknown) => void;
    onBotConnected: (participant: Participant) => void;
    onBotReady: (botReadyData: BotReadyData) => void;
    onBotDisconnected: (participant: Participant) => void;
    onMetrics: (data: PipecatMetricsData) => void;
    onServerMessage: (data: any) => void;
    onMessageError: (message: RTVIMessage) => void;
    onUICommand: (data: UICommandData) => void;
    onUIJobGroup: (data: UIJobGroupData) => void;
    onParticipantJoined: (participant: Participant) => void;
    onParticipantLeft: (participant: Participant) => void;
    onAvailableCamsUpdated: (cams: MediaDeviceInfo[]) => void;
    onAvailableMicsUpdated: (mics: MediaDeviceInfo[]) => void;
    onAvailableSpeakersUpdated: (speakers: MediaDeviceInfo[]) => void;
    onCamUpdated: (cam: MediaDeviceInfo) => void;
    onMicUpdated: (mic: MediaDeviceInfo) => void;
    onSpeakerUpdated: (speaker: MediaDeviceInfo) => void;
    onDeviceError: (error: DeviceError) => void;
    onMediaStateChanged: (mediaState: MediaState) => void;
    onTrackStarted: (track: MediaStreamTrack, participant?: Participant) => void;
    onTrackStopped: (track: MediaStreamTrack, participant?: Participant) => void;
    onScreenTrackStarted: (track: MediaStreamTrack, participant?: Participant) => void;
    onScreenTrackStopped: (track: MediaStreamTrack, participant?: Participant) => void;
    onScreenShareError: (errorMessage: string) => void;
    onUnsupportedFeature: (error: UnsupportedFeatureError) => void;
    onLocalAudioLevel: (level: number) => void;
    onRemoteAudioLevel: (level: number, participant: Participant) => void;
    onUserStartedSpeaking: () => void;
    onUserStoppedSpeaking: () => void;
    onBotStartedSpeaking: () => void;
    onBotStoppedSpeaking: () => void;
    onUserMuteStarted: () => void;
    onUserMuteStopped: () => void;
    onUserTranscript: (data: TranscriptData) => void;
    onBotOutput: (data: BotOutputData) => void;
    /** @deprecated Use onBotOutput instead */
    onBotTranscript: (data: BotLLMTextData) => void;
    onBotLlmText: (data: BotLLMTextData) => void;
    onBotLlmStarted: () => void;
    onBotLlmStopped: () => void;
    onBotTtsText: (data: BotTTSTextData) => void;
    onBotTtsStarted: () => void;
    onBotTtsStopped: () => void;
    onLLMFunctionCallStarted: (data: LLMFunctionCallStartedData) => void;
    onLLMFunctionCallInProgress: (data: LLMFunctionCallInProgressData) => void;
    onLLMFunctionCallStopped: (data: LLMFunctionCallStoppedData) => void;
    onBotLlmSearchResponse: (data: BotLLMSearchResponseData) => void;
    /** @deprecated Use onLLMFunctionCallInProgress instead */
    onLLMFunctionCall: (data: LLMFunctionCallData) => void;
}>;
export interface PipecatClientOptions {
    /**
     * Transport class for media streaming
     */
    transport: Transport;
    /**
     * Optional callback methods for RTVI events
     */
    callbacks?: RTVIEventCallbacks;
    /**
     * Enable user mic input
     *
     * Default to true
     */
    enableMic?: boolean;
    /**
     * Enable user cam input
     *
     * Default to false
     */
    enableCam?: boolean;
    /**
     * Enable screen sharing
     *
     * Default to false
     */
    enableScreenShare?: boolean;
    /**
     * Disconnect when the bot disconnects.
     *
     * Default to true
     */
    disconnectOnBotDisconnect?: boolean;
}
declare const RTVIEventEmitter_base: new () => TypedEmitter<RTVIEvents>;
declare abstract class RTVIEventEmitter extends RTVIEventEmitter_base {
}
export class PipecatClient extends RTVIEventEmitter {
    protected _options: PipecatClientOptions;
    protected _transport: Transport;
    protected _transportWrapper: TransportWrapper;
    protected _disconnectOnBotDisconnect: boolean;
    protected _messageDispatcher: MessageDispatcher;
    protected _functionCallCallbacks: Record<string, FunctionCallCallback>;
    protected _abortController: AbortController | undefined;
    constructor(options: PipecatClientOptions);
    setLogLevel(level: LogLevel): void;
    /**
     * Initialize local media devices.
     *
     * Drives MediaState transitions: both mic and cam move to 'initializing' on
     * entry. On success, each device moves to 'granted' only if the transport
     * reports it as acquired (via onMicUpdated / onCamUpdated with a real
     * deviceId); otherwise that device falls back to 'uninitialized'. On
     * failure the in-flight DeviceError (if any) classifies the affected
     * device(s) per-device; anything still at 'initializing' falls back to
     * 'unknown'. The original error is always re-thrown.
     *
     * Calling this again after a failure is the recovery path — a second call
     * re-enters 'initializing' and reclassifies. There is no separate
     * retryDevices() method.
     */
    initDevices(): Promise<void>;
    /**
     * startBot() is a method that initiates the bot by posting to a specified endpoint
     * that optionally returns connection parameters for establishing a transport session.
     * @param startBotParams
     * @returns Promise that resolves to TransportConnectionParams or unknown
     */
    startBot(startBotParams: APIRequest): Promise<unknown>;
    /**
     * The `connect` function establishes a transport session and awaits a
     * bot-ready signal, handling various connection states and errors.
     * @param {TransportConnectionParams} [connectParams] -
     * The `connectParams` parameter in the `connect` method should be of type
     * `TransportConnectionParams`. This parameter is passed to the transport
     * for establishing a transport session.
     * NOTE: `connectParams` as type `ConnectionEndpoint` IS NOW DEPRECATED. If you
     * want to authenticate and connect to a bot in one step, use
     * `startBotAndConnect()` instead.
     * @returns The `connect` method returns a Promise that resolves to an unknown value.
     */
    connect(connectParams?: TransportConnectionParams | ConnectionEndpoint): Promise<BotReadyData>;
    startBotAndConnect(startBotParams: APIRequest): Promise<BotReadyData>;
    /**
     * Disconnect the voice client from the transport
     * Reset / reinitialize transport and abort any pending requests
     */
    disconnect(): Promise<void>;
    /**
     * Get the current state of the transport
     */
    get connected(): boolean;
    get transport(): Transport;
    get state(): TransportState;
    /**
     * Per-device device state (mic, cam). Independent of transport state.
     *
     * Updated by initDevices() and DeviceError events. Returns a snapshot — to
     * track changes, subscribe to RTVIEvent.MediaStateUpdated or pass an
     * onMediaStateChanged callback in the client constructor.
     */
    get mediaState(): MediaState;
    /**
     * Whether initDevices() still has work to do. Returns true if any device
     * the caller opted into (enableMic / enableCam) is still 'uninitialized'.
     * Devices the caller opted out of are not considered — they stay
     * 'uninitialized' by design and must not gate the implicit init.
     *
     * Used internally by connect() / startBot() to decide whether to drive an
     * implicit initDevices(); exposed publicly so consumers (e.g. step 3's
     * useMediaState hook) can branch on the same logic.
     */
    needsInit(): boolean;
    get version(): string;
    getAllMics(): Promise<MediaDeviceInfo[]>;
    getAllCams(): Promise<MediaDeviceInfo[]>;
    getAllSpeakers(): Promise<MediaDeviceInfo[]>;
    get selectedMic(): MediaDeviceInfo | Record<string, never>;
    get selectedCam(): MediaDeviceInfo | Record<string, never>;
    get selectedSpeaker(): MediaDeviceInfo | Record<string, never>;
    updateMic(micId: string): void;
    updateCam(camId: string): void;
    updateSpeaker(speakerId: string): void;
    enableMic(enable: boolean): void;
    get isMicEnabled(): boolean;
    enableCam(enable: boolean): void;
    get isCamEnabled(): boolean;
    tracks(): Tracks;
    enableScreenShare(enable: boolean): void;
    get isSharingScreen(): boolean;
    /**
     * Directly send a message to the bot via the transport.
     * Do not await a response.
     * @param msgType - a string representing the message type
     * @param data - a dictionary of data to send with the message
     */
    sendClientMessage(msgType: string, data?: unknown): void;
    /**
     * Send a named UI event to the server as a first-class RTVI
     * `ui-event` message.
     *
     * @param event - App-defined event.
     * @param payload - App-defined payload. Optional.
     */
    sendUIEvent(event: string, payload?: unknown): void;
    /**
     * Start streaming UI snapshots to the server as
     * first-class `ui-snapshot` RTVI messages.
     *
     * Calling this again replaces any existing managed streamer with
     * the new options.
     */
    startUISnapshotStream(options?: A11ySnapshotStreamerOptions): void;
    /**
     * Stop the managed UI snapshot stream, if one is active.
     */
    stopUISnapshotStream(): void;
    /**
     * Ask the server to cancel an in-flight UI job group.
     *
     * @param jobId - Shared job identifier of the group to cancel.
     * @param reason - Optional human-readable reason logged on the server.
     */
    cancelUIJobGroup(jobId: string, reason?: string): void;
    /**
     * Directly send a message to the bot via the transport.
     * Wait for and return the response.
     * @param msgType - a string representing the message type
     * @param data - a dictionary of data to send with the message
     * @param timeout - optional timeout in milliseconds for the response
     */
    sendClientRequest(msgType: string, data: unknown, timeout?: number): Promise<unknown>;
    registerFunctionCallHandler(functionName: string, callback: FunctionCallCallback): void;
    unregisterFunctionCallHandler(functionName: string): void;
    unregisterAllFunctionCallHandlers(): void;
    appendToContext(context: LLMContextMessage): Promise<boolean>;
    sendText(content: string, options?: SendTextOptions): Promise<void>;
    /**
     * Disconnects the bot, but keeps the session alive
     */
    disconnectBot(): void;
    protected handleMessage(ev: RTVIMessage): void;
}

//# sourceMappingURL=index.d.ts.map