@azure/ai-voicelive 1.0.0-alpha.20251117.2

package/dist/react-native/models/models.d.ts

@@ -0,0 +1,2154 @@
+/** Error object returned in case of API failure. */
+export interface VoiceLiveErrorDetails {
+    /** Error code, or null if unspecified. */
+    code?: string;
+    /** Human-readable error message. */
+    message: string;
+    /** Parameter name related to the error, if applicable. */
+    param?: string;
+    /** Type or category of the error. */
+    type?: string;
+    /** Event id of the error. */
+    eventId?: string;
+}
+export declare function voiceLiveErrorDetailsDeserializer(item: any): VoiceLiveErrorDetails;
+/** Standard error response envelope. */
+export interface ErrorResponse {
+    /** Error object returned in case of API failure. */
+    error: VoiceLiveErrorDetails;
+}
+export declare function errorResponseDeserializer(item: any): ErrorResponse;
+/** A single log probability entry for a token. */
+export interface LogProbProperties {
+    /** The token that was used to generate the log probability. */
+    token: string;
+    /** The log probability of the token. */
+    logprob: number;
+    /** The bytes that were used to generate the log probability. */
+    bytes: number[];
+}
+export declare function logProbPropertiesDeserializer(item: any): LogProbProperties;
+/** A voicelive client event. */
+export interface ClientEvent {
+    /** The type of event. */
+    /** The discriminator possible values: session.update, session.avatar.connect, input_audio.turn.start, input_audio.turn.append, input_audio.turn.end, input_audio.turn.cancel, input_audio.clear, input_audio_buffer.append, input_audio_buffer.commit, input_audio_buffer.clear, conversation.item.create, conversation.item.truncate, conversation.item.delete, response.create, response.cancel, conversation.item.retrieve */
+    type: ClientEventType;
+    eventId?: string;
+}
+export declare function clientEventSerializer(item: ClientEvent): any;
+/** Alias for ClientEventUnion */
+export type ClientEventUnion = ClientEventSessionUpdate | ClientEventSessionAvatarConnect | ClientEventInputAudioTurnStart | ClientEventInputAudioTurnAppend | ClientEventInputAudioTurnEnd | ClientEventInputAudioTurnCancel | ClientEventInputAudioClear | ClientEventInputAudioBufferAppend | ClientEventInputAudioBufferCommit | ClientEventInputAudioBufferClear | ClientEventConversationItemCreate | ClientEventConversationItemTruncate | ClientEventConversationItemDelete | ClientEventResponseCreate | ClientEventResponseCancel | ClientEventConversationItemRetrieve | ClientEvent;
+export declare function clientEventUnionSerializer(item: ClientEventUnion): any;
+/** Client event types used in VoiceLive protocol. */
+export declare enum KnownClientEventType {
+    /** session.update */
+    SessionUpdate = "session.update",
+    /** input_audio_buffer.append */
+    InputAudioBufferAppend = "input_audio_buffer.append",
+    /** input_audio_buffer.commit */
+    InputAudioBufferCommit = "input_audio_buffer.commit",
+    /** input_audio_buffer.clear */
+    InputAudioBufferClear = "input_audio_buffer.clear",
+    /** input_audio.turn.start */
+    InputAudioTurnStart = "input_audio.turn.start",
+    /** input_audio.turn.append */
+    InputAudioTurnAppend = "input_audio.turn.append",
+    /** input_audio.turn.end */
+    InputAudioTurnEnd = "input_audio.turn.end",
+    /** input_audio.turn.cancel */
+    InputAudioTurnCancel = "input_audio.turn.cancel",
+    /** input_audio.clear */
+    InputAudioClear = "input_audio.clear",
+    /** conversation.item.create */
+    ConversationItemCreate = "conversation.item.create",
+    /** conversation.item.retrieve */
+    ConversationItemRetrieve = "conversation.item.retrieve",
+    /** conversation.item.truncate */
+    ConversationItemTruncate = "conversation.item.truncate",
+    /** conversation.item.delete */
+    ConversationItemDelete = "conversation.item.delete",
+    /** response.create */
+    ResponseCreate = "response.create",
+    /** response.cancel */
+    ResponseCancel = "response.cancel",
+    /** session.avatar.connect */
+    SessionAvatarConnect = "session.avatar.connect"
+}
+/**
+ * Client event types used in VoiceLive protocol. \
+ * {@link KnownClientEventType} can be used interchangeably with ClientEventType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **session.update** \
+ * **input_audio_buffer.append** \
+ * **input_audio_buffer.commit** \
+ * **input_audio_buffer.clear** \
+ * **input_audio.turn.start** \
+ * **input_audio.turn.append** \
+ * **input_audio.turn.end** \
+ * **input_audio.turn.cancel** \
+ * **input_audio.clear** \
+ * **conversation.item.create** \
+ * **conversation.item.retrieve** \
+ * **conversation.item.truncate** \
+ * **conversation.item.delete** \
+ * **response.create** \
+ * **response.cancel** \
+ * **session.avatar.connect**
+ */
+export type ClientEventType = string;
+/**
+ * Send this event to update the session’s default configuration.
+ * The client may send this event at any time to update any field,
+ * except for `voice`. However, note that once a session has been
+ * initialized with a particular `model`, it can’t be changed to
+ * another model using `session.update`.
+ * When the server receives a `session.update`, it will respond
+ * with a `session.updated` event showing the full, effective configuration.
+ * Only the fields that are present are updated. To clear a field like
+ * `instructions`, pass an empty string.
+ */
+export interface ClientEventSessionUpdate extends ClientEvent {
+    /** The event type, must be `session.update`. */
+    type: "session.update";
+    session: RequestSession;
+}
+export declare function clientEventSessionUpdateSerializer(item: ClientEventSessionUpdate): any;
+/** Base for session configuration shared between request and response. */
+export interface RequestSession {
+    /** The model for the session. */
+    model?: string;
+    /** The modalities to be used in the session. */
+    modalities?: Modality[];
+    /** The animation configuration for the session. */
+    animation?: Animation;
+    /** The voice configuration for the session. */
+    voice?: Voice;
+    /** Optional instructions to guide the model's behavior throughout the session. */
+    instructions?: string;
+    /**
+     * Input audio sampling rate in Hz. Available values:
+     *
+     * - For pcm16: 8000, 16000, 24000
+     *
+     * - For g711_alaw/g711_ulaw: 8000
+     */
+    inputAudioSamplingRate?: number;
+    /** Input audio format. Default is 'pcm16'. */
+    inputAudioFormat?: InputAudioFormat;
+    /** Output audio format. Default is 'pcm16'. */
+    outputAudioFormat?: OutputAudioFormat;
+    /** Type of turn detection to use. */
+    turnDetection?: TurnDetectionUnion;
+    /** Configuration for input audio noise reduction. */
+    inputAudioNoiseReduction?: AudioNoiseReduction;
+    /** Configuration for echo cancellation during server-side audio processing. */
+    inputAudioEchoCancellation?: AudioEchoCancellation;
+    /** Configuration for avatar streaming and behavior during the session. */
+    avatar?: AvatarConfig;
+    /** Configuration for input audio transcription. */
+    inputAudioTranscription?: AudioInputTranscriptionOptions;
+    /** Types of timestamps to include in audio response content. */
+    outputAudioTimestampTypes?: AudioTimestampType[];
+    /** Configuration for tools to be used during the session, if applicable. */
+    tools?: ToolUnion[];
+    /** Specifies which tools the model is allowed to call during the session. */
+    toolChoice?: ToolChoice;
+    /** Controls the randomness of the model's output. Range: 0.0 to 1.0. Default is 0.7. */
+    temperature?: number;
+    /** Maximum number of tokens to generate in the response. Default is unlimited. */
+    maxResponseOutputTokens?: number | "inf";
+}
+export declare function requestSessionSerializer(item: RequestSession): any;
+/** Supported modalities for the session. */
+export declare enum KnownModality {
+    /** Text modality. */
+    Text = "text",
+    /** Audio modality. */
+    Audio = "audio",
+    /** Animation modality. */
+    Animation = "animation",
+    /** Avatar modality. */
+    Avatar = "avatar"
+}
+/**
+ * Supported modalities for the session. \
+ * {@link KnownModality} can be used interchangeably with Modality,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **text**: Text modality. \
+ * **audio**: Audio modality. \
+ * **animation**: Animation modality. \
+ * **avatar**: Avatar modality.
+ */
+export type Modality = string;
+/** Configuration for animation outputs including blendshapes and visemes metadata. */
+export interface Animation {
+    /** The name of the animation model to use. */
+    modelName?: string;
+    /** Set of output data types requested from the animation system. */
+    outputs?: AnimationOutputType[];
+}
+export declare function animationSerializer(item: Animation): any;
+export declare function animationDeserializer(item: any): Animation;
+/** Specifies the types of animation data to output. */
+export declare enum KnownAnimationOutputType {
+    /** Blendshapes output type. */
+    Blendshapes = "blendshapes",
+    /** Viseme ID output type. */
+    VisemeId = "viseme_id"
+}
+/**
+ * Specifies the types of animation data to output. \
+ * {@link KnownAnimationOutputType} can be used interchangeably with AnimationOutputType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **blendshapes**: Blendshapes output type. \
+ * **viseme_id**: Viseme ID output type.
+ */
+export type AnimationOutputType = string;
+/** Union of all supported voice configurations. */
+export type Voice = OAIVoice | OpenAIVoice | AzureVoiceUnion;
+export declare function voiceSerializer(item: Voice): any;
+export declare function voiceDeserializer(item: any): Voice;
+/** Supported OpenAI voice names (string enum). */
+export declare enum KnownOAIVoice {
+    /** Alloy voice. */
+    Alloy = "alloy",
+    /** Ash voice. */
+    Ash = "ash",
+    /** Ballard voice. */
+    Ballad = "ballad",
+    /** Coral voice. */
+    Coral = "coral",
+    /** Echo voice. */
+    Echo = "echo",
+    /** Sage voice. */
+    Sage = "sage",
+    /** Shimmer voice. */
+    Shimmer = "shimmer",
+    /** Verse voice. */
+    Verse = "verse"
+}
+/**
+ * Supported OpenAI voice names (string enum). \
+ * {@link KnownOAIVoice} can be used interchangeably with OAIVoice,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **alloy**: Alloy voice. \
+ * **ash**: Ash voice. \
+ * **ballad**: Ballard voice. \
+ * **coral**: Coral voice. \
+ * **echo**: Echo voice. \
+ * **sage**: Sage voice. \
+ * **shimmer**: Shimmer voice. \
+ * **verse**: Verse voice.
+ */
+export type OAIVoice = string;
+/**
+ * OpenAI voice configuration with explicit type field.
+ *
+ * This provides a unified interface for OpenAI voices, complementing the
+ * existing string-based OAIVoice for backward compatibility.
+ */
+export interface OpenAIVoice {
+    /** The type of the voice. */
+    type: "openai";
+    /** The name of the OpenAI voice. */
+    name: OAIVoice;
+}
+export declare function openAIVoiceSerializer(item: OpenAIVoice): any;
+export declare function openAIVoiceDeserializer(item: any): OpenAIVoice;
+/** Base for Azure voice configurations. */
+export interface AzureVoice {
+    /** The type of the Azure voice. */
+    /** The discriminator possible values: azure-custom, azure-standard, azure-personal */
+    type: AzureVoiceType;
+}
+export declare function azureVoiceSerializer(item: AzureVoice): any;
+export declare function azureVoiceDeserializer(item: any): AzureVoice;
+/** Alias for AzureVoiceUnion */
+export type AzureVoiceUnion = AzureCustomVoice | AzureStandardVoice | AzurePersonalVoice | AzureVoice;
+export declare function azureVoiceUnionSerializer(item: AzureVoiceUnion): any;
+export declare function azureVoiceUnionDeserializer(item: any): AzureVoiceUnion;
+/** Union of all supported Azure voice types. */
+export declare enum KnownAzureVoiceType {
+    /** Azure custom voice. */
+    AzureCustom = "azure-custom",
+    /** Azure standard voice. */
+    AzureStandard = "azure-standard",
+    /** Azure personal voice. */
+    AzurePersonal = "azure-personal"
+}
+/**
+ * Union of all supported Azure voice types. \
+ * {@link KnownAzureVoiceType} can be used interchangeably with AzureVoiceType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **azure-custom**: Azure custom voice. \
+ * **azure-standard**: Azure standard voice. \
+ * **azure-personal**: Azure personal voice.
+ */
+export type AzureVoiceType = string;
+/** Azure custom voice configuration. */
+export interface AzureCustomVoice extends AzureVoice {
+    type: "azure-custom";
+    /** Voice name cannot be empty. */
+    name: string;
+    /** Endpoint ID cannot be empty. */
+    endpointId: string;
+    /** Temperature must be between 0.0 and 1.0. */
+    temperature?: number;
+    customLexiconUrl?: string;
+    preferLocales?: string[];
+    locale?: string;
+    style?: string;
+    pitch?: string;
+    rate?: string;
+    volume?: string;
+}
+export declare function azureCustomVoiceSerializer(item: AzureCustomVoice): any;
+export declare function azureCustomVoiceDeserializer(item: any): AzureCustomVoice;
+/** Azure standard voice configuration. */
+export interface AzureStandardVoice extends AzureVoice {
+    type: "azure-standard";
+    /** Voice name cannot be empty. */
+    name: string;
+    /** Temperature must be between 0.0 and 1.0. */
+    temperature?: number;
+    customLexiconUrl?: string;
+    preferLocales?: string[];
+    locale?: string;
+    style?: string;
+    pitch?: string;
+    rate?: string;
+    volume?: string;
+}
+export declare function azureStandardVoiceSerializer(item: AzureStandardVoice): any;
+export declare function azureStandardVoiceDeserializer(item: any): AzureStandardVoice;
+/** Azure personal voice configuration. */
+export interface AzurePersonalVoice extends AzureVoice {
+    type: "azure-personal";
+    /** Voice name cannot be empty. */
+    name: string;
+    /** Temperature must be between 0.0 and 1.0. */
+    temperature?: number;
+    /** Underlying neural model to use for personal voice. */
+    model: PersonalVoiceModels;
+}
+export declare function azurePersonalVoiceSerializer(item: AzurePersonalVoice): any;
+export declare function azurePersonalVoiceDeserializer(item: any): AzurePersonalVoice;
+/** PersonalVoice models */
+export declare enum KnownPersonalVoiceModels {
+    /** Use the latest Dragon model. */
+    DragonLatestNeural = "DragonLatestNeural",
+    /** Use the latest Phoenix model. */
+    PhoenixLatestNeural = "PhoenixLatestNeural",
+    /** Use the Phoenix V2 model. */
+    PhoenixV2Neural = "PhoenixV2Neural"
+}
+/**
+ * PersonalVoice models \
+ * {@link KnownPersonalVoiceModels} can be used interchangeably with PersonalVoiceModels,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **DragonLatestNeural**: Use the latest Dragon model. \
+ * **PhoenixLatestNeural**: Use the latest Phoenix model. \
+ * **PhoenixV2Neural**: Use the Phoenix V2 model.
+ */
+export type PersonalVoiceModels = string;
+/** Input audio format types supported. */
+export declare enum KnownInputAudioFormat {
+    /** 16-bit PCM audio format at default sampling rate (24kHz) */
+    Pcm16 = "pcm16",
+    /** G.711 μ-law (mu-law) audio format at 8kHz sampling rate */
+    G711Ulaw = "g711_ulaw",
+    /** G.711 A-law audio format at 8kHz sampling rate */
+    G711Alaw = "g711_alaw"
+}
+/**
+ * Input audio format types supported. \
+ * {@link KnownInputAudioFormat} can be used interchangeably with InputAudioFormat,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **pcm16**: 16-bit PCM audio format at default sampling rate (24kHz) \
+ * **g711_ulaw**: G.711 μ-law (mu-law) audio format at 8kHz sampling rate \
+ * **g711_alaw**: G.711 A-law audio format at 8kHz sampling rate
+ */
+export type InputAudioFormat = string;
+/** Output audio format types supported. */
+export declare enum KnownOutputAudioFormat {
+    /** 16-bit PCM audio format at default sampling rate (24kHz) */
+    Pcm16 = "pcm16",
+    /** 16-bit PCM audio format at 8kHz sampling rate */
+    Pcm168000Hz = "pcm16-8000hz",
+    /** 16-bit PCM audio format at 16kHz sampling rate */
+    Pcm1616000Hz = "pcm16-16000hz",
+    /** G.711 μ-law (mu-law) audio format at 8kHz sampling rate */
+    G711Ulaw = "g711_ulaw",
+    /** G.711 A-law audio format at 8kHz sampling rate */
+    G711Alaw = "g711_alaw"
+}
+/**
+ * Output audio format types supported. \
+ * {@link KnownOutputAudioFormat} can be used interchangeably with OutputAudioFormat,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **pcm16**: 16-bit PCM audio format at default sampling rate (24kHz) \
+ * **pcm16-8000hz**: 16-bit PCM audio format at 8kHz sampling rate \
+ * **pcm16-16000hz**: 16-bit PCM audio format at 16kHz sampling rate \
+ * **g711_ulaw**: G.711 μ-law (mu-law) audio format at 8kHz sampling rate \
+ * **g711_alaw**: G.711 A-law audio format at 8kHz sampling rate
+ */
+export type OutputAudioFormat = string;
+/** Top-level union for turn detection configuration. */
+export interface TurnDetection {
+    type: TurnDetectionType;
+}
+export declare function turnDetectionSerializer(item: TurnDetection): any;
+export declare function turnDetectionDeserializer(item: any): TurnDetection;
+/** Alias for TurnDetectionUnion */
+export type TurnDetectionUnion = ServerVad | AzureSemanticVad | AzureSemanticVadEn | AzureSemanticVadMultilingual | TurnDetection;
+export declare function turnDetectionUnionSerializer(item: TurnDetectionUnion): any;
+export declare function turnDetectionUnionDeserializer(item: any): TurnDetectionUnion;
+/** Known values of {@link TurnDetectionType} that the service accepts. */
+export declare enum KnownTurnDetectionType {
+    /** server_vad */
+    ServerVad = "server_vad",
+    /** azure_semantic_vad */
+    AzureSemanticVad = "azure_semantic_vad",
+    /** azure_semantic_vad_en */
+    AzureSemanticVadEn = "azure_semantic_vad_en",
+    /** azure_semantic_vad_multilingual */
+    AzureSemanticVadMultilingual = "azure_semantic_vad_multilingual"
+}
+/** Type of TurnDetectionType */
+export type TurnDetectionType = string;
+/** Base model for VAD-based turn detection. */
+export interface ServerVad extends TurnDetection {
+    type: "server_vad";
+    threshold?: number;
+    prefixPaddingInMs?: number;
+    silenceDurationInMs?: number;
+    endOfUtteranceDetection?: EouDetectionUnion;
+    autoTruncate?: boolean;
+    createResponse?: boolean;
+    interruptResponse?: boolean;
+}
+export declare function serverVadSerializer(item: ServerVad): any;
+export declare function serverVadDeserializer(item: any): ServerVad;
+/** Top-level union for end-of-utterance (EOU) semantic detection configuration. */
+export interface EouDetection {
+    model: string;
+}
+export declare function eouDetectionSerializer(item: EouDetection): any;
+export declare function eouDetectionDeserializer(item: any): EouDetection;
+/** Alias for EouDetectionUnion */
+export type EouDetectionUnion = AzureSemanticDetection | AzureSemanticDetectionEn | AzureSemanticDetectionMultilingual | EouDetection;
+export declare function eouDetectionUnionSerializer(item: EouDetectionUnion): any;
+export declare function eouDetectionUnionDeserializer(item: any): EouDetectionUnion;
+/** Azure semantic end-of-utterance detection (default). */
+export interface AzureSemanticDetection extends EouDetection {
+    model: "semantic_detection_v1";
+    /** Threshold level setting. Recommended instead of `threshold`. One of `low`, `medium`, `high`, or `default`. */
+    thresholdLevel?: EouThresholdLevel;
+    /** Timeout in milliseconds. Recommended instead of `timeout`. */
+    timeoutInMs?: number;
+}
+export declare function azureSemanticDetectionSerializer(item: AzureSemanticDetection): any;
+export declare function azureSemanticDetectionDeserializer(item: any): AzureSemanticDetection;
+/** Threshold level settings for Azure semantic end-of-utterance detection. */
+export declare enum KnownEouThresholdLevel {
+    /** Low sensitivity threshold level. */
+    Low = "low",
+    /** Medium sensitivity threshold level. */
+    Medium = "medium",
+    /** High sensitivity threshold level. */
+    High = "high",
+    /** Default sensitivity threshold level. */
+    Default = "default"
+}
+/**
+ * Threshold level settings for Azure semantic end-of-utterance detection. \
+ * {@link KnownEouThresholdLevel} can be used interchangeably with EouThresholdLevel,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **low**: Low sensitivity threshold level. \
+ * **medium**: Medium sensitivity threshold level. \
+ * **high**: High sensitivity threshold level. \
+ * **default**: Default sensitivity threshold level.
+ */
+export type EouThresholdLevel = string;
+/** Azure semantic end-of-utterance detection (English-optimized). */
+export interface AzureSemanticDetectionEn extends EouDetection {
+    model: "semantic_detection_v1_en";
+    /** Threshold level setting. Recommended instead of `threshold`. One of `low`, `medium`, `high`, or `default`. */
+    thresholdLevel?: EouThresholdLevel;
+    /** Timeout in milliseconds. Recommended instead of `timeout`. */
+    timeoutInMs?: number;
+}
+export declare function azureSemanticDetectionEnSerializer(item: AzureSemanticDetectionEn): any;
+export declare function azureSemanticDetectionEnDeserializer(item: any): AzureSemanticDetectionEn;
+/** Azure semantic end-of-utterance detection (multilingual). */
+export interface AzureSemanticDetectionMultilingual extends EouDetection {
+    model: "semantic_detection_v1_multilingual";
+    /** Threshold level setting. Recommended instead of `threshold`. One of `low`, `medium`, `high`, or `default`. */
+    thresholdLevel?: EouThresholdLevel;
+    /** Timeout in milliseconds. Recommended instead of `timeout`. */
+    timeoutInMs?: number;
+}
+export declare function azureSemanticDetectionMultilingualSerializer(item: AzureSemanticDetectionMultilingual): any;
+export declare function azureSemanticDetectionMultilingualDeserializer(item: any): AzureSemanticDetectionMultilingual;
+/** Server Speech Detection (Azure semantic VAD, default variant). */
+export interface AzureSemanticVad extends TurnDetection {
+    type: "azure_semantic_vad";
+    threshold?: number;
+    prefixPaddingInMs?: number;
+    silenceDurationInMs?: number;
+    endOfUtteranceDetection?: EouDetectionUnion;
+    speechDurationInMs?: number;
+    removeFillerWords?: boolean;
+    languages?: string[];
+    autoTruncate?: boolean;
+    createResponse?: boolean;
+    interruptResponse?: boolean;
+}
+export declare function azureSemanticVadSerializer(item: AzureSemanticVad): any;
+export declare function azureSemanticVadDeserializer(item: any): AzureSemanticVad;
+/** Server Speech Detection (Azure semantic VAD, English-only). */
+export interface AzureSemanticVadEn extends TurnDetection {
+    type: "azure_semantic_vad_en";
+    threshold?: number;
+    prefixPaddingInMs?: number;
+    silenceDurationInMs?: number;
+    endOfUtteranceDetection?: EouDetectionUnion;
+    speechDurationInMs?: number;
+    removeFillerWords?: boolean;
+    autoTruncate?: boolean;
+    createResponse?: boolean;
+    interruptResponse?: boolean;
+}
+export declare function azureSemanticVadEnSerializer(item: AzureSemanticVadEn): any;
+export declare function azureSemanticVadEnDeserializer(item: any): AzureSemanticVadEn;
+/** Server Speech Detection (Azure semantic VAD). */
+export interface AzureSemanticVadMultilingual extends TurnDetection {
+    type: "azure_semantic_vad_multilingual";
+    threshold?: number;
+    prefixPaddingInMs?: number;
+    silenceDurationInMs?: number;
+    endOfUtteranceDetection?: EouDetectionUnion;
+    speechDurationInMs?: number;
+    removeFillerWords?: boolean;
+    languages?: string[];
+    autoTruncate?: boolean;
+    createResponse?: boolean;
+    interruptResponse?: boolean;
+}
+export declare function azureSemanticVadMultilingualSerializer(item: AzureSemanticVadMultilingual): any;
+export declare function azureSemanticVadMultilingualDeserializer(item: any): AzureSemanticVadMultilingual;
+/** Configuration for input audio noise reduction. */
+export interface AudioNoiseReduction {
+    /** The type of noise reduction model. */
+    type: string;
+}
+export declare function audioNoiseReductionSerializer(item: AudioNoiseReduction): any;
+export declare function audioNoiseReductionDeserializer(item: any): AudioNoiseReduction;
+/** Echo cancellation configuration for server-side audio processing. */
+export interface AudioEchoCancellation {
+    /** The type of echo cancellation model to use. */
+    type: "server_echo_cancellation";
+}
+export declare function audioEchoCancellationSerializer(item: AudioEchoCancellation): any;
+export declare function audioEchoCancellationDeserializer(item: any): AudioEchoCancellation;
+/** Configuration for avatar streaming and behavior during the session. */
+export interface AvatarConfig {
+    /** Optional list of ICE servers to use for WebRTC connection establishment. */
+    iceServers?: IceServer[];
+    /** The character name or ID used for the avatar. */
+    character: string;
+    /** Optional avatar style, such as emotional tone or speaking style. */
+    style?: string;
+    /** Indicates whether the avatar is customized or not. */
+    customized: boolean;
+    /** Optional video configuration including resolution, bitrate, and codec. */
+    video?: VideoParams;
+}
+export declare function avatarConfigSerializer(item: AvatarConfig): any;
+export declare function avatarConfigDeserializer(item: any): AvatarConfig;
+export declare function iceServerArraySerializer(result: Array<IceServer>): any[];
+export declare function iceServerArrayDeserializer(result: Array<IceServer>): any[];
+/** ICE server configuration for WebRTC connection negotiation. */
+export interface IceServer {
+    /** List of ICE server URLs (e.g., TURN or STUN endpoints). */
+    urls: string[];
+    /** Optional username used for authentication with the ICE server. */
+    username?: string;
+    /** Optional credential (e.g., password or token) used for authentication. */
+    credential?: string;
+}
+export declare function iceServerSerializer(item: IceServer): any;
+export declare function iceServerDeserializer(item: any): IceServer;
+/** Video streaming parameters for avatar. */
+export interface VideoParams {
+    /** Bitrate in bits per second (e.g., 2000000 for 2 Mbps). */
+    bitrate?: number;
+    /** Codec to use for encoding. Currently only 'h264' is supported. */
+    codec?: "h264";
+    /** Optional cropping settings for the video stream. */
+    crop?: VideoCrop;
+    /** Optional resolution settings for the video stream. */
+    resolution?: VideoResolution;
+    /** Optional background settings for the video. Allows specifying either a solid color or an image URL. */
+    background?: Background;
+    /** Group of Pictures (GOP) size for video encoding. Controls the interval between keyframes, affecting compression efficiency and seeking performance. */
+    gopSize?: number;
+}
+export declare function videoParamsSerializer(item: VideoParams): any;
+export declare function videoParamsDeserializer(item: any): VideoParams;
+/** Defines a video crop rectangle using top-left and bottom-right coordinates. */
+export interface VideoCrop {
+    /** Top-left corner of the crop region. Array of [x, y], must be non-negative integers. */
+    topLeft: number[];
+    /** Bottom-right corner of the crop region. Array of [x, y], must be non-negative integers. */
+    bottomRight: number[];
+}
+export declare function videoCropSerializer(item: VideoCrop): any;
+export declare function videoCropDeserializer(item: any): VideoCrop;
+/** Resolution of the video feed in pixels. */
+export interface VideoResolution {
+    /** Width of the video in pixels. Must be greater than 0. */
+    width: number;
+    /** Height of the video in pixels. Must be greater than 0. */
+    height: number;
+}
+export declare function videoResolutionSerializer(item: VideoResolution): any;
+export declare function videoResolutionDeserializer(item: any): VideoResolution;
+/** Defines a video background, either a solid color or an image URL (mutually exclusive). */
+export interface Background {
+    /** Background color in hex format (e.g., `#00FF00FF`). Cannot be set if `image_url` is provided. */
+    color?: string;
+    /** Background image URL. Cannot be set if `color` is provided. */
+    imageUrl?: string;
+}
+export declare function backgroundSerializer(item: Background): any;
+export declare function backgroundDeserializer(item: any): Background;
+/** Configuration for input audio transcription. */
+export interface AudioInputTranscriptionOptions {
+    /**
+     * The transcription model to use. Supported values:
+     * 'whisper-1', 'gpt-4o-transcribe', 'gpt-4o-mini-transcribe',
+     * 'azure-speech'.
+     */
+    model: string;
+    /** Optional language code in BCP-47 (e.g., 'en-US'), or ISO-639-1 (e.g., 'en'), or multi languages with auto detection, (e.g., 'en,zh'). */
+    language?: string;
+    /** Optional configuration for custom speech models. */
+    customSpeech?: Record<string, string>;
+    /** Optional list of phrase hints to bias recognition. */
+    phraseList?: string[];
+}
+export declare function audioInputTranscriptionOptionsSerializer(item: AudioInputTranscriptionOptions): any;
+export declare function audioInputTranscriptionOptionsDeserializer(item: any): AudioInputTranscriptionOptions;
+/** Output timestamp types supported in audio response content. */
+export declare enum KnownAudioTimestampType {
+    /** Timestamps per word in the output audio. */
+    Word = "word"
+}
+/**
+ * Output timestamp types supported in audio response content. \
+ * {@link KnownAudioTimestampType} can be used interchangeably with AudioTimestampType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **word**: Timestamps per word in the output audio.
+ */
+export type AudioTimestampType = string;
+export declare function toolUnionArraySerializer(result: Array<ToolUnion>): any[];
+export declare function toolUnionArrayDeserializer(result: Array<ToolUnion>): any[];
+/** The base representation of a voicelive tool definition. */
+export interface Tool {
+    type: ToolType;
+}
+export declare function toolSerializer(item: Tool): any;
+export declare function toolDeserializer(item: any): Tool;
+/** Alias for ToolUnion */
+export type ToolUnion = FunctionTool | Tool;
+export declare function toolUnionSerializer(item: ToolUnion): any;
+export declare function toolUnionDeserializer(item: any): ToolUnion;
+/**
+ * The supported tool type discriminators for voicelive tools.
+ * Currently, only 'function' tools are supported.
+ */
+export declare enum KnownToolType {
+    /** function */
+    Function = "function"
+}
+/**
+ * The supported tool type discriminators for voicelive tools.
+ * Currently, only 'function' tools are supported. \
+ * {@link KnownToolType} can be used interchangeably with ToolType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **function**
+ */
+export type ToolType = string;
+/** The definition of a function tool as used by the voicelive endpoint. */
+export interface FunctionTool extends Tool {
+    type: "function";
+    name: string;
+    description?: string;
+    parameters?: any;
+}
+export declare function functionToolSerializer(item: FunctionTool): any;
+export declare function functionToolDeserializer(item: any): FunctionTool;
+/**
+ * The combined set of available representations for a voicelive tool_choice parameter, encompassing both string
+ * literal options like 'auto' as well as structured references to defined tools.
+ */
+export type ToolChoice = ToolChoiceLiteral | ToolChoiceSelectionUnion;
+export declare function toolChoiceSerializer(item: ToolChoice): any;
+export declare function toolChoiceDeserializer(item: any): ToolChoice;
+/** The available set of mode-level, string literal tool_choice options for the voicelive endpoint. */
+export declare enum KnownToolChoiceLiteral {
+    /** Specifies that the model should freely determine which tool or tools, if any, to call. */
+    Auto = "auto",
+    /** Specifies that the model should call no tools whatsoever. */
+    None = "none",
+    /** Specifies that the model should call at least one tool. */
+    Required = "required"
+}
+/**
+ * The available set of mode-level, string literal tool_choice options for the voicelive endpoint. \
+ * {@link KnownToolChoiceLiteral} can be used interchangeably with ToolChoiceLiteral,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **auto**: Specifies that the model should freely determine which tool or tools, if any, to call. \
+ * **none**: Specifies that the model should call no tools whatsoever. \
+ * **required**: Specifies that the model should call at least one tool.
+ */
+export type ToolChoiceLiteral = string;
+/** A base representation for a voicelive tool_choice selecting a named tool. */
+export interface ToolChoiceSelection {
+    type: ToolType;
+}
+export declare function toolChoiceSelectionSerializer(item: ToolChoiceSelection): any;
+export declare function toolChoiceSelectionDeserializer(item: any): ToolChoiceSelection;
+/** Alias for ToolChoiceSelectionUnion */
+export type ToolChoiceSelectionUnion = ToolChoiceFunctionSelection | ToolChoiceSelection;
+export declare function toolChoiceSelectionUnionSerializer(item: ToolChoiceSelectionUnion): any;
+export declare function toolChoiceSelectionUnionDeserializer(item: any): ToolChoiceSelectionUnion;
+/** The representation of a voicelive tool_choice selecting a named function tool. */
+export interface ToolChoiceFunctionSelection extends ToolChoiceSelection {
+    type: "function";
+    name: string;
+}
+export declare function toolChoiceFunctionSelectionSerializer(item: ToolChoiceFunctionSelection): any;
+export declare function toolChoiceFunctionSelectionDeserializer(item: any): ToolChoiceFunctionSelection;
+/** Alias for _RequestSessionMaxResponseOutputTokens */
+export type _RequestSessionMaxResponseOutputTokens = number | "inf";
+export declare function _requestSessionMaxResponseOutputTokensSerializer(item: _RequestSessionMaxResponseOutputTokens): any;
+export declare function _requestSessionMaxResponseOutputTokensDeserializer(item: any): _RequestSessionMaxResponseOutputTokens;
+/**
+ * Sent when the client connects and provides its SDP (Session Description Protocol)
+ *
+ * for avatar-related media negotiation.
+ */
+export interface ClientEventSessionAvatarConnect extends ClientEvent {
+    /** The event type, must be 'session.avatar.connect'. */
+    type: "session.avatar.connect";
+    /** The client's SDP offer. */
+    clientSdp: string;
+}
+export declare function clientEventSessionAvatarConnectSerializer(item: ClientEventSessionAvatarConnect): any;
+/** Indicates the start of a new audio input turn. */
+export interface ClientEventInputAudioTurnStart extends ClientEvent {
+    /** The event type, must be 'input_audio.turn.start'. */
+    type: "input_audio.turn.start";
+    /** Unique identifier for the input audio turn. */
+    turnId: string;
+}
+export declare function clientEventInputAudioTurnStartSerializer(item: ClientEventInputAudioTurnStart): any;
+/** Appends audio data to an ongoing input turn. */
+export interface ClientEventInputAudioTurnAppend extends ClientEvent {
+    /** The event type, must be 'input_audio.turn.append'. */
+    type: "input_audio.turn.append";
+    /** The ID of the turn this audio is part of. */
+    turnId: string;
+    /** Base64-encoded audio chunk. */
+    audio: string;
+}
+export declare function clientEventInputAudioTurnAppendSerializer(item: ClientEventInputAudioTurnAppend): any;
+/** Marks the end of an audio input turn. */
+export interface ClientEventInputAudioTurnEnd extends ClientEvent {
+    /** The event type, must be 'input_audio.turn.end'. */
+    type: "input_audio.turn.end";
+    /** The ID of the audio turn being ended. */
+    turnId: string;
+}
+export declare function clientEventInputAudioTurnEndSerializer(item: ClientEventInputAudioTurnEnd): any;
+/** Cancels an in-progress input audio turn. */
+export interface ClientEventInputAudioTurnCancel extends ClientEvent {
+    /** The event type, must be 'input_audio.turn.cancel'. */
+    type: "input_audio.turn.cancel";
+    /** The ID of the turn to cancel. */
+    turnId: string;
+}
+export declare function clientEventInputAudioTurnCancelSerializer(item: ClientEventInputAudioTurnCancel): any;
+/** Clears all input audio currently being streamed. */
+export interface ClientEventInputAudioClear extends ClientEvent {
+    /** The event type, must be 'input_audio.clear'. */
+    type: "input_audio.clear";
+}
+export declare function clientEventInputAudioClearSerializer(item: ClientEventInputAudioClear): any;
+/**
+ * Send this event to append audio bytes to the input audio buffer. The audio
+ * buffer is temporary storage you can write to and later commit. In Server VAD
+ * mode, the audio buffer is used to detect speech and the server will decide
+ * when to commit. When Server VAD is disabled, you must commit the audio buffer
+ * manually.
+ *
+ * The client may choose how much audio to place in each event up to a maximum
+ * of 15 MiB, for example streaming smaller chunks from the client may allow the
+ * VAD to be more responsive. Unlike made other client events, the server will
+ * not send a confirmation response to this event.
+ */
+export interface ClientEventInputAudioBufferAppend extends ClientEvent {
+    /** The event type, must be `input_audio_buffer.append`. */
+    type: "input_audio_buffer.append";
+    /**
+     * Base64-encoded audio. This must be in the format specified by the
+     * `input_audio_format` field in the session configuration.
+     */
+    audio: string;
+}
+export declare function clientEventInputAudioBufferAppendSerializer(item: ClientEventInputAudioBufferAppend): any;
+/**
+ * Send this event to commit the user input audio buffer, which will create a
+ * new user message item in the conversation. This event will produce an error
+ * if the input audio buffer is empty. When in Server VAD mode, the client does
+ * not need to send this event, the server will commit the audio buffer
+ * automatically.
+ * Committing the input audio buffer will trigger input audio transcription
+ * (if enabled in session configuration), but it will not create a response
+ * from the model. The server will respond with an `input_audio_buffer.committed`
+ * event.
+ */
+export interface ClientEventInputAudioBufferCommit extends ClientEvent {
+    /** The event type, must be `input_audio_buffer.commit`. */
+    type: "input_audio_buffer.commit";
+}
+export declare function clientEventInputAudioBufferCommitSerializer(item: ClientEventInputAudioBufferCommit): any;
+/**
+ * Send this event to clear the audio bytes in the buffer. The server will
+ * respond with an `input_audio_buffer.cleared` event.
+ */
+export interface ClientEventInputAudioBufferClear extends ClientEvent {
+    /** The event type, must be `input_audio_buffer.clear`. */
+    type: "input_audio_buffer.clear";
+}
+export declare function clientEventInputAudioBufferClearSerializer(item: ClientEventInputAudioBufferClear): any;
+/**
+ * Add a new Item to the Conversation's context, including messages, function
+ * calls, and function call responses. This event can be used both to populate a
+ * "history" of the conversation and to add new items mid-stream, but has the
+ * current limitation that it cannot populate assistant audio messages.
+ * If successful, the server will respond with a `conversation.item.created`
+ * event, otherwise an `error` event will be sent.
+ */
+export interface ClientEventConversationItemCreate extends ClientEvent {
+    /** The event type, must be `conversation.item.create`. */
+    type: "conversation.item.create";
+    /** Optional client-generated ID used to identify this event. */
+    eventId?: string;
+    /**
+     * The ID of the preceding item after which the new item will be inserted.
+     * If not set, the new item will be appended to the end of the conversation.
+     * If set to `root`, the new item will be added to the beginning of the conversation.
+     * If set to an existing ID, it allows an item to be inserted mid-conversation. If the
+     * ID cannot be found, an error will be returned and the item will not be added.
+     */
+    previousItemId?: string;
+    item?: ConversationRequestItemUnion;
+}
+export declare function clientEventConversationItemCreateSerializer(item: ClientEventConversationItemCreate): any;
+/** Base for any response item; discriminated by `type`. */
+export interface ConversationRequestItem {
+    type: ItemType;
+    id?: string;
+}
+export declare function conversationRequestItemSerializer(item: ConversationRequestItem): any;
+export declare function conversationRequestItemDeserializer(item: any): ConversationRequestItem;
+/** Alias for ConversationRequestItemUnion */
+export type ConversationRequestItemUnion = MessageItemUnion | FunctionCallItem | FunctionCallOutputItem | ConversationRequestItem;
+export declare function conversationRequestItemUnionSerializer(item: ConversationRequestItemUnion): any;
+export declare function conversationRequestItemUnionDeserializer(item: any): ConversationRequestItemUnion;
+/** Known values of {@link ItemType} that the service accepts. */
+export declare enum KnownItemType {
+    /** message */
+    Message = "message",
+    /** function_call */
+    FunctionCall = "function_call",
+    /** function_call_output */
+    FunctionCallOutput = "function_call_output"
+}
+/** Type of ItemType */
+export type ItemType = string;
+/** A message item within a conversation. */
+export interface MessageItem extends ConversationRequestItem {
+    /** The type of the item; must be 'message' for message items. */
+    type: "message";
+    /** The role of the message origionator. */
+    /** The discriminator possible values: system, user, assistant */
+    role: MessageRole;
+    /** The content parts of the message. */
+    content: MessageContentPartUnion[];
+    /** Processing status of the message item. */
+    status?: ItemParamStatus;
+}
+export declare function messageItemSerializer(item: MessageItem): any;
+export declare function messageItemDeserializer(item: any): MessageItem;
+/** Alias for MessageItemUnion */
+export type MessageItemUnion = SystemMessageItem | UserMessageItem | AssistantMessageItem | MessageItem;
+export declare function messageItemUnionSerializer(item: MessageItemUnion): any;
+export declare function messageItemUnionDeserializer(item: any): MessageItemUnion;
+/** Known values of {@link MessageRole} that the service accepts. */
+export declare enum KnownMessageRole {
+    /** system */
+    System = "system",
+    /** user */
+    User = "user",
+    /** assistant */
+    Assistant = "assistant"
+}
+/** Type of MessageRole */
+export type MessageRole = string;
+export declare function messageContentPartUnionArraySerializer(result: Array<MessageContentPartUnion>): any[];
+export declare function messageContentPartUnionArrayDeserializer(result: Array<MessageContentPartUnion>): any[];
+/** Base for any message content part; discriminated by `type`. */
+export interface MessageContentPart {
+    /** The type of the content part. */
+    /** The discriminator possible values: input_text, input_audio, text */
+    type: ContentPartType;
+}
+export declare function messageContentPartSerializer(item: MessageContentPart): any;
+export declare function messageContentPartDeserializer(item: any): MessageContentPart;
+/** Alias for MessageContentPartUnion */
+export type MessageContentPartUnion = InputTextContentPart | InputAudioContentPart | OutputTextContentPart | MessageContentPart;
+export declare function messageContentPartUnionSerializer(item: MessageContentPartUnion): any;
+export declare function messageContentPartUnionDeserializer(item: any): MessageContentPartUnion;
+/** Known values of {@link ContentPartType} that the service accepts. */
+export declare enum KnownContentPartType {
+    /** input_text */
+    InputText = "input_text",
+    /** input_audio */
+    InputAudio = "input_audio",
+    /** text */
+    Text = "text",
+    /** audio */
+    Audio = "audio"
+}
+/** Type of ContentPartType */
+export type ContentPartType = string;
+/** Input text content part. */
+export interface InputTextContentPart extends MessageContentPart {
+    type: "input_text";
+    text: string;
+}
+export declare function inputTextContentPartSerializer(item: InputTextContentPart): any;
+export declare function inputTextContentPartDeserializer(item: any): InputTextContentPart;
+/** Input audio content part. */
+export interface InputAudioContentPart extends MessageContentPart {
+    type: "input_audio";
+    audio: string;
+    transcript?: string;
+}
+export declare function inputAudioContentPartSerializer(item: InputAudioContentPart): any;
+export declare function inputAudioContentPartDeserializer(item: any): InputAudioContentPart;
+/** Output text content part. */
+export interface OutputTextContentPart extends MessageContentPart {
+    /** The type of the content part. */
+    type: "text";
+    /** The text content. */
+    text: string;
+}
+export declare function outputTextContentPartSerializer(item: OutputTextContentPart): any;
+export declare function outputTextContentPartDeserializer(item: any): OutputTextContentPart;
+/** Indicates the processing status of an item or parameter. */
+export declare enum KnownItemParamStatus {
+    /** Item or parameter is still being processed. */
+    Completed = "completed",
+    /** Item or parameter is not yet complete. */
+    Incomplete = "incomplete"
+}
+/**
+ * Indicates the processing status of an item or parameter. \
+ * {@link KnownItemParamStatus} can be used interchangeably with ItemParamStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **completed**: Item or parameter is still being processed. \
+ * **incomplete**: Item or parameter is not yet complete.
+ */
+export type ItemParamStatus = string;
+/** A system message item within a conversation. */
+export interface SystemMessageItem extends MessageItem {
+    role: "system";
+}
+export declare function systemMessageItemSerializer(item: SystemMessageItem): any;
+export declare function systemMessageItemDeserializer(item: any): SystemMessageItem;
+/** A user message item within a conversation. */
+export interface UserMessageItem extends MessageItem {
+    role: "user";
+}
+export declare function userMessageItemSerializer(item: UserMessageItem): any;
+export declare function userMessageItemDeserializer(item: any): UserMessageItem;
+/** An assistant message item within a conversation. */
+export interface AssistantMessageItem extends MessageItem {
+    role: "assistant";
+}
+export declare function assistantMessageItemSerializer(item: AssistantMessageItem): any;
+export declare function assistantMessageItemDeserializer(item: any): AssistantMessageItem;
+/** A function call item within a conversation. */
+export interface FunctionCallItem extends ConversationRequestItem {
+    type: "function_call";
+    name: string;
+    callId: string;
+    arguments: string;
+    status?: ItemParamStatus;
+}
+export declare function functionCallItemSerializer(item: FunctionCallItem): any;
+export declare function functionCallItemDeserializer(item: any): FunctionCallItem;
+/** A function call output item within a conversation. */
+export interface FunctionCallOutputItem extends ConversationRequestItem {
+    type: "function_call_output";
+    callId: string;
+    output: string;
+    status?: ItemParamStatus;
+}
+export declare function functionCallOutputItemSerializer(item: FunctionCallOutputItem): any;
+export declare function functionCallOutputItemDeserializer(item: any): FunctionCallOutputItem;
+/**
+ * Send this event to truncate a previous assistant message’s audio. The server
+ * will produce audio faster than voicelive, so this event is useful when the user
+ * interrupts to truncate audio that has already been sent to the client but not
+ * yet played. This will synchronize the server's understanding of the audio with
+ * the client's playback.
+ * Truncating audio will delete the server-side text transcript to ensure there
+ * is not text in the context that hasn't been heard by the user.
+ * If successful, the server will respond with a `conversation.item.truncated`
+ * event.
+ */
+export interface ClientEventConversationItemTruncate extends ClientEvent {
+    /** The event type, must be `conversation.item.truncate`. */
+    type: "conversation.item.truncate";
+    /**
+     * The ID of the assistant message item to truncate. Only assistant message
+     * items can be truncated.
+     */
+    itemId: string;
+    /** The index of the content part to truncate. Set this to 0. */
+    contentIndex: number;
+    /**
+     * Inclusive duration up to which audio is truncated, in milliseconds. If
+     * the audio_end_ms is greater than the actual audio duration, the server
+     * will respond with an error.
+     */
+    audioEndInMs: number;
+}
+export declare function clientEventConversationItemTruncateSerializer(item: ClientEventConversationItemTruncate): any;
+/**
+ * Send this event when you want to remove any item from the conversation
+ * history. The server will respond with a `conversation.item.deleted` event,
+ * unless the item does not exist in the conversation history, in which case the
+ * server will respond with an error.
+ */
+export interface ClientEventConversationItemDelete extends ClientEvent {
+    /** The event type, must be `conversation.item.delete`. */
+    type: "conversation.item.delete";
+    /** The ID of the item to delete. */
+    itemId: string;
+}
+export declare function clientEventConversationItemDeleteSerializer(item: ClientEventConversationItemDelete): any;
+/**
+ * This event instructs the server to create a Response, which means triggering
+ * model inference. When in Server VAD mode, the server will create Responses
+ * automatically.
+ * A Response will include at least one Item, and may have two, in which case
+ * the second will be a function call. These Items will be appended to the
+ * conversation history.
+ * The server will respond with a `response.created` event, events for Items
+ * and content created, and finally a `response.done` event to indicate the
+ * Response is complete.
+ * The `response.create` event includes inference configuration like
+ * `instructions`, and `temperature`. These fields will override the Session's
+ * configuration for this Response only.
+ */
+export interface ClientEventResponseCreate extends ClientEvent {
+    /** The event type, must be `response.create`. */
+    type: "response.create";
+    response?: ResponseCreateParams;
+    /** additional instructions (system prompt) appended to the default instructions of the session. Only affects this response only. */
+    additionalInstructions?: string;
+}
+export declare function clientEventResponseCreateSerializer(item: ClientEventResponseCreate): any;
+/** Create a new VoiceLive response with these parameters */
+export interface ResponseCreateParams {
+    /** Whether to commit the response to the conversation. Defaults to true. */
+    commit?: boolean;
+    /** Whether to cancel any ongoing generation before starting this one. Defaults to true. */
+    cancelPrevious?: boolean;
+    /** Input items to append to the conversation context before generating a response. */
+    appendInputItems?: ConversationRequestItemUnion[];
+    /**
+     * Input items to be used as the context for this response.
+     * An empty array clears previous context.
+     */
+    inputItems?: ConversationRequestItemUnion[];
+    /**
+     * The set of modalities the model can respond with. To disable audio,
+     * set this to ["text"].
+     */
+    modalities?: Modality[];
+    /**
+     * The default system instructions (i.e. system message) prepended to model
+     * calls. This field allows the client to guide the model on desired
+     * responses. The model can be instructed on response content and format,
+     * (e.g. "be extremely succinct", "act friendly", "here are examples of good
+     * responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+     * into your voice", "laugh frequently"). The instructions are not guaranteed
+     * to be followed by the model, but they provide guidance to the model on the
+     * desired behavior.
+     *
+     * Note that the server sets default instructions which will be used if this
+     * field is not set and are visible in the `session.created` event at the
+     * start of the session.
+     */
+    instructions?: string;
+    /** supported voice identifiers and configurations. */
+    voice?: Voice;
+    /** The format of output audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. */
+    outputAudioFormat?: OutputAudioFormat;
+    /** Tools (functions) available to the model. */
+    tools?: ToolUnion[];
+    /**
+     * How the model chooses tools. Options are `auto`, `none`, `required`, or
+     * specify a function, like `{"type": "function", "function": {"name": "my_function"}}`.
+     */
+    toolChoice?: string;
+    /** Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8. */
+    temperature?: number;
+    /**
+     * Maximum number of output tokens for a single assistant response,
+     * inclusive of tool calls. Provide an integer between 1 and 4096 to
+     * limit output tokens, or `inf` for the maximum available tokens for a
+     * given model. Defaults to `inf`.
+     */
+    maxOutputTokens?: number | "inf";
+}
+export declare function responseCreateParamsSerializer(item: ResponseCreateParams): any;
+export declare function responseCreateParamsDeserializer(item: any): ResponseCreateParams;
+export declare function conversationRequestItemUnionArraySerializer(result: Array<ConversationRequestItemUnion>): any[];
+export declare function conversationRequestItemUnionArrayDeserializer(result: Array<ConversationRequestItemUnion>): any[];
+/** Alias for _ResponseCreateParamsMaxOutputTokens */
+export type _ResponseCreateParamsMaxOutputTokens = number | "inf";
+export declare function _responseCreateParamsMaxOutputTokensSerializer(item: _ResponseCreateParamsMaxOutputTokens): any;
+export declare function _responseCreateParamsMaxOutputTokensDeserializer(item: any): _ResponseCreateParamsMaxOutputTokens;
+/**
+ * Send this event to cancel an in-progress response. The server will respond
+ * with a `response.cancelled` event or an error if there is no response to
+ * cancel.
+ */
+export interface ClientEventResponseCancel extends ClientEvent {
+    /** The event type, must be `response.cancel`. */
+    type: "response.cancel";
+    /**
+     * A specific response ID to cancel - if not provided, will cancel an
+     * in-progress response in the default conversation.
+     */
+    responseId?: string;
+}
+export declare function clientEventResponseCancelSerializer(item: ClientEventResponseCancel): any;
+/**
+ * Send this event when you want to retrieve the server's representation of a specific item in the conversation history. This is useful, for example, to inspect user audio after noise cancellation and VAD.
+ * The server will respond with a `conversation.item.retrieved` event,
+ * unless the item does not exist in the conversation history, in which case the
+ * server will respond with an error.
+ */
+export interface ClientEventConversationItemRetrieve extends ClientEvent {
+    /** The event type, must be `conversation.item.retrieve`. */
+    type: "conversation.item.retrieve";
+    /** The ID of the item to retrieve. */
+    itemId: string;
+}
+export declare function clientEventConversationItemRetrieveSerializer(item: ClientEventConversationItemRetrieve): any;
+/** VoiceLive session object configuration. */
+export interface SessionBase {
+}
+export declare function sessionBaseDeserializer(item: any): SessionBase;
+/** The item to add to the conversation. */
+export interface ConversationItemBase {
+}
+export declare function conversationItemBaseSerializer(item: ConversationItemBase): any;
+/** The response resource. */
+export interface Response {
+    /** The unique ID of the response. */
+    id?: string;
+    /** The object type, must be `realtime.response`. */
+    object?: "realtime.response";
+    /**
+     * The final status of the response.
+     *
+     * One of: `completed`, `cancelled`, `failed`, `incomplete`, or `in_progress`.
+     */
+    status?: ResponseStatus;
+    /** Additional details about the status. */
+    statusDetails?: ResponseStatusDetailsUnion;
+    /** The list of output items generated by the response. */
+    output?: ResponseItemUnion[];
+    /**
+     * Usage statistics for the Response, this will correspond to billing. A
+     * VoiceLive API session will maintain a conversation context and append new
+     * Items to the Conversation, thus output from previous turns (text and
+     * audio tokens) will become the input for later turns.
+     */
+    usage?: TokenUsage;
+    /**
+     * Which conversation the response is added to, determined by the `conversation`
+     * field in the `response.create` event. If `auto`, the response will be added to
+     * the default conversation and the value of `conversation_id` will be an id like
+     * `conv_1234`. If `none`, the response will not be added to any conversation and
+     * the value of `conversation_id` will be `null`. If responses are being triggered
+     * by server VAD, the response will be added to the default conversation, thus
+     * the `conversation_id` will be an id like `conv_1234`.
+     */
+    conversationId?: string;
+    /** supported voice identifiers and configurations. */
+    voice?: Voice;
+    /**
+     * The set of modalities the model used to respond. If there are multiple modalities,
+     * the model will pick one, for example if `modalities` is `["text", "audio"]`, the model
+     * could be responding in either text or audio.
+     */
+    modalities?: Modality[];
+    /** The format of output audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. */
+    outputAudioFormat?: OutputAudioFormat;
+    /** Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8. */
+    temperature?: number;
+    /**
+     * Maximum number of output tokens for a single assistant response,
+     * inclusive of tool calls, that was used in this response.
+     */
+    maxOutputTokens?: number | "inf";
+}
+export declare function responseDeserializer(item: any): Response;
+/** Terminal status of a response. */
+export declare enum KnownResponseStatus {
+    /** completed */
+    Completed = "completed",
+    /** cancelled */
+    Cancelled = "cancelled",
+    /** failed */
+    Failed = "failed",
+    /** incomplete */
+    Incomplete = "incomplete",
+    /** in_progress */
+    InProgress = "in_progress"
+}
+/**
+ * Terminal status of a response. \
+ * {@link KnownResponseStatus} can be used interchangeably with ResponseStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **completed** \
+ * **cancelled** \
+ * **failed** \
+ * **incomplete** \
+ * **in_progress**
+ */
+export type ResponseStatus = string;
+/** Base for all non-success response details. */
+export interface ResponseStatusDetails {
+    type: ResponseStatus;
+}
+export declare function responseStatusDetailsDeserializer(item: any): ResponseStatusDetails;
+/** Alias for ResponseStatusDetailsUnion */
+export type ResponseStatusDetailsUnion = ResponseCancelledDetails | ResponseIncompleteDetails | ResponseFailedDetails | ResponseStatusDetails;
+export declare function responseStatusDetailsUnionDeserializer(item: any): ResponseStatusDetailsUnion;
+/** Details for a cancelled response. */
+export interface ResponseCancelledDetails extends ResponseStatusDetails {
+    type: "cancelled";
+    reason: string;
+}
+export declare function responseCancelledDetailsDeserializer(item: any): ResponseCancelledDetails;
+/** Details for an incomplete response. */
+export interface ResponseIncompleteDetails extends ResponseStatusDetails {
+    type: "incomplete";
+    reason: string;
+}
+export declare function responseIncompleteDetailsDeserializer(item: any): ResponseIncompleteDetails;
+/** Details for a failed response. */
+export interface ResponseFailedDetails extends ResponseStatusDetails {
+    type: "failed";
+    error: any;
+}
+export declare function responseFailedDetailsDeserializer(item: any): ResponseFailedDetails;
+export declare function responseItemUnionArrayDeserializer(result: Array<ResponseItemUnion>): any[];
+/** Base for any response item; discriminated by `type`. */
+export interface ResponseItem {
+    type: ItemType;
+    id?: string;
+    object?: "realtime.item";
+}
+export declare function responseItemDeserializer(item: any): ResponseItem;
+/** Alias for ResponseItemUnion */
+export type ResponseItemUnion = ResponseMessageItem | ResponseFunctionCallItem | ResponseFunctionCallOutputItem | ResponseItem;
+export declare function responseItemUnionDeserializer(item: any): ResponseItemUnion;
+/** Base type for message item within a conversation. */
+export interface ResponseMessageItem extends ResponseItem {
+    type: "message";
+    role: MessageRole;
+    content: ContentPartUnion[];
+    status: ResponseItemStatus;
+}
+export declare function responseMessageItemDeserializer(item: any): ResponseMessageItem;
+export declare function contentPartUnionArraySerializer(result: Array<ContentPartUnion>): any[];
+export declare function contentPartUnionArrayDeserializer(result: Array<ContentPartUnion>): any[];
+/** Base for any content part; discriminated by `type`. */
+export interface ContentPart {
+    type: ContentPartType;
+}
+export declare function contentPartSerializer(item: ContentPart): any;
+export declare function contentPartDeserializer(item: any): ContentPart;
+/** Alias for ContentPartUnion */
+export type ContentPartUnion = RequestTextContentPart | RequestAudioContentPart | ResponseTextContentPart | ResponseAudioContentPart | ContentPart;
+export declare function contentPartUnionSerializer(item: ContentPartUnion): any;
+export declare function contentPartUnionDeserializer(item: any): ContentPartUnion;
+/** A text content part for a request. */
+export interface RequestTextContentPart extends ContentPart {
+    type: "input_text";
+    text?: string;
+}
+export declare function requestTextContentPartSerializer(item: RequestTextContentPart): any;
+export declare function requestTextContentPartDeserializer(item: any): RequestTextContentPart;
+/** An audio content part for a request. */
+export interface RequestAudioContentPart extends ContentPart {
+    type: "input_audio";
+    transcript?: string;
+}
+export declare function requestAudioContentPartSerializer(item: RequestAudioContentPart): any;
+export declare function requestAudioContentPartDeserializer(item: any): RequestAudioContentPart;
+/** A text content part for a response. */
+export interface ResponseTextContentPart extends ContentPart {
+    type: "text";
+    text?: string;
+}
+export declare function responseTextContentPartDeserializer(item: any): ResponseTextContentPart;
+/** An audio content part for a response. */
+export interface ResponseAudioContentPart extends ContentPart {
+    type: "audio";
+    transcript?: string;
+}
+export declare function responseAudioContentPartDeserializer(item: any): ResponseAudioContentPart;
+/** Indicates the processing status of a response item. */
+export declare enum KnownResponseItemStatus {
+    /** Item that is in progress. */
+    InProgress = "in_progress",
+    /** Item has been fully processed and is complete. */
+    Completed = "completed",
+    /** Item has been processed but is incomplete. */
+    Incomplete = "incomplete"
+}
+/**
+ * Indicates the processing status of a response item. \
+ * {@link KnownResponseItemStatus} can be used interchangeably with ResponseItemStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **in_progress**: Item that is in progress. \
+ * **completed**: Item has been fully processed and is complete. \
+ * **incomplete**: Item has been processed but is incomplete.
+ */
+export type ResponseItemStatus = string;
+/** A function call item within a conversation. */
+export interface ResponseFunctionCallItem extends ResponseItem {
+    type: "function_call";
+    name: string;
+    callId: string;
+    arguments: string;
+    status: ResponseItemStatus;
+}
+export declare function responseFunctionCallItemDeserializer(item: any): ResponseFunctionCallItem;
+/** A function call output item within a conversation. */
+export interface ResponseFunctionCallOutputItem extends ResponseItem {
+    type: "function_call_output";
+    callId: string;
+    output: string;
+}
+export declare function responseFunctionCallOutputItemDeserializer(item: any): ResponseFunctionCallOutputItem;
+/** Overall usage statistics for a response. */
+export interface TokenUsage {
+    /** Total number of tokens (input + output). */
+    totalTokens: number;
+    /** Number of input tokens. */
+    inputTokens: number;
+    /** Number of output tokens. */
+    outputTokens: number;
+    /** Detailed breakdown of input tokens. */
+    inputTokenDetails: InputTokenDetails;
+    /** Detailed breakdown of output tokens. */
+    outputTokenDetails: OutputTokenDetails;
+}
+export declare function tokenUsageDeserializer(item: any): TokenUsage;
+/** Details of input token usage. */
+export interface InputTokenDetails {
+    /** Number of cached tokens used in the input. */
+    cachedTokens: number;
+    /** Number of text tokens used in the input. */
+    textTokens: number;
+    /** Number of audio tokens used in the input. */
+    audioTokens: number;
+    /** Details of cached token usage. */
+    cachedTokensDetails: CachedTokenDetails;
+}
+export declare function inputTokenDetailsDeserializer(item: any): InputTokenDetails;
+/** Details of output token usage. */
+export interface CachedTokenDetails {
+    /** Number of cached text tokens. */
+    textTokens: number;
+    /** Number of cached audio tokens. */
+    audioTokens: number;
+}
+export declare function cachedTokenDetailsDeserializer(item: any): CachedTokenDetails;
+/** Details of output token usage. */
+export interface OutputTokenDetails {
+    /** Number of text tokens generated in the output. */
+    textTokens: number;
+    /** Number of audio tokens generated in the output. */
+    audioTokens: number;
+}
+export declare function outputTokenDetailsDeserializer(item: any): OutputTokenDetails;
+/** Alias for _ResponseMaxOutputTokens */
+export type _ResponseMaxOutputTokens = number | "inf";
+export declare function _responseMaxOutputTokensDeserializer(item: any): _ResponseMaxOutputTokens;
+/** A voicelive server event. */
+export interface ServerEvent {
+    /** The type of event. */
+    /** The discriminator possible values: error, session.created, session.updated, session.avatar.connecting, input_audio_buffer.committed, input_audio_buffer.cleared, input_audio_buffer.speech_started, input_audio_buffer.speech_stopped, conversation.item.created, conversation.item.input_audio_transcription.completed, conversation.item.input_audio_transcription.failed, conversation.item.truncated, conversation.item.deleted, response.created, response.done, response.output_item.added, response.output_item.done, response.content_part.added, response.content_part.done, response.text.delta, response.text.done, response.audio_transcript.delta, response.audio_transcript.done, response.audio.delta, response.audio.done, response.animation_blendshapes.delta, response.animation_blendshapes.done, response.audio_timestamp.delta, response.audio_timestamp.done, response.animation_viseme.delta, response.animation_viseme.done, conversation.item.input_audio_transcription.delta, conversation.item.retrieved, response.function_call_arguments.delta, response.function_call_arguments.done */
+    type: ServerEventType;
+    eventId?: string;
+}
+export declare function serverEventDeserializer(item: any): ServerEvent;
+/** Alias for ServerEventUnion */
+export type ServerEventUnion = ServerEventError | ServerEventSessionCreated | ServerEventSessionUpdated | ServerEventSessionAvatarConnecting | ServerEventInputAudioBufferCommitted | ServerEventInputAudioBufferCleared | ServerEventInputAudioBufferSpeechStarted | ServerEventInputAudioBufferSpeechStopped | ServerEventConversationItemCreated | ServerEventConversationItemInputAudioTranscriptionCompleted | ServerEventConversationItemInputAudioTranscriptionFailed | ServerEventConversationItemTruncated | ServerEventConversationItemDeleted | ServerEventResponseCreated | ServerEventResponseDone | ServerEventResponseOutputItemAdded | ServerEventResponseOutputItemDone | ServerEventResponseContentPartAdded | ServerEventResponseContentPartDone | ServerEventResponseTextDelta | ServerEventResponseTextDone | ServerEventResponseAudioTranscriptDelta | ServerEventResponseAudioTranscriptDone | ServerEventResponseAudioDelta | ServerEventResponseAudioDone | ServerEventResponseAnimationBlendshapeDelta | ServerEventResponseAnimationBlendshapeDone | ServerEventResponseAudioTimestampDelta | ServerEventResponseAudioTimestampDone | ServerEventResponseAnimationVisemeDelta | ServerEventResponseAnimationVisemeDone | ServerEventConversationItemInputAudioTranscriptionDelta | ServerEventConversationItemRetrieved | ServerEventResponseFunctionCallArgumentsDelta | ServerEventResponseFunctionCallArgumentsDone | ServerEvent;
+export declare function serverEventUnionDeserializer(item: any): ServerEventUnion;
+/** Server event types used in VoiceLive protocol. */
+export declare enum KnownServerEventType {
+    /** error */
+    Error = "error",
+    /** session.avatar.connecting */
+    SessionAvatarConnecting = "session.avatar.connecting",
+    /** session.created */
+    SessionCreated = "session.created",
+    /** session.updated */
+    SessionUpdated = "session.updated",
+    /** conversation.item.input_audio_transcription.completed */
+    ConversationItemInputAudioTranscriptionCompleted = "conversation.item.input_audio_transcription.completed",
+    /** conversation.item.input_audio_transcription.delta */
+    ConversationItemInputAudioTranscriptionDelta = "conversation.item.input_audio_transcription.delta",
+    /** conversation.item.input_audio_transcription.failed */
+    ConversationItemInputAudioTranscriptionFailed = "conversation.item.input_audio_transcription.failed",
+    /** conversation.item.created */
+    ConversationItemCreated = "conversation.item.created",
+    /** conversation.item.retrieved */
+    ConversationItemRetrieved = "conversation.item.retrieved",
+    /** conversation.item.truncated */
+    ConversationItemTruncated = "conversation.item.truncated",
+    /** conversation.item.deleted */
+    ConversationItemDeleted = "conversation.item.deleted",
+    /** input_audio_buffer.committed */
+    InputAudioBufferCommitted = "input_audio_buffer.committed",
+    /** input_audio_buffer.cleared */
+    InputAudioBufferCleared = "input_audio_buffer.cleared",
+    /** input_audio_buffer.speech_started */
+    InputAudioBufferSpeechStarted = "input_audio_buffer.speech_started",
+    /** input_audio_buffer.speech_stopped */
+    InputAudioBufferSpeechStopped = "input_audio_buffer.speech_stopped",
+    /** response.created */
+    ResponseCreated = "response.created",
+    /** response.done */
+    ResponseDone = "response.done",
+    /** response.output_item.added */
+    ResponseOutputItemAdded = "response.output_item.added",
+    /** response.output_item.done */
+    ResponseOutputItemDone = "response.output_item.done",
+    /** response.content_part.added */
+    ResponseContentPartAdded = "response.content_part.added",
+    /** response.content_part.done */
+    ResponseContentPartDone = "response.content_part.done",
+    /** response.text.delta */
+    ResponseTextDelta = "response.text.delta",
+    /** response.text.done */
+    ResponseTextDone = "response.text.done",
+    /** response.audio_transcript.delta */
+    ResponseAudioTranscriptDelta = "response.audio_transcript.delta",
+    /** response.audio_transcript.done */
+    ResponseAudioTranscriptDone = "response.audio_transcript.done",
+    /** response.audio.delta */
+    ResponseAudioDelta = "response.audio.delta",
+    /** response.audio.done */
+    ResponseAudioDone = "response.audio.done",
+    /** response.animation_blendshapes.delta */
+    ResponseAnimationBlendshapesDelta = "response.animation_blendshapes.delta",
+    /** response.animation_blendshapes.done */
+    ResponseAnimationBlendshapesDone = "response.animation_blendshapes.done",
+    /** response.audio_timestamp.delta */
+    ResponseAudioTimestampDelta = "response.audio_timestamp.delta",
+    /** response.audio_timestamp.done */
+    ResponseAudioTimestampDone = "response.audio_timestamp.done",
+    /** response.animation_viseme.delta */
+    ResponseAnimationVisemeDelta = "response.animation_viseme.delta",
+    /** response.animation_viseme.done */
+    ResponseAnimationVisemeDone = "response.animation_viseme.done",
+    /** response.function_call_arguments.delta */
+    ResponseFunctionCallArgumentsDelta = "response.function_call_arguments.delta",
+    /** response.function_call_arguments.done */
+    ResponseFunctionCallArgumentsDone = "response.function_call_arguments.done"
+}
+/**
+ * Server event types used in VoiceLive protocol. \
+ * {@link KnownServerEventType} can be used interchangeably with ServerEventType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **error** \
+ * **session.avatar.connecting** \
+ * **session.created** \
+ * **session.updated** \
+ * **conversation.item.input_audio_transcription.completed** \
+ * **conversation.item.input_audio_transcription.delta** \
+ * **conversation.item.input_audio_transcription.failed** \
+ * **conversation.item.created** \
+ * **conversation.item.retrieved** \
+ * **conversation.item.truncated** \
+ * **conversation.item.deleted** \
+ * **input_audio_buffer.committed** \
+ * **input_audio_buffer.cleared** \
+ * **input_audio_buffer.speech_started** \
+ * **input_audio_buffer.speech_stopped** \
+ * **response.created** \
+ * **response.done** \
+ * **response.output_item.added** \
+ * **response.output_item.done** \
+ * **response.content_part.added** \
+ * **response.content_part.done** \
+ * **response.text.delta** \
+ * **response.text.done** \
+ * **response.audio_transcript.delta** \
+ * **response.audio_transcript.done** \
+ * **response.audio.delta** \
+ * **response.audio.done** \
+ * **response.animation_blendshapes.delta** \
+ * **response.animation_blendshapes.done** \
+ * **response.audio_timestamp.delta** \
+ * **response.audio_timestamp.done** \
+ * **response.animation_viseme.delta** \
+ * **response.animation_viseme.done** \
+ * **response.function_call_arguments.delta** \
+ * **response.function_call_arguments.done**
+ */
+export type ServerEventType = string;
+/**
+ * Returned when an error occurs, which could be a client problem or a server
+ * problem. Most errors are recoverable and the session will stay open, we
+ * recommend to implementors to monitor and log error messages by default.
+ */
+export interface ServerEventError extends ServerEvent {
+    /** The event type, must be `error`. */
+    type: "error";
+    /** Details of the error. */
+    error: ServerEventErrorDetails;
+}
+export declare function serverEventErrorDeserializer(item: any): ServerEventError;
+/** Details of the error. */
+export interface ServerEventErrorDetails {
+    /** The type of error (e.g., "invalid_request_error", "server_error"). */
+    type: string;
+    /** Error code, if any. */
+    code?: string;
+    /** A human-readable error message. */
+    message: string;
+    /** Parameter related to the error, if any. */
+    param?: string;
+    /** The event_id of the client event that caused the error, if applicable. */
+    eventId?: string;
+}
+export declare function serverEventErrorDetailsDeserializer(item: any): ServerEventErrorDetails;
+/**
+ * Returned when a Session is created. Emitted automatically when a new
+ * connection is established as the first server event. This event will contain
+ * the default Session configuration.
+ */
+export interface ServerEventSessionCreated extends ServerEvent {
+    /** The event type, must be `session.created`. */
+    type: "session.created";
+    session: ResponseSession;
+}
+export declare function serverEventSessionCreatedDeserializer(item: any): ServerEventSessionCreated;
+/** Base for session configuration in the response. */
+export interface ResponseSession {
+    /** The model for the session. */
+    model?: string;
+    /** The modalities to be used in the session. */
+    modalities?: Modality[];
+    /** The animation configuration for the session. */
+    animation?: Animation;
+    /** The voice configuration for the session. */
+    voice?: Voice;
+    /** Optional instructions to guide the model's behavior throughout the session. */
+    instructions?: string;
+    /**
+     * Input audio sampling rate in Hz. Available values:
+     *
+     * - For pcm16: 8000, 16000, 24000
+     *
+     * - For g711_alaw/g711_ulaw: 8000
+     */
+    inputAudioSamplingRate?: number;
+    /** Input audio format. Default is 'pcm16'. */
+    inputAudioFormat?: InputAudioFormat;
+    /** Output audio format. Default is 'pcm16'. */
+    outputAudioFormat?: OutputAudioFormat;
+    /** Type of turn detection to use. */
+    turnDetection?: TurnDetectionUnion;
+    /** Configuration for input audio noise reduction. */
+    inputAudioNoiseReduction?: AudioNoiseReduction;
+    /** Configuration for echo cancellation during server-side audio processing. */
+    inputAudioEchoCancellation?: AudioEchoCancellation;
+    /** Configuration for avatar streaming and behavior during the session. */
+    avatar?: AvatarConfig;
+    /** Configuration for input audio transcription. */
+    inputAudioTranscription?: AudioInputTranscriptionOptions;
+    /** Types of timestamps to include in audio response content. */
+    outputAudioTimestampTypes?: AudioTimestampType[];
+    /** Configuration for tools to be used during the session, if applicable. */
+    tools?: ToolUnion[];
+    /** Specifies which tools the model is allowed to call during the session. */
+    toolChoice?: ToolChoice;
+    /** Controls the randomness of the model's output. Range: 0.0 to 1.0. Default is 0.7. */
+    temperature?: number;
+    /** Maximum number of tokens to generate in the response. Default is unlimited. */
+    maxResponseOutputTokens?: number | "inf";
+    /** The agent configuration for the session, if applicable. */
+    agent?: AgentConfig;
+    /** The unique identifier for the session. */
+    id?: string;
+}
+export declare function responseSessionSerializer(item: ResponseSession): any;
+export declare function responseSessionDeserializer(item: any): ResponseSession;
+/** Configuration for the agent. */
+export interface AgentConfig {
+    /** The type of agent to use. */
+    type: "agent";
+    /** The name of the agent. */
+    name: string;
+    /** Optional description of the agent. */
+    description?: string;
+    /** The ID of the agent. */
+    agentId: string;
+    /** The ID of the conversation thread. */
+    threadId: string;
+}
+export declare function agentConfigSerializer(item: AgentConfig): any;
+export declare function agentConfigDeserializer(item: any): AgentConfig;
+/**
+ * Returned when a session is updated with a `session.update` event, unless
+ * there is an error.
+ */
+export interface ServerEventSessionUpdated extends ServerEvent {
+    /** The event type, must be `session.updated`. */
+    type: "session.updated";
+    session: ResponseSession;
+}
+export declare function serverEventSessionUpdatedDeserializer(item: any): ServerEventSessionUpdated;
+/** Sent when the server is in the process of establishing an avatar media connection and provides its SDP answer. */
+export interface ServerEventSessionAvatarConnecting extends ServerEvent {
+    /** The event type, must be 'session.avatar.connecting'. */
+    type: "session.avatar.connecting";
+    /** The server's SDP answer for the avatar connection. */
+    serverSdp: string;
+}
+export declare function serverEventSessionAvatarConnectingDeserializer(item: any): ServerEventSessionAvatarConnecting;
+/**
+ * Returned when an input audio buffer is committed, either by the client or
+ * automatically in server VAD mode. The `item_id` property is the ID of the user
+ * message item that will be created, thus a `conversation.item.created` event
+ * will also be sent to the client.
+ */
+export interface ServerEventInputAudioBufferCommitted extends ServerEvent {
+    /** The event type, must be `input_audio_buffer.committed`. */
+    type: "input_audio_buffer.committed";
+    /** The ID of the preceding item after which the new item will be inserted. */
+    previousItemId?: string;
+    /** The ID of the user message item that will be created. */
+    itemId: string;
+}
+export declare function serverEventInputAudioBufferCommittedDeserializer(item: any): ServerEventInputAudioBufferCommitted;
+/**
+ * Returned when the input audio buffer is cleared by the client with a
+ * `input_audio_buffer.clear` event.
+ */
+export interface ServerEventInputAudioBufferCleared extends ServerEvent {
+    /** The event type, must be `input_audio_buffer.cleared`. */
+    type: "input_audio_buffer.cleared";
+}
+export declare function serverEventInputAudioBufferClearedDeserializer(item: any): ServerEventInputAudioBufferCleared;
+/**
+ * Sent by the server when in `server_vad` mode to indicate that speech has been
+ * detected in the audio buffer. This can happen any time audio is added to the
+ * buffer (unless speech is already detected). The client may want to use this
+ * event to interrupt audio playback or provide visual feedback to the user.
+ * The client should expect to receive a `input_audio_buffer.speech_stopped` event
+ * when speech stops. The `item_id` property is the ID of the user message item
+ * that will be created when speech stops and will also be included in the
+ * `input_audio_buffer.speech_stopped` event (unless the client manually commits
+ * the audio buffer during VAD activation).
+ */
+export interface ServerEventInputAudioBufferSpeechStarted extends ServerEvent {
+    /** The event type, must be `input_audio_buffer.speech_started`. */
+    type: "input_audio_buffer.speech_started";
+    /**
+     * Milliseconds from the start of all audio written to the buffer during the
+     * session when speech was first detected. This will correspond to the
+     * beginning of audio sent to the model, and thus includes the
+     * `prefix_padding_ms` configured in the Session.
+     */
+    audioStartInMs: number;
+    /** The ID of the user message item that will be created when speech stops. */
+    itemId: string;
+}
+export declare function serverEventInputAudioBufferSpeechStartedDeserializer(item: any): ServerEventInputAudioBufferSpeechStarted;
+/**
+ * Returned in `server_vad` mode when the server detects the end of speech in
+ * the audio buffer. The server will also send an `conversation.item.created`
+ * event with the user message item that is created from the audio buffer.
+ */
+export interface ServerEventInputAudioBufferSpeechStopped extends ServerEvent {
+    /** The event type, must be `input_audio_buffer.speech_stopped`. */
+    type: "input_audio_buffer.speech_stopped";
+    /**
+     * Milliseconds since the session started when speech stopped. This will
+     * correspond to the end of audio sent to the model, and thus includes the
+     * `min_silence_duration_ms` configured in the Session.
+     */
+    audioEndInMs: number;
+    /** The ID of the user message item that will be created. */
+    itemId: string;
+}
+export declare function serverEventInputAudioBufferSpeechStoppedDeserializer(item: any): ServerEventInputAudioBufferSpeechStopped;
+/**
+ * Returned when a conversation item is created. There are several scenarios that produce this event:
+ * - The server is generating a Response, which if successful will produce
+ * either one or two Items, which will be of type `message`
+ * (role `assistant`) or type `function_call`.
+ * - The input audio buffer has been committed, either by the client or the
+ * server (in `server_vad` mode). The server will take the content of the
+ * input audio buffer and add it to a new user message Item.
+ * - The client has sent a `conversation.item.create` event to add a new Item
+ * to the Conversation.
+ */
+export interface ServerEventConversationItemCreated extends ServerEvent {
+    /** The event type, must be `conversation.item.created`. */
+    type: "conversation.item.created";
+    /**
+     * The ID of the preceding item in the Conversation context, allows the
+     * client to understand the order of the conversation.
+     */
+    previousItemId?: string;
+    item?: ResponseItemUnion;
+}
+export declare function serverEventConversationItemCreatedDeserializer(item: any): ServerEventConversationItemCreated;
+/**
+ * This event is the output of audio transcription for user audio written to the
+ * user audio buffer. Transcription begins when the input audio buffer is
+ * committed by the client or server (in `server_vad` mode). Transcription runs
+ * asynchronously with Response creation, so this event may come before or after
+ * the Response events.
+ * VoiceLive API models accept audio natively, and thus input transcription is a
+ * separate process run on a separate ASR (Automatic Speech Recognition) model.
+ * The transcript may diverge somewhat from the model's interpretation, and
+ * should be treated as a rough guide.
+ */
+export interface ServerEventConversationItemInputAudioTranscriptionCompleted extends ServerEvent {
+    /**
+     * The event type, must be
+     * `conversation.item.input_audio_transcription.completed`.
+     */
+    type: "conversation.item.input_audio_transcription.completed";
+    /** The ID of the user message item containing the audio. */
+    itemId: string;
+    /** The index of the content part containing the audio. */
+    contentIndex: number;
+    /** The transcribed text. */
+    transcript: string;
+}
+export declare function serverEventConversationItemInputAudioTranscriptionCompletedDeserializer(item: any): ServerEventConversationItemInputAudioTranscriptionCompleted;
+/**
+ * Returned when input audio transcription is configured, and a transcription
+ * request for a user message failed. These events are separate from other
+ * `error` events so that the client can identify the related Item.
+ */
+export interface ServerEventConversationItemInputAudioTranscriptionFailed extends ServerEvent {
+    /**
+     * The event type, must be
+     * `conversation.item.input_audio_transcription.failed`.
+     */
+    type: "conversation.item.input_audio_transcription.failed";
+    /** The ID of the user message item. */
+    itemId: string;
+    /** The index of the content part containing the audio. */
+    contentIndex: number;
+    /** Details of the transcription error. */
+    error: VoiceLiveErrorDetails;
+}
+export declare function serverEventConversationItemInputAudioTranscriptionFailedDeserializer(item: any): ServerEventConversationItemInputAudioTranscriptionFailed;
+/**
+ * Returned when an earlier assistant audio message item is truncated by the
+ * client with a `conversation.item.truncate` event. This event is used to
+ * synchronize the server's understanding of the audio with the client's playback.
+ * This action will truncate the audio and remove the server-side text transcript
+ * to ensure there is no text in the context that hasn't been heard by the user.
+ */
+export interface ServerEventConversationItemTruncated extends ServerEvent {
+    /** The event type, must be `conversation.item.truncated`. */
+    type: "conversation.item.truncated";
+    /** The ID of the assistant message item that was truncated. */
+    itemId: string;
+    /** The index of the content part that was truncated. */
+    contentIndex: number;
+    /** The duration up to which the audio was truncated, in milliseconds. */
+    audioEndInMs: number;
+    eventId?: string;
+}
+export declare function serverEventConversationItemTruncatedDeserializer(item: any): ServerEventConversationItemTruncated;
+/**
+ * Returned when an item in the conversation is deleted by the client with a
+ * `conversation.item.delete` event. This event is used to synchronize the
+ * server's understanding of the conversation history with the client's view.
+ */
+export interface ServerEventConversationItemDeleted extends ServerEvent {
+    /** The event type, must be `conversation.item.deleted`. */
+    type: "conversation.item.deleted";
+    /** The ID of the item that was deleted. */
+    itemId: string;
+    eventId?: string;
+}
+export declare function serverEventConversationItemDeletedDeserializer(item: any): ServerEventConversationItemDeleted;
+/**
+ * Returned when a new Response is created. The first event of response creation,
+ * where the response is in an initial state of `in_progress`.
+ */
+export interface ServerEventResponseCreated extends ServerEvent {
+    /** The event type, must be `response.created`. */
+    type: "response.created";
+    response: Response;
+}
+export declare function serverEventResponseCreatedDeserializer(item: any): ServerEventResponseCreated;
+/**
+ * Returned when a Response is done streaming. Always emitted, no matter the
+ * final state. The Response object included in the `response.done` event will
+ * include all output Items in the Response but will omit the raw audio data.
+ */
+export interface ServerEventResponseDone extends ServerEvent {
+    /** The event type, must be `response.done`. */
+    type: "response.done";
+    response: Response;
+}
+export declare function serverEventResponseDoneDeserializer(item: any): ServerEventResponseDone;
+/** Returned when a new Item is created during Response generation. */
+export interface ServerEventResponseOutputItemAdded extends ServerEvent {
+    /** The event type, must be `response.output_item.added`. */
+    type: "response.output_item.added";
+    /** The ID of the Response to which the item belongs. */
+    responseId: string;
+    /** The index of the output item in the Response. */
+    outputIndex: number;
+    item?: ResponseItemUnion;
+}
+export declare function serverEventResponseOutputItemAddedDeserializer(item: any): ServerEventResponseOutputItemAdded;
+/**
+ * Returned when an Item is done streaming. Also emitted when a Response is
+ * interrupted, incomplete, or cancelled.
+ */
+export interface ServerEventResponseOutputItemDone extends ServerEvent {
+    /** The event type, must be `response.output_item.done`. */
+    type: "response.output_item.done";
+    /** The ID of the Response to which the item belongs. */
+    responseId: string;
+    /** The index of the output item in the Response. */
+    outputIndex: number;
+    item?: ResponseItemUnion;
+}
+export declare function serverEventResponseOutputItemDoneDeserializer(item: any): ServerEventResponseOutputItemDone;
+/**
+ * Returned when a new content part is added to an assistant message item during
+ * response generation.
+ */
+export interface ServerEventResponseContentPartAdded extends ServerEvent {
+    /** The event type, must be `response.content_part.added`. */
+    type: "response.content_part.added";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item to which the content part was added. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+    /** The content part that was added. */
+    part: ContentPartUnion;
+}
+export declare function serverEventResponseContentPartAddedDeserializer(item: any): ServerEventResponseContentPartAdded;
+/**
+ * Returned when a content part is done streaming in an assistant message item.
+ * Also emitted when a Response is interrupted, incomplete, or cancelled.
+ */
+export interface ServerEventResponseContentPartDone extends ServerEvent {
+    /** The event type, must be `response.content_part.done`. */
+    type: "response.content_part.done";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+    /** The content part that is done. */
+    part: ContentPartUnion;
+}
+export declare function serverEventResponseContentPartDoneDeserializer(item: any): ServerEventResponseContentPartDone;
+/** Returned when the text value of a "text" content part is updated. */
+export interface ServerEventResponseTextDelta extends ServerEvent {
+    /** The event type, must be `response.text.delta`. */
+    type: "response.text.delta";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+    /** The text delta. */
+    delta: string;
+}
+export declare function serverEventResponseTextDeltaDeserializer(item: any): ServerEventResponseTextDelta;
+/**
+ * Returned when the text value of a "text" content part is done streaming. Also
+ * emitted when a Response is interrupted, incomplete, or cancelled.
+ */
+export interface ServerEventResponseTextDone extends ServerEvent {
+    /** The event type, must be `response.text.done`. */
+    type: "response.text.done";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+    /** The final text content. */
+    text: string;
+}
+export declare function serverEventResponseTextDoneDeserializer(item: any): ServerEventResponseTextDone;
+/** Returned when the model-generated transcription of audio output is updated. */
+export interface ServerEventResponseAudioTranscriptDelta extends ServerEvent {
+    /** The event type, must be `response.audio_transcript.delta`. */
+    type: "response.audio_transcript.delta";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+    /** The transcript delta. */
+    delta: string;
+}
+export declare function serverEventResponseAudioTranscriptDeltaDeserializer(item: any): ServerEventResponseAudioTranscriptDelta;
+/**
+ * Returned when the model-generated transcription of audio output is done
+ * streaming. Also emitted when a Response is interrupted, incomplete, or
+ * cancelled.
+ */
+export interface ServerEventResponseAudioTranscriptDone extends ServerEvent {
+    /** The event type, must be `response.audio_transcript.done`. */
+    type: "response.audio_transcript.done";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+    /** The final transcript of the audio. */
+    transcript: string;
+}
+export declare function serverEventResponseAudioTranscriptDoneDeserializer(item: any): ServerEventResponseAudioTranscriptDone;
+/** Returned when the model-generated audio is updated. */
+export interface ServerEventResponseAudioDelta extends ServerEvent {
+    /** The event type, must be `response.audio.delta`. */
+    type: "response.audio.delta";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+    /** Base64-encoded audio data delta. */
+    delta: Uint8Array;
+}
+export declare function serverEventResponseAudioDeltaDeserializer(item: any): ServerEventResponseAudioDelta;
+/**
+ * Returned when the model-generated audio is done. Also emitted when a Response
+ * is interrupted, incomplete, or cancelled.
+ */
+export interface ServerEventResponseAudioDone extends ServerEvent {
+    /** The event type, must be `response.audio.done`. */
+    type: "response.audio.done";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The index of the content part in the item's content array. */
+    contentIndex: number;
+}
+export declare function serverEventResponseAudioDoneDeserializer(item: any): ServerEventResponseAudioDone;
+/** Represents a delta update of blendshape animation frames for a specific output of a response. */
+export interface ServerEventResponseAnimationBlendshapeDelta extends ServerEvent {
+    type: "response.animation_blendshapes.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    frames: number[][] | string;
+    frameIndex: number;
+}
+export declare function serverEventResponseAnimationBlendshapeDeltaDeserializer(item: any): ServerEventResponseAnimationBlendshapeDelta;
+/** Alias for _ServerEventResponseAnimationBlendshapeDeltaFrames */
+export type _ServerEventResponseAnimationBlendshapeDeltaFrames = number[][] | string;
+export declare function _serverEventResponseAnimationBlendshapeDeltaFramesDeserializer(item: any): _ServerEventResponseAnimationBlendshapeDeltaFrames;
+/** Indicates the completion of blendshape animation processing for a specific output of a response. */
+export interface ServerEventResponseAnimationBlendshapeDone extends ServerEvent {
+    type: "response.animation_blendshapes.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+}
+export declare function serverEventResponseAnimationBlendshapeDoneDeserializer(item: any): ServerEventResponseAnimationBlendshapeDone;
+/** Represents a word-level audio timestamp delta for a response. */
+export interface ServerEventResponseAudioTimestampDelta extends ServerEvent {
+    type: "response.audio_timestamp.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    audioOffsetInMs: number;
+    audioDurationInMs: number;
+    text: string;
+    timestampType: "word";
+}
+export declare function serverEventResponseAudioTimestampDeltaDeserializer(item: any): ServerEventResponseAudioTimestampDelta;
+/** Indicates completion of audio timestamp delivery for a response. */
+export interface ServerEventResponseAudioTimestampDone extends ServerEvent {
+    type: "response.audio_timestamp.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+}
+export declare function serverEventResponseAudioTimestampDoneDeserializer(item: any): ServerEventResponseAudioTimestampDone;
+/** Represents a viseme ID delta update for animation based on audio. */
+export interface ServerEventResponseAnimationVisemeDelta extends ServerEvent {
+    type: "response.animation_viseme.delta";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+    audioOffsetInMs: number;
+    visemeId: number;
+}
+export declare function serverEventResponseAnimationVisemeDeltaDeserializer(item: any): ServerEventResponseAnimationVisemeDelta;
+/** Indicates completion of viseme animation delivery for a response. */
+export interface ServerEventResponseAnimationVisemeDone extends ServerEvent {
+    type: "response.animation_viseme.done";
+    responseId: string;
+    itemId: string;
+    outputIndex: number;
+    contentIndex: number;
+}
+export declare function serverEventResponseAnimationVisemeDoneDeserializer(item: any): ServerEventResponseAnimationVisemeDone;
+/** Returned when the text value of an input audio transcription content part is updated. */
+export interface ServerEventConversationItemInputAudioTranscriptionDelta extends ServerEvent {
+    /** The event type, must be `conversation.item.input_audio_transcription.delta`. */
+    type: "conversation.item.input_audio_transcription.delta";
+    /** The ID of the item. */
+    itemId: string;
+    /** The index of the content part in the item's content array. */
+    contentIndex?: number;
+    /** The text delta. */
+    delta?: string;
+    /** The log probabilities of the transcription. */
+    logprobs?: LogProbProperties[];
+}
+export declare function serverEventConversationItemInputAudioTranscriptionDeltaDeserializer(item: any): ServerEventConversationItemInputAudioTranscriptionDelta;
+export declare function logProbPropertiesArrayDeserializer(result: Array<LogProbProperties>): any[];
+/** Returned when a conversation item is retrieved with `conversation.item.retrieve`. */
+export interface ServerEventConversationItemRetrieved extends ServerEvent {
+    /** The event type, must be `conversation.item.retrieved`. */
+    type: "conversation.item.retrieved";
+    item?: ResponseItemUnion;
+    eventId?: string;
+}
+export declare function serverEventConversationItemRetrievedDeserializer(item: any): ServerEventConversationItemRetrieved;
+/** Returned when the model-generated function call arguments are updated. */
+export interface ServerEventResponseFunctionCallArgumentsDelta extends ServerEvent {
+    /** The event type, must be `response.function_call_arguments.delta`. */
+    type: "response.function_call_arguments.delta";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the function call item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The ID of the function call. */
+    callId: string;
+    /** The arguments delta as a JSON string. */
+    delta: string;
+}
+export declare function serverEventResponseFunctionCallArgumentsDeltaDeserializer(item: any): ServerEventResponseFunctionCallArgumentsDelta;
+/**
+ * Returned when the model-generated function call arguments are done streaming.
+ * Also emitted when a Response is interrupted, incomplete, or cancelled.
+ */
+export interface ServerEventResponseFunctionCallArgumentsDone extends ServerEvent {
+    /** The event type, must be `response.function_call_arguments.done`. */
+    type: "response.function_call_arguments.done";
+    /** The ID of the response. */
+    responseId: string;
+    /** The ID of the function call item. */
+    itemId: string;
+    /** The index of the output item in the response. */
+    outputIndex: number;
+    /** The ID of the function call. */
+    callId: string;
+    /** The final arguments as a JSON string. */
+    arguments: string;
+    /** The name of the function call. */
+    name: string;
+}
+export declare function serverEventResponseFunctionCallArgumentsDoneDeserializer(item: any): ServerEventResponseFunctionCallArgumentsDone;
+//# sourceMappingURL=models.d.ts.map