@pipedog/openai 0.0.0 → 0.3.0

package/dist/realtime/events.d.ts

@@ -0,0 +1,1401 @@
+import type { DirectFunction } from "@pipedog/core/adapters/schemas/direct_function";
+import type { FunctionSchema } from "@pipedog/core/adapters/schemas/function_schema";
+import { ToolsSchema } from "@pipedog/core/adapters/schemas/tools_schema";
+/** A modality the model can respond with. */
+export type Modality = "text" | "audio";
+/** How much detail the model should read out of an image. */
+export type ImageDetail = "auto" | "low" | "high";
+/** Raised when data does not match a model, like pydantic's `ValidationError`. */
+export declare class ValidationError extends Error {
+    name: string;
+}
+/** Options for `BaseModel.modelDump()`. */
+export interface ModelDumpOptions {
+    /** Leave out fields whose value is `null` (pydantic's `exclude_none`). */
+    excludeNone?: boolean;
+}
+/** Builds a nested field's value from wire data. */
+type Resolver = (value: unknown) => unknown;
+/**
+ * Base of the models in this module (pydantic's `BaseModel`).
+ *
+ * Fields are the instance's own properties, in declaration order (base class
+ * fields first, as pydantic orders them).
+ */
+export declare class BaseModel {
+    /** Fields holding nested models, by field name: how to build each from wire data. */
+    static _nested: Record<string, Resolver>;
+    /** Whether keys that match no field are kept (pydantic's `extra="allow"`). */
+    static _extraAllowed: boolean;
+    /** Extra fields kept from wire data (pydantic's `model_extra`), by wire key. */
+    get modelExtra(): Record<string, unknown> | null;
+    /**
+     * Validate wire data (snake_case keys) into a model (pydantic's
+     * `model_validate`). An instance of the model is returned as is.
+     */
+    static modelValidate<T extends BaseModel>(this: new (options: any) => T, data: unknown): T;
+    /**
+     * Serialize the model to a plain object with the wire (snake_case) keys
+     * (pydantic's `model_dump`).
+     */
+    modelDump(options?: ModelDumpOptions): Record<string, any>;
+    /** JSON form: the wire dump. */
+    toJSON(): Record<string, any>;
+    /**
+     * Shallow copy of the model, with `update` (camelCase field names) applied
+     * (pydantic's `model_copy`).
+     */
+    modelCopy(options?: {
+        update?: Record<string, unknown>;
+    }): this;
+}
+export interface AudioFormatOptions {
+    type?: string;
+}
+/** Base class for audio format configuration. */
+export declare class AudioFormat extends BaseModel {
+    type: string;
+    constructor(options: AudioFormatOptions);
+}
+export interface PCMAudioFormatOptions {
+    type?: "audio/pcm";
+    rate?: number;
+}
+/**
+ * PCM audio format configuration.
+ *
+ * - `type`: audio format type, always "audio/pcm".
+ * - `rate`: sample rate, always 24000 for PCM.
+ */
+export declare class PCMAudioFormat extends AudioFormat {
+    type: "audio/pcm";
+    rate: number;
+    constructor(options?: PCMAudioFormatOptions);
+}
+export interface PCMUAudioFormatOptions {
+    type?: "audio/pcmu";
+}
+/**
+ * PCMU (G.711 μ-law) audio format configuration.
+ *
+ * - `type`: audio format type, always "audio/pcmu".
+ */
+export declare class PCMUAudioFormat extends AudioFormat {
+    type: "audio/pcmu";
+    constructor(options?: PCMUAudioFormatOptions);
+}
+export interface PCMAAudioFormatOptions {
+    type?: "audio/pcma";
+}
+/**
+ * PCMA (G.711 A-law) audio format configuration.
+ *
+ * - `type`: audio format type, always "audio/pcma".
+ */
+export declare class PCMAAudioFormat extends AudioFormat {
+    type: "audio/pcma";
+    constructor(options?: PCMAAudioFormatOptions);
+}
+export interface InputAudioTranscriptionOptions {
+    /**
+     * Transcription model to use (e.g. "gpt-realtime-whisper",
+     * "gpt-4o-transcribe", "whisper-1").
+     */
+    model?: string | null;
+    /** Optional language code for transcription. */
+    language?: string | null;
+    /** Optional transcription hint text. */
+    prompt?: string | null;
+}
+/** Configuration for audio transcription settings. */
+export declare class InputAudioTranscription extends BaseModel {
+    model: string;
+    language: string | null;
+    prompt: string | null;
+    /**
+     * Initialize InputAudioTranscription.
+     *
+     * @param options.model Transcription model to use (e.g.
+     *   "gpt-realtime-whisper", "gpt-4o-transcribe", "whisper-1").
+     * @param options.language Optional language code for transcription.
+     * @param options.prompt Optional transcription hint text.
+     */
+    constructor(options?: InputAudioTranscriptionOptions);
+}
+export interface TurnDetectionOptions {
+    type?: "server_vad" | null;
+    threshold?: number | null;
+    prefixPaddingMs?: number | null;
+    silenceDurationMs?: number | null;
+}
+/**
+ * Server-side voice activity detection configuration.
+ *
+ * - `type`: detection type, must be "server_vad".
+ * - `threshold`: voice activity detection threshold (0.0-1.0). Defaults to 0.5.
+ * - `prefixPaddingMs`: padding before speech starts in milliseconds. Defaults to 300.
+ * - `silenceDurationMs`: silence duration to detect speech end in milliseconds.
+ *   Defaults to 500.
+ */
+export declare class TurnDetection extends BaseModel {
+    type: "server_vad" | null;
+    threshold: number | null;
+    prefixPaddingMs: number | null;
+    silenceDurationMs: number | null;
+    constructor(options?: TurnDetectionOptions);
+}
+export interface SemanticTurnDetectionOptions {
+    type?: "semantic_vad" | null;
+    eagerness?: "low" | "medium" | "high" | "auto" | null;
+    createResponse?: boolean | null;
+    interruptResponse?: boolean | null;
+}
+/**
+ * Semantic-based turn detection configuration.
+ *
+ * - `type`: detection type, must be "semantic_vad".
+ * - `eagerness`: turn detection eagerness level. Can be "low", "medium",
+ *   "high", or "auto".
+ * - `createResponse`: whether to automatically create responses on turn detection.
+ * - `interruptResponse`: whether to interrupt ongoing responses on turn detection.
+ */
+export declare class SemanticTurnDetection extends BaseModel {
+    type: "semantic_vad" | null;
+    eagerness: "low" | "medium" | "high" | "auto" | null;
+    createResponse: boolean | null;
+    interruptResponse: boolean | null;
+    constructor(options?: SemanticTurnDetectionOptions);
+}
+export interface InputAudioNoiseReductionOptions {
+    type: "near_field" | "far_field" | null;
+}
+/**
+ * Input audio noise reduction configuration.
+ *
+ * - `type`: noise reduction type for different microphone scenarios.
+ */
+export declare class InputAudioNoiseReduction extends BaseModel {
+    type: "near_field" | "far_field" | null;
+    constructor(options: InputAudioNoiseReductionOptions);
+}
+export interface AudioInputOptions {
+    format?: PCMAudioFormat | PCMUAudioFormat | PCMAAudioFormat | null;
+    transcription?: InputAudioTranscription | null;
+    noiseReduction?: InputAudioNoiseReduction | null;
+    turnDetection?: TurnDetection | SemanticTurnDetection | boolean | null;
+}
+/**
+ * Audio input configuration.
+ *
+ * - `format`: the format of the input audio.
+ * - `transcription`: configuration for input audio transcription.
+ * - `noiseReduction`: configuration for input audio noise reduction.
+ * - `turnDetection`: configuration for turn detection, or false to disable.
+ */
+export declare class AudioInput extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    format: PCMAudioFormat | PCMUAudioFormat | PCMAAudioFormat | null;
+    transcription: InputAudioTranscription | null;
+    noiseReduction: InputAudioNoiseReduction | null;
+    turnDetection: TurnDetection | SemanticTurnDetection | boolean | null;
+    constructor(options?: AudioInputOptions);
+}
+export interface AudioOutputOptions {
+    format?: PCMAudioFormat | PCMUAudioFormat | PCMAAudioFormat | null;
+    voice?: string | null;
+    speed?: number | null;
+}
+/**
+ * Audio output configuration.
+ *
+ * - `format`: the format of the output audio.
+ * - `voice`: the voice the model uses to respond.
+ * - `speed`: the speed of the model's spoken response.
+ */
+export declare class AudioOutput extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    format: PCMAudioFormat | PCMUAudioFormat | PCMAAudioFormat | null;
+    voice: string | null;
+    speed: number | null;
+    constructor(options?: AudioOutputOptions);
+}
+export interface AudioConfigurationOptions {
+    input?: AudioInput | null;
+    output?: AudioOutput | null;
+}
+/**
+ * Audio configuration for input and output.
+ *
+ * - `input`: configuration for input audio.
+ * - `output`: configuration for output audio.
+ */
+export declare class AudioConfiguration extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    input: AudioInput | null;
+    output: AudioOutput | null;
+    constructor(options?: AudioConfigurationOptions);
+}
+/** A reasoning effort level; any string is accepted for forward compatibility. */
+export type ReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | (string & {});
+export interface ReasoningOptions {
+    effort?: ReasoningEffort | null;
+}
+/**
+ * Reasoning configuration for reasoning-capable Realtime models (e.g. `gpt-realtime-2`).
+ *
+ * - `effort`: how much reasoning effort the model should apply. `null` (the
+ *   default) leaves the field unset and lets the server pick.
+ */
+export declare class Reasoning extends BaseModel {
+    effort: ReasoningEffort | null;
+    constructor(options?: ReasoningOptions);
+}
+/** The tools a session can carry. */
+export type SessionTools = ToolsSchema | (FunctionSchema | DirectFunction)[] | Record<string, unknown>[];
+export interface SessionPropertiesOptions {
+    type?: "realtime" | null;
+    object?: "realtime.session" | null;
+    id?: string | null;
+    model?: string | null;
+    outputModalities?: Modality[] | null;
+    instructions?: string | null;
+    audio?: AudioConfiguration | null;
+    tools?: SessionTools | null;
+    toolChoice?: "auto" | "none" | "required" | null;
+    maxOutputTokens?: number | "inf" | null;
+    tracing?: "auto" | Record<string, unknown> | null;
+    prompt?: Record<string, unknown> | null;
+    expiresAt?: number | null;
+    include?: string[] | null;
+    reasoning?: Reasoning | null;
+}
+/**
+ * Configuration properties for an OpenAI Realtime session.
+ *
+ * - `type`: the type of session, always "realtime".
+ * - `object`: object type identifier, always "realtime.session".
+ * - `id`: unique identifier for the session.
+ * - `model`: the Realtime model used for this session. Note: the model is set
+ *   at connection time via the service settings and cannot be changed during
+ *   the session.
+ * - `outputModalities`: the set of modalities the model can respond with.
+ * - `instructions`: system instructions for the assistant.
+ * - `audio`: configuration for input and output audio.
+ * - `tools`: available function tools for the assistant.
+ * - `toolChoice`: tool usage strategy ("auto", "none", or "required").
+ * - `maxOutputTokens`: maximum tokens in response or "inf" for unlimited.
+ * - `tracing`: configuration options for tracing.
+ * - `prompt`: reference to a prompt template and its variables.
+ * - `expiresAt`: session expiration timestamp.
+ * - `include`: additional fields to include in server outputs.
+ * - `reasoning`: reasoning configuration. Only supported by reasoning-capable
+ *   Realtime models such as `gpt-realtime-2`.
+ */
+export declare class SessionProperties extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    /** The model's fields (pydantic's `model_fields`): camelCase field name to wire key. */
+    static readonly modelFields: Readonly<Record<string, string>>;
+    type: "realtime" | null;
+    object: "realtime.session" | null;
+    id: string | null;
+    model: string | null;
+    outputModalities: Modality[] | null;
+    instructions: string | null;
+    audio: AudioConfiguration | null;
+    tools: SessionTools | null;
+    toolChoice: "auto" | "none" | "required" | null;
+    maxOutputTokens: number | "inf" | null;
+    tracing: "auto" | Record<string, unknown> | null;
+    prompt: Record<string, unknown> | null;
+    expiresAt: number | null;
+    include: string[] | null;
+    reasoning: Reasoning | null;
+    constructor(options?: SessionPropertiesOptions);
+    /**
+     * Wrap a plain list of standard tools in a `ToolsSchema`.
+     *
+     * Provider-native tool lists (dicts) pass through unchanged.
+     */
+    static _normalizeTools(v: SessionTools | null): SessionTools | null;
+}
+export type ItemContentType = "text" | "audio" | "input_text" | "input_audio" | "input_image" | "output_text" | "output_audio";
+export interface ItemContentOptions {
+    type: ItemContentType;
+    text?: string | null;
+    audio?: string | null;
+    transcript?: string | null;
+    imageUrl?: string | null;
+    detail?: ImageDetail | null;
+}
+/**
+ * Content within a conversation item.
+ *
+ * - `type`: content type (text, audio, input_text, input_audio, input_image,
+ *   output_text, or output_audio).
+ * - `text`: text content for text-based items.
+ * - `audio`: base64-encoded audio data for audio items.
+ * - `transcript`: transcribed text for audio items.
+ * - `imageUrl`: base64-encoded image data as a data URI for input_image items.
+ * - `detail`: detail level for image processing ("auto", "low", or "high").
+ */
+export declare class ItemContent extends BaseModel {
+    type: ItemContentType;
+    text: string | null;
+    audio: string | null;
+    transcript: string | null;
+    imageUrl: string | null;
+    detail: ImageDetail | null;
+    constructor(options: ItemContentOptions);
+}
+export interface ConversationItemOptions {
+    id?: string;
+    object?: "realtime.item" | null;
+    type: "message" | "function_call" | "function_call_output";
+    status?: "completed" | "in_progress" | "incomplete" | null;
+    role?: "user" | "assistant" | "system" | null;
+    content?: ItemContent[] | null;
+    callId?: string | null;
+    name?: string | null;
+    arguments?: string | null;
+    output?: string | null;
+}
+/**
+ * A conversation item in the realtime session.
+ *
+ * - `id`: unique identifier for the item, auto-generated if not provided.
+ * - `object`: object type identifier for the realtime API.
+ * - `type`: item type (message, function_call, or function_call_output).
+ * - `status`: current status of the item.
+ * - `role`: speaker role for message items (user, assistant, or system).
+ * - `content`: content list for message items.
+ * - `callId`: function call identifier for function_call items.
+ * - `name`: function name for function_call items.
+ * - `arguments`: function arguments as JSON string for function_call items.
+ * - `output`: function output as JSON string for function_call_output items.
+ */
+export declare class ConversationItem extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    id: string;
+    object: "realtime.item" | null;
+    type: "message" | "function_call" | "function_call_output";
+    status: "completed" | "in_progress" | "incomplete" | null;
+    role: "user" | "assistant" | "system" | null;
+    content: ItemContent[] | null;
+    callId: string | null;
+    name: string | null;
+    arguments: string | null;
+    output: string | null;
+    constructor(options: ConversationItemOptions);
+}
+export interface RealtimeConversationOptions {
+    id: string;
+    object: "realtime.conversation";
+}
+/**
+ * A realtime conversation session.
+ *
+ * - `id`: unique identifier for the conversation.
+ * - `object`: object type identifier, always "realtime.conversation".
+ */
+export declare class RealtimeConversation extends BaseModel {
+    id: string;
+    object: "realtime.conversation";
+    constructor(options: RealtimeConversationOptions);
+}
+export interface ResponsePropertiesOptions {
+    outputModalities?: Modality[] | null;
+    instructions?: string | null;
+    audio?: AudioConfiguration | null;
+    tools?: Record<string, unknown>[] | null;
+    toolChoice?: "auto" | "none" | "required" | null;
+    temperature?: number | null;
+    maxOutputTokens?: number | "inf" | null;
+}
+/**
+ * Properties for configuring assistant responses.
+ *
+ * - `outputModalities`: output modalities for the response. Must be either
+ *   ["text"] or ["audio"]. Defaults to ["audio"].
+ * - `instructions`: specific instructions for this response.
+ * - `audio`: audio configuration for this response.
+ * - `tools`: available tools for this response.
+ * - `toolChoice`: tool usage strategy for this response.
+ * - `temperature`: sampling temperature for this response.
+ * - `maxOutputTokens`: maximum tokens for this response.
+ */
+export declare class ResponseProperties extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    outputModalities: Modality[] | null;
+    instructions: string | null;
+    audio: AudioConfiguration | null;
+    tools: Record<string, unknown>[] | null;
+    toolChoice: "auto" | "none" | "required" | null;
+    temperature: number | null;
+    maxOutputTokens: number | "inf" | null;
+    constructor(options?: ResponsePropertiesOptions);
+}
+export interface RealtimeErrorOptions {
+    type: string;
+    code?: string | null;
+    message: string;
+    param?: string | null;
+    eventId?: string | null;
+}
+/**
+ * Error information from the realtime API.
+ *
+ * - `type`: error type identifier.
+ * - `code`: specific error code.
+ * - `message`: human-readable error message.
+ * - `param`: parameter name that caused the error, if applicable.
+ * - `eventId`: event ID associated with the error, if applicable.
+ */
+export declare class RealtimeError extends BaseModel {
+    type: string;
+    code: string | null;
+    message: string;
+    param: string | null;
+    eventId: string | null;
+    constructor(options: RealtimeErrorOptions);
+}
+export interface ClientEventOptions {
+    eventId?: string;
+}
+/**
+ * Base class for client events sent to the realtime API.
+ *
+ * - `eventId`: unique identifier for the event, auto-generated if not provided.
+ */
+export declare class ClientEvent extends BaseModel {
+    eventId: string;
+    constructor(options?: ClientEventOptions);
+}
+export interface SessionUpdateEventOptions extends ClientEventOptions {
+    type?: "session.update";
+    session: SessionProperties;
+}
+/**
+ * Event to update session properties.
+ *
+ * - `type`: event type, always "session.update".
+ * - `session`: updated session properties.
+ */
+export declare class SessionUpdateEvent extends ClientEvent {
+    static _nested: Record<string, Resolver>;
+    type: "session.update";
+    session: SessionProperties;
+    constructor(options: SessionUpdateEventOptions);
+    /**
+     * Serialize the event to a plain object.
+     *
+     * Handles special serialization for turn_detection where false becomes null.
+     *
+     * @param options Options passed to the parent `modelDump`.
+     * @returns Object representation of the event.
+     */
+    modelDump(options?: ModelDumpOptions): Record<string, any>;
+}
+export interface InputAudioBufferAppendEventOptions extends ClientEventOptions {
+    type?: "input_audio_buffer.append";
+    audio: string;
+}
+/**
+ * Event to append audio data to the input buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.append".
+ * - `audio`: base64-encoded audio data to append.
+ */
+export declare class InputAudioBufferAppendEvent extends ClientEvent {
+    type: "input_audio_buffer.append";
+    audio: string;
+    constructor(options: InputAudioBufferAppendEventOptions);
+}
+export interface InputAudioBufferCommitEventOptions extends ClientEventOptions {
+    type?: "input_audio_buffer.commit";
+}
+/**
+ * Event to commit the current input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.commit".
+ */
+export declare class InputAudioBufferCommitEvent extends ClientEvent {
+    type: "input_audio_buffer.commit";
+    constructor(options?: InputAudioBufferCommitEventOptions);
+}
+export interface InputAudioBufferClearEventOptions extends ClientEventOptions {
+    type?: "input_audio_buffer.clear";
+}
+/**
+ * Event to clear the input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.clear".
+ */
+export declare class InputAudioBufferClearEvent extends ClientEvent {
+    type: "input_audio_buffer.clear";
+    constructor(options?: InputAudioBufferClearEventOptions);
+}
+export interface ConversationItemCreateEventOptions extends ClientEventOptions {
+    type?: "conversation.item.create";
+    previousItemId?: string | null;
+    item: ConversationItem;
+}
+/**
+ * Event to create a new conversation item.
+ *
+ * - `type`: event type, always "conversation.item.create".
+ * - `previousItemId`: ID of the item to insert after, if any.
+ * - `item`: the conversation item to create.
+ */
+export declare class ConversationItemCreateEvent extends ClientEvent {
+    static _nested: Record<string, Resolver>;
+    type: "conversation.item.create";
+    previousItemId: string | null;
+    item: ConversationItem;
+    constructor(options: ConversationItemCreateEventOptions);
+}
+export interface ConversationItemTruncateEventOptions extends ClientEventOptions {
+    type?: "conversation.item.truncate";
+    itemId: string;
+    contentIndex: number;
+    audioEndMs: number;
+}
+/**
+ * Event to truncate a conversation item's audio content.
+ *
+ * - `type`: event type, always "conversation.item.truncate".
+ * - `itemId`: ID of the item to truncate.
+ * - `contentIndex`: index of the content to truncate within the item.
+ * - `audioEndMs`: end time in milliseconds for the truncated audio.
+ */
+export declare class ConversationItemTruncateEvent extends ClientEvent {
+    type: "conversation.item.truncate";
+    itemId: string;
+    contentIndex: number;
+    audioEndMs: number;
+    constructor(options: ConversationItemTruncateEventOptions);
+}
+export interface ConversationItemDeleteEventOptions extends ClientEventOptions {
+    type?: "conversation.item.delete";
+    itemId: string;
+}
+/**
+ * Event to delete a conversation item.
+ *
+ * - `type`: event type, always "conversation.item.delete".
+ * - `itemId`: ID of the item to delete.
+ */
+export declare class ConversationItemDeleteEvent extends ClientEvent {
+    type: "conversation.item.delete";
+    itemId: string;
+    constructor(options: ConversationItemDeleteEventOptions);
+}
+export interface ConversationItemRetrieveEventOptions extends ClientEventOptions {
+    type?: "conversation.item.retrieve";
+    itemId: string;
+}
+/**
+ * Event to retrieve a conversation item by ID.
+ *
+ * - `type`: event type, always "conversation.item.retrieve".
+ * - `itemId`: ID of the item to retrieve.
+ */
+export declare class ConversationItemRetrieveEvent extends ClientEvent {
+    type: "conversation.item.retrieve";
+    itemId: string;
+    constructor(options: ConversationItemRetrieveEventOptions);
+}
+export interface ResponseCreateEventOptions extends ClientEventOptions {
+    type?: "response.create";
+    response?: ResponseProperties | null;
+}
+/**
+ * Event to create a new assistant response.
+ *
+ * - `type`: event type, always "response.create".
+ * - `response`: optional response configuration properties.
+ */
+export declare class ResponseCreateEvent extends ClientEvent {
+    static _nested: Record<string, Resolver>;
+    type: "response.create";
+    response: ResponseProperties | null;
+    constructor(options?: ResponseCreateEventOptions);
+}
+export interface ResponseCancelEventOptions extends ClientEventOptions {
+    type?: "response.cancel";
+}
+/**
+ * Event to cancel the current assistant response.
+ *
+ * - `type`: event type, always "response.cancel".
+ */
+export declare class ResponseCancelEvent extends ClientEvent {
+    type: "response.cancel";
+    constructor(options?: ResponseCancelEventOptions);
+}
+export interface ServerEventOptions {
+    eventId: string;
+    type: string;
+}
+/**
+ * Base class for server events received from the realtime API.
+ *
+ * - `eventId`: unique identifier for the event.
+ * - `type`: type of the server event.
+ */
+export declare class ServerEvent extends BaseModel {
+    eventId: string;
+    type: string;
+    constructor(options: ServerEventOptions);
+}
+export interface SessionCreatedEventOptions extends ServerEventOptions {
+    type: "session.created";
+    session: SessionProperties;
+}
+/**
+ * Event indicating a session has been created.
+ *
+ * - `type`: event type, always "session.created".
+ * - `session`: the created session properties.
+ */
+export declare class SessionCreatedEvent extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "session.created";
+    session: SessionProperties;
+    constructor(options: SessionCreatedEventOptions);
+}
+export interface SessionUpdatedEventOptions extends ServerEventOptions {
+    type: "session.updated";
+    session: SessionProperties;
+}
+/**
+ * Event indicating a session has been updated.
+ *
+ * - `type`: event type, always "session.updated".
+ * - `session`: the updated session properties.
+ */
+export declare class SessionUpdatedEvent extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "session.updated";
+    session: SessionProperties;
+    constructor(options: SessionUpdatedEventOptions);
+}
+export interface ConversationCreatedOptions extends ServerEventOptions {
+    type: "conversation.created";
+    conversation: RealtimeConversation;
+}
+/**
+ * Event indicating a conversation has been created.
+ *
+ * - `type`: event type, always "conversation.created".
+ * - `conversation`: the created conversation.
+ */
+export declare class ConversationCreated extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "conversation.created";
+    conversation: RealtimeConversation;
+    constructor(options: ConversationCreatedOptions);
+}
+export interface ConversationItemAddedOptions extends ServerEventOptions {
+    type: "conversation.item.added";
+    previousItemId?: string | null;
+    item: ConversationItem;
+}
+/**
+ * Event indicating a conversation item has been added.
+ *
+ * - `type`: event type, always "conversation.item.added".
+ * - `previousItemId`: ID of the previous item, if any.
+ * - `item`: the added conversation item.
+ */
+export declare class ConversationItemAdded extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "conversation.item.added";
+    previousItemId: string | null;
+    item: ConversationItem;
+    constructor(options: ConversationItemAddedOptions);
+}
+export interface ConversationItemDoneOptions extends ServerEventOptions {
+    type: "conversation.item.done";
+    previousItemId?: string | null;
+    item: ConversationItem;
+}
+/**
+ * Event indicating a conversation item is done processing.
+ *
+ * - `type`: event type, always "conversation.item.done".
+ * - `previousItemId`: ID of the previous item, if any.
+ * - `item`: the completed conversation item.
+ */
+export declare class ConversationItemDone extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "conversation.item.done";
+    previousItemId: string | null;
+    item: ConversationItem;
+    constructor(options: ConversationItemDoneOptions);
+}
+export interface ConversationItemInputAudioTranscriptionDeltaOptions extends ServerEventOptions {
+    type: "conversation.item.input_audio_transcription.delta";
+    itemId: string;
+    contentIndex: number;
+    delta: string;
+}
+/**
+ * Event containing incremental input audio transcription.
+ *
+ * - `type`: event type, always "conversation.item.input_audio_transcription.delta".
+ * - `itemId`: ID of the conversation item being transcribed.
+ * - `contentIndex`: index of the content within the item.
+ * - `delta`: incremental transcription text.
+ */
+export declare class ConversationItemInputAudioTranscriptionDelta extends ServerEvent {
+    type: "conversation.item.input_audio_transcription.delta";
+    itemId: string;
+    contentIndex: number;
+    delta: string;
+    constructor(options: ConversationItemInputAudioTranscriptionDeltaOptions);
+}
+export interface ConversationItemInputAudioTranscriptionCompletedOptions extends ServerEventOptions {
+    type: "conversation.item.input_audio_transcription.completed";
+    itemId: string;
+    contentIndex: number;
+    transcript: string;
+}
+/**
+ * Event indicating input audio transcription is complete.
+ *
+ * - `type`: event type, always "conversation.item.input_audio_transcription.completed".
+ * - `itemId`: ID of the conversation item that was transcribed.
+ * - `contentIndex`: index of the content within the item.
+ * - `transcript`: complete transcription text.
+ */
+export declare class ConversationItemInputAudioTranscriptionCompleted extends ServerEvent {
+    type: "conversation.item.input_audio_transcription.completed";
+    itemId: string;
+    contentIndex: number;
+    transcript: string;
+    constructor(options: ConversationItemInputAudioTranscriptionCompletedOptions);
+}
+export interface ConversationItemInputAudioTranscriptionFailedOptions extends ServerEventOptions {
+    type: "conversation.item.input_audio_transcription.failed";
+    itemId: string;
+    contentIndex: number;
+    error: RealtimeError;
+}
+/**
+ * Event indicating input audio transcription failed.
+ *
+ * - `type`: event type, always "conversation.item.input_audio_transcription.failed".
+ * - `itemId`: ID of the conversation item that failed transcription.
+ * - `contentIndex`: index of the content within the item.
+ * - `error`: error details for the transcription failure.
+ */
+export declare class ConversationItemInputAudioTranscriptionFailed extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "conversation.item.input_audio_transcription.failed";
+    itemId: string;
+    contentIndex: number;
+    error: RealtimeError;
+    constructor(options: ConversationItemInputAudioTranscriptionFailedOptions);
+}
+export interface ConversationItemTruncatedOptions extends ServerEventOptions {
+    type: "conversation.item.truncated";
+    itemId: string;
+    contentIndex: number;
+    audioEndMs: number;
+}
+/**
+ * Event indicating a conversation item has been truncated.
+ *
+ * - `type`: event type, always "conversation.item.truncated".
+ * - `itemId`: ID of the truncated conversation item.
+ * - `contentIndex`: index of the content within the item.
+ * - `audioEndMs`: end time in milliseconds for the truncated audio.
+ */
+export declare class ConversationItemTruncated extends ServerEvent {
+    type: "conversation.item.truncated";
+    itemId: string;
+    contentIndex: number;
+    audioEndMs: number;
+    constructor(options: ConversationItemTruncatedOptions);
+}
+export interface ConversationItemDeletedOptions extends ServerEventOptions {
+    type: "conversation.item.deleted";
+    itemId: string;
+}
+/**
+ * Event indicating a conversation item has been deleted.
+ *
+ * - `type`: event type, always "conversation.item.deleted".
+ * - `itemId`: ID of the deleted conversation item.
+ */
+export declare class ConversationItemDeleted extends ServerEvent {
+    type: "conversation.item.deleted";
+    itemId: string;
+    constructor(options: ConversationItemDeletedOptions);
+}
+export interface ConversationItemRetrievedOptions extends ServerEventOptions {
+    type: "conversation.item.retrieved";
+    item: ConversationItem;
+}
+/**
+ * Event containing a retrieved conversation item.
+ *
+ * - `type`: event type, always "conversation.item.retrieved".
+ * - `item`: the retrieved conversation item.
+ */
+export declare class ConversationItemRetrieved extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "conversation.item.retrieved";
+    item: ConversationItem;
+    constructor(options: ConversationItemRetrievedOptions);
+}
+export interface ResponseCreatedOptions extends ServerEventOptions {
+    type: "response.created";
+    response: Response;
+}
+/**
+ * Event indicating an assistant response has been created.
+ *
+ * - `type`: event type, always "response.created".
+ * - `response`: the created response object.
+ */
+export declare class ResponseCreated extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "response.created";
+    response: Response;
+    constructor(options: ResponseCreatedOptions);
+}
+export interface ResponseDoneOptions extends ServerEventOptions {
+    type: "response.done";
+    response: Response;
+}
+/**
+ * Event indicating an assistant response is complete.
+ *
+ * - `type`: event type, always "response.done".
+ * - `response`: the completed response object.
+ */
+export declare class ResponseDone extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "response.done";
+    response: Response;
+    constructor(options: ResponseDoneOptions);
+}
+export interface ResponseOutputItemAddedOptions extends ServerEventOptions {
+    type: "response.output_item.added";
+    responseId: string;
+    outputIndex: number;
+    item: ConversationItem;
+}
+/**
+ * Event indicating an output item has been added to a response.
+ *
+ * - `type`: event type, always "response.output_item.added".
+ * - `responseId`: ID of the response.
+ * - `outputIndex`: index of the output item.
+ * - `item`: the added conversation item.
+ */
+export declare class ResponseOutputItemAdded extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "response.output_item.added";
+    responseId: string;
+    outputIndex: number;
+    item: ConversationItem;
+    constructor(options: ResponseOutputItemAddedOptions);
+}
+export interface ResponseOutputItemDoneOptions extends ServerEventOptions {
+    type: "response.output_item.done";
+    responseId: string;
+    outputIndex: number;
+    item: ConversationItem;
+}
+/**
+ * Event indicating an output item is complete.
+ *
+ * - `type`: event type, always "response.output_item.done".
+ * - `responseId`: ID of the response.
+ * - `outputIndex`: index of the output item.
+ * - `item`: the completed conversation item.
+ */
+export declare class ResponseOutputItemDone extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "response.output_item.done";
+    responseId: string;
+    outputIndex: number;
+    item: ConversationItem;
+    constructor(options: ResponseOutputItemDoneOptions);
+}
+export interface ResponseContentPartAddedOptions extends ServerEventOptions {
+    type: "response.content_part.added";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    part: ItemContent;
+}
+/**
+ * Event indicating a content part has been added to a response.
+ *
+ * - `type`: event type, always "response.content_part.added".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `part`: the added content part.
+ */
+export declare class ResponseContentPartAdded extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "response.content_part.added";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    part: ItemContent;
+    constructor(options: ResponseContentPartAddedOptions);
+}
+export interface ResponseContentPartDoneOptions extends ServerEventOptions {
+    type: "response.content_part.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    part: ItemContent;
+}
+/**
+ * Event indicating a content part is complete.
+ *
+ * - `type`: event type, always "response.content_part.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `part`: the completed content part.
+ */
+export declare class ResponseContentPartDone extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "response.content_part.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    part: ItemContent;
+    constructor(options: ResponseContentPartDoneOptions);
+}
+/** Options shared by the streamed response-content events. */
+interface ResponseContentEventOptions extends ServerEventOptions {
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+}
+export interface ResponseTextDeltaOptions extends ResponseContentEventOptions {
+    type: "response.output_text.delta";
+    delta: string;
+}
+/**
+ * Event containing incremental text from a response.
+ *
+ * - `type`: event type, always "response.output_text.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `delta`: incremental text content.
+ */
+export declare class ResponseTextDelta extends ServerEvent {
+    type: "response.output_text.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    delta: string;
+    constructor(options: ResponseTextDeltaOptions);
+}
+export interface ResponseTextDoneOptions extends ResponseContentEventOptions {
+    type: "response.output_text.done";
+    text: string;
+}
+/**
+ * Event indicating text content is complete.
+ *
+ * - `type`: event type, always "response.output_text.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `text`: complete text content.
+ */
+export declare class ResponseTextDone extends ServerEvent {
+    type: "response.output_text.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    text: string;
+    constructor(options: ResponseTextDoneOptions);
+}
+export interface ResponseAudioTranscriptDeltaOptions extends ResponseContentEventOptions {
+    type: "response.output_audio_transcript.delta";
+    delta: string;
+}
+/**
+ * Event containing incremental audio transcript from a response.
+ *
+ * - `type`: event type, always "response.output_audio_transcript.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `delta`: incremental transcript text.
+ */
+export declare class ResponseAudioTranscriptDelta extends ServerEvent {
+    type: "response.output_audio_transcript.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    delta: string;
+    constructor(options: ResponseAudioTranscriptDeltaOptions);
+}
+export interface ResponseAudioTranscriptDoneOptions extends ResponseContentEventOptions {
+    type: "response.output_audio_transcript.done";
+    transcript: string;
+}
+/**
+ * Event indicating audio transcript is complete.
+ *
+ * - `type`: event type, always "response.output_audio_transcript.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `transcript`: complete transcript text.
+ */
+export declare class ResponseAudioTranscriptDone extends ServerEvent {
+    type: "response.output_audio_transcript.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    transcript: string;
+    constructor(options: ResponseAudioTranscriptDoneOptions);
+}
+export interface ResponseAudioDeltaOptions extends ResponseContentEventOptions {
+    type: "response.output_audio.delta";
+    delta: string;
+}
+/**
+ * Event containing incremental audio data from a response.
+ *
+ * - `type`: event type, always "response.output_audio.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `delta`: base64-encoded incremental audio data.
+ */
+export declare class ResponseAudioDelta extends ServerEvent {
+    type: "response.output_audio.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    delta: string;
+    constructor(options: ResponseAudioDeltaOptions);
+}
+export interface ResponseAudioDoneOptions extends ResponseContentEventOptions {
+    type: "response.output_audio.done";
+}
+/**
+ * Event indicating audio content is complete.
+ *
+ * - `type`: event type, always "response.output_audio.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ */
+export declare class ResponseAudioDone extends ServerEvent {
+    type: "response.output_audio.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    constructor(options: ResponseAudioDoneOptions);
+}
+export interface ResponseFunctionCallArgumentsDeltaOptions extends ServerEventOptions {
+    type: "response.function_call_arguments.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    callId: string;
+    delta: string;
+}
+/**
+ * Event containing incremental function call arguments.
+ *
+ * - `type`: event type, always "response.function_call_arguments.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `callId`: ID of the function call.
+ * - `delta`: incremental function arguments as JSON.
+ */
+export declare class ResponseFunctionCallArgumentsDelta extends ServerEvent {
+    type: "response.function_call_arguments.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    callId: string;
+    delta: string;
+    constructor(options: ResponseFunctionCallArgumentsDeltaOptions);
+}
+export interface ResponseFunctionCallArgumentsDoneOptions extends ServerEventOptions {
+    type: "response.function_call_arguments.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    callId: string;
+    arguments: string;
+}
+/**
+ * Event indicating function call arguments are complete.
+ *
+ * - `type`: event type, always "response.function_call_arguments.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `callId`: ID of the function call.
+ * - `arguments`: complete function arguments as JSON string.
+ */
+export declare class ResponseFunctionCallArgumentsDone extends ServerEvent {
+    type: "response.function_call_arguments.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    callId: string;
+    arguments: string;
+    constructor(options: ResponseFunctionCallArgumentsDoneOptions);
+}
+export interface InputAudioBufferSpeechStartedOptions extends ServerEventOptions {
+    type: "input_audio_buffer.speech_started";
+    audioStartMs: number;
+    itemId: string;
+}
+/**
+ * Event indicating speech has started in the input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.speech_started".
+ * - `audioStartMs`: start time of speech in milliseconds.
+ * - `itemId`: ID of the associated conversation item.
+ */
+export declare class InputAudioBufferSpeechStarted extends ServerEvent {
+    type: "input_audio_buffer.speech_started";
+    audioStartMs: number;
+    itemId: string;
+    constructor(options: InputAudioBufferSpeechStartedOptions);
+}
+export interface InputAudioBufferSpeechStoppedOptions extends ServerEventOptions {
+    type: "input_audio_buffer.speech_stopped";
+    audioEndMs: number;
+    itemId: string;
+}
+/**
+ * Event indicating speech has stopped in the input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.speech_stopped".
+ * - `audioEndMs`: end time of speech in milliseconds.
+ * - `itemId`: ID of the associated conversation item.
+ */
+export declare class InputAudioBufferSpeechStopped extends ServerEvent {
+    type: "input_audio_buffer.speech_stopped";
+    audioEndMs: number;
+    itemId: string;
+    constructor(options: InputAudioBufferSpeechStoppedOptions);
+}
+export interface InputAudioBufferCommittedOptions extends ServerEventOptions {
+    type: "input_audio_buffer.committed";
+    previousItemId?: string | null;
+    itemId: string;
+}
+/**
+ * Event indicating the input audio buffer has been committed.
+ *
+ * - `type`: event type, always "input_audio_buffer.committed".
+ * - `previousItemId`: ID of the previous item, if any.
+ * - `itemId`: ID of the committed conversation item.
+ */
+export declare class InputAudioBufferCommitted extends ServerEvent {
+    type: "input_audio_buffer.committed";
+    previousItemId: string | null;
+    itemId: string;
+    constructor(options: InputAudioBufferCommittedOptions);
+}
+export interface InputAudioBufferClearedOptions extends ServerEventOptions {
+    type: "input_audio_buffer.cleared";
+}
+/**
+ * Event indicating the input audio buffer has been cleared.
+ *
+ * - `type`: event type, always "input_audio_buffer.cleared".
+ */
+export declare class InputAudioBufferCleared extends ServerEvent {
+    type: "input_audio_buffer.cleared";
+    constructor(options: InputAudioBufferClearedOptions);
+}
+export interface ErrorEventOptions extends ServerEventOptions {
+    type: "error";
+    error: RealtimeError;
+}
+/**
+ * Event indicating an error occurred.
+ *
+ * - `type`: event type, always "error".
+ * - `error`: error details.
+ */
+export declare class ErrorEvent extends ServerEvent {
+    static _nested: Record<string, Resolver>;
+    type: "error";
+    error: RealtimeError;
+    constructor(options: ErrorEventOptions);
+}
+export interface RateLimitsUpdatedOptions extends ServerEventOptions {
+    type: "rate_limits.updated";
+    rateLimits: Record<string, unknown>[];
+}
+/**
+ * Event indicating rate limits have been updated.
+ *
+ * - `type`: event type, always "rate_limits.updated".
+ * - `rateLimits`: list of rate limit information.
+ */
+export declare class RateLimitsUpdated extends ServerEvent {
+    type: "rate_limits.updated";
+    rateLimits: Record<string, unknown>[];
+    constructor(options: RateLimitsUpdatedOptions);
+}
+export interface CachedTokensDetailsOptions {
+    textTokens?: number | null;
+    audioTokens?: number | null;
+}
+/**
+ * Details about cached tokens.
+ *
+ * - `textTokens`: number of cached text tokens.
+ * - `audioTokens`: number of cached audio tokens.
+ */
+export declare class CachedTokensDetails extends BaseModel {
+    textTokens: number | null;
+    audioTokens: number | null;
+    constructor(options?: CachedTokensDetailsOptions);
+}
+export interface TokenDetailsOptions {
+    cachedTokens?: number | null;
+    textTokens?: number | null;
+    audioTokens?: number | null;
+    cachedTokensDetails?: CachedTokensDetails | null;
+    imageTokens?: number | null;
+}
+/**
+ * Detailed token usage information.
+ *
+ * Keys the model doesn't declare are kept (see `modelExtra`).
+ *
+ * - `cachedTokens`: number of cached tokens used. Defaults to 0.
+ * - `textTokens`: number of text tokens used. Defaults to 0.
+ * - `audioTokens`: number of audio tokens used. Defaults to 0.
+ * - `cachedTokensDetails`: detailed breakdown of cached tokens.
+ * - `imageTokens`: number of image tokens used (for input only).
+ */
+export declare class TokenDetails extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    static _extraAllowed: boolean;
+    cachedTokens: number | null;
+    textTokens: number | null;
+    audioTokens: number | null;
+    cachedTokensDetails: CachedTokensDetails | null;
+    imageTokens: number | null;
+    constructor(options?: TokenDetailsOptions);
+}
+export interface UsageOptions {
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    inputTokenDetails: TokenDetails;
+    outputTokenDetails: TokenDetails;
+}
+/**
+ * Token usage statistics for a response.
+ *
+ * - `totalTokens`: total number of tokens used.
+ * - `inputTokens`: number of input tokens used.
+ * - `outputTokens`: number of output tokens used.
+ * - `inputTokenDetails`: detailed breakdown of input token usage.
+ * - `outputTokenDetails`: detailed breakdown of output token usage.
+ */
+export declare class Usage extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    inputTokenDetails: TokenDetails;
+    outputTokenDetails: TokenDetails;
+    constructor(options: UsageOptions);
+}
+export type ResponseStatus = "completed" | "in_progress" | "incomplete" | "cancelled" | "failed";
+export interface ResponseOptions {
+    id: string;
+    object: "realtime.response";
+    status: ResponseStatus;
+    statusDetails: any;
+    output: ConversationItem[];
+    outputModalities?: Modality[] | null;
+    maxOutputTokens?: number | "inf" | null;
+    audio?: AudioConfiguration | null;
+    usage?: Usage | null;
+    voice?: string | null;
+    temperature?: number | null;
+    outputAudioFormat?: string | null;
+}
+/**
+ * A complete assistant response.
+ *
+ * - `id`: unique identifier for the response.
+ * - `object`: object type, always "realtime.response".
+ * - `status`: current status of the response.
+ * - `statusDetails`: additional status information.
+ * - `output`: list of conversation items in the response.
+ * - `outputModalities`: the set of modalities the model used to respond.
+ * - `maxOutputTokens`: maximum number of output tokens used.
+ * - `audio`: audio configuration for the response.
+ * - `usage`: token usage statistics for the response.
+ * - `voice`: the voice the model used to respond.
+ * - `temperature`: sampling temperature used for the response.
+ * - `outputAudioFormat`: the format of output audio.
+ */
+export declare class Response extends BaseModel {
+    static _nested: Record<string, Resolver>;
+    id: string;
+    object: "realtime.response";
+    status: ResponseStatus;
+    statusDetails: any;
+    output: ConversationItem[];
+    outputModalities: Modality[] | null;
+    maxOutputTokens: number | "inf" | null;
+    audio: AudioConfiguration | null;
+    usage: Usage | null;
+    voice: string | null;
+    temperature: number | null;
+    outputAudioFormat: string | null;
+    constructor(options: ResponseOptions);
+}
+/**
+ * Parse a server event from JSON string.
+ *
+ * @param str JSON string (or UTF-8 bytes) containing the server event.
+ * @returns Parsed server event object of the appropriate type.
+ * @throws Error If the event type is unimplemented or parsing fails.
+ */
+export declare function parseServerEvent(str: string | Uint8Array): ServerEvent;
+export {};
+//# sourceMappingURL=events.d.ts.map