@wildix/wilma-voice-client 0.0.51 → 0.0.52

package/dist-types/models/models_0.d.ts

@@ -1,5 +1,5 @@
 import type { DocumentType as __DocumentType, StreamingBlobTypes } from "@smithy/types";
-import type { MediaAudioBeginFrameType, MediaAudioEncoding, MediaAudioEndFrameType, MediaDtmfFrameType, MediaDuckFrameType, MediaErrorFrameType, MediaFinishedFrameType, MediaFinishFrameType, MediaFinishReason, MediaHangupFrameType, MediaLanguageFrameType, MediaParty, MediaPlaybackEvent, MediaPlaybackFrameType, MediaPlaybackStopCause, MediaRestoreFrameType, MediaRunPurpose, MediaStartedFrameType, MediaStartFrameType, MediaStopFrameType, MediaTranscriptionFrameType, MediaTransferFrameType, MediaVadFrameType, VoiceAudioEncoding, VoiceCallEndReason, VoiceCallToolPhase, VoiceCommandType, VoiceControlAction, VoiceEventType, VoiceInputMode, VoicePronunciationEncoding, VoiceTranscriptionDropReason } from "./enums";
+import type { VoiceCallClientEndReason, VoiceCallClientFrameType, VoiceCallEndReason, VoiceCallParty, VoiceCallPlaybackPhase, VoiceCallServerFrameType, VoiceCommandType, VoiceEventType, VoiceInputMode, VoicePronunciationEncoding, VoiceToolPhase, VoiceTranscriptionDropReason } from "./enums";
 /**
  * A pronunciation rule for one phrase. Belongs to a LANGUAGE, not to the agent: 'Wildix' is
  *     respelled differently for an Italian and a German voice, so one list shared ACROSS languages
@@ -25,387 +25,724 @@ export interface VoicePronunciation {
     encoding?: VoicePronunciationEncoding | undefined;
 }
 /**
- * A recogniser result for the agent's own leg — what the caller hears. Sent by the PBX for new-stack agents only, from the same dual-channel stream that transcribes the caller. Never starts a turn.
+ * Caller voice detection on the PBX.
  * @public
  */
-export interface AgentTranscriptionEvent {
+export interface VoiceDetectionSettings {
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * Silence in ms that ends the caller speech. Absent: 500.
+     * @public
+     */
+    silenceMs?: number | undefined;
+    /**
+     * Mean frame level in dBFS below which caller audio is silence. Absent: -36.
+     * @public
+     */
+    silenceLevelDb?: number | undefined;
+    /**
+     * Mean frame level in dBFS from which caller audio is speech. Absent: -30.
+     * @public
+     */
+    speechLevelDb?: number | undefined;
+}
+/**
+ * A transcription chunk of the agent speech, as the caller hears it. It does not start a turn.
+ * @public
+ */
+export interface VoiceAgentTranscriptionEvent {
+    /**
+     * Value of `type` in the `event` of an event frame.
      * @public
      */
     type: VoiceEventType;
     /**
-     * Identifier of a transcription chunk within a session.
+     * Id of the utterance. Absent: the service makes a new id.
+     * @public
+     */
+    id?: string | undefined;
+    /**
+     * Text of the chunk. Must not be empty.
      * @public
      */
-    id: string;
     text: string;
     /**
-     * Transcription confidence score (accuracy level) in range from 0.0 to 1.0. Value -1.0 indicates confidence is unavailable.
+     * Confidence of the recogniser. The service does not record it.
      * @public
      */
     confidence?: number | undefined;
     /**
-     * True when this is the final transcript for the utterance rather than an interim hypothesis. An absent value is read as final, as on `TranscriptionEvent`.
+     * True when the chunk is the final transcript of the utterance. False for an interim result. Absent: true.
      * @public
      */
     final?: boolean | undefined;
     /**
-     * Language the recogniser identified for this chunk. Recorded in the trace only — it drives no behavior.
+     * Language that the recogniser identified for the chunk. The service records it and does not change the conversation language.
      * @public
      */
     language?: string | undefined;
-    time: number;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface AgentTranscriptionWebsocketEvent {
-    type: string;
     /**
-     * A recogniser result for the agent's own leg — what the caller hears. Sent by the PBX for new-stack agents only, from the same dual-channel stream that transcribes the caller. Never starts a turn.
+     * Time of the chunk, in epoch ms. Absent: the time when the service received it.
      * @public
      */
-    event: AgentTranscriptionEvent;
+    time?: number | undefined;
 }
 /**
- * A chunk of raw caller audio, base64-encoded in the session's negotiated input format
- *     (inputAudio from the connect handshake). Used by web/app clients in AUDIO input mode; the
- *     service buffers and transcribes it server-side. Not used in TRANSCRIPTION mode.
+ * The call or the conversation is complete, for example because the caller hung up. The service ends the session. The service also accepts `type` `ended` with the same meaning.
  * @public
  */
-export interface AudioEvent {
+export interface VoiceCompleteEvent {
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * Value of `type` in the `event` of an event frame.
      * @public
      */
     type: VoiceEventType;
-    data: string;
     /**
-     * Optional monotonic chunk sequence number, for gap detection.
+     * Why the call is complete. Absent: the value of `type`.
      * @public
      */
-    seq?: number | undefined;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface AudioWebsocketEvent {
-    type: string;
+    reason?: string | undefined;
     /**
-     * A chunk of raw caller audio, base64-encoded in the session's negotiated input format
-     *     (inputAudio from the connect handshake). Used by web/app clients in AUDIO input mode; the
-     *     service buffers and transcribes it server-side. Not used in TRANSCRIPTION mode.
+     * Time of the completion, in epoch ms. The service ignores it.
      * @public
      */
-    event: AudioEvent;
+    time?: number | undefined;
 }
 /**
- * The call/conversation completed (e.g. the caller hung up or the call was transferred away).
+ * End the session and hang up the call.
  * @public
  */
-export interface CompleteEvent {
+export interface VoiceHangupCommandData {
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * Why the session ended.
      * @public
      */
-    type: VoiceEventType;
-    reason: string;
-    time: number;
+    reason?: string | undefined;
+    /**
+     * Value of `type` in the `command` of a command frame.
+     * @public
+     */
+    type: VoiceCommandType;
 }
 /**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+ * Keepalive frame from the client: `\{"type": "healthcheck"\}`. The service sends no answer.
  * @public
  */
-export interface CompleteWebsocketEvent {
+export interface VoiceHealthcheckWebsocketFrame {
     type: string;
-    /**
-     * The call/conversation completed (e.g. the caller hung up or the call was transferred away).
-     * @public
-     */
-    event: CompleteEvent;
 }
 /**
- * A lightweight control frame from the client (AUDIO mode).
+ * The caller spoke over a reply while the client played it.
  * @public
  */
-export interface ControlEvent {
+export interface VoiceInterruptionEvent {
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * Value of `type` in the `event` of an event frame.
      * @public
      */
     type: VoiceEventType;
     /**
-     * A client control action on the audio input (AUDIO mode).
+     * Reply that the caller interrupted.
      * @public
      */
-    action: VoiceControlAction;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface ControlWebsocketEvent {
-    type: string;
+    replyId?: string | undefined;
     /**
-     * A lightweight control frame from the client (AUDIO mode).
+     * Part of the reply that the client played before the interruption.
      * @public
      */
-    event: ControlEvent;
-}
-/**
- * @public
- */
-export interface DescribeVoiceProtocolInput {
-}
-/**
- * A recogniser result for the AGENT's own leg — what the caller actually heard. Same semantics as VoiceCallTranscriptionEvent; an interrupted reply simply stops.
- * @public
- */
-export interface VoiceCallAgentTranscriptionEvent {
+    playedText?: string | undefined;
     /**
-     * Identifier of a transcription chunk within a session.
+     * Full text of the reply.
      * @public
      */
-    id: string;
-    text: string;
-    final: boolean;
+    originalText?: string | undefined;
     /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
-     *     when the model was released.
+     * Time of the interruption, in epoch ms on the client clock. The service ignores 0.
      * @public
      */
-    language?: string | undefined;
     time?: number | undefined;
 }
 /**
- * The session ended. After `transfer` another session of the same call may follow with its own `started`.
+ * Progress of the playback of a reply on the client.
  * @public
  */
-export interface VoiceCallEndedEvent {
+export interface VoicePlaybackEvent {
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Value of `type` in the `event` of an event frame.
      * @public
      */
-    sessionId: string;
-    reason: VoiceCallEndReason;
-}
-/**
- * The caller talked over the agent. `playedText` is what they heard before the cut.
- * @public
- */
-export interface VoiceCallInterruptionEvent {
+    type: VoiceEventType;
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Reply that the client plays.
      * @public
      */
     replyId?: string | undefined;
-    playedText?: string | undefined;
-    originalText?: string | undefined;
-}
-/**
- * The conversation language changed on a recognised utterance.
- * @public
- */
-export interface VoiceCallLanguageEvent {
     /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
-     *     when the model was released.
+     * Text of the reply that the client played.
      * @public
      */
-    from?: string | undefined;
+    text?: string | undefined;
     /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
-     *     when the model was released.
+     * True when the client played the reply to its end.
      * @public
      */
-    to: string;
-    reason: string;
-}
-/**
- * The PBX finished (or abandoned) playing a reply.
- * @public
- */
-export interface VoiceCallPlaybackEvent {
+    complete: boolean;
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Start of the playback, in epoch ms on the client clock. The service ignores 0.
      * @public
      */
-    replyId: string;
-    complete: boolean;
+    startTime?: number | undefined;
+    /**
+     * End of the playback, in epoch ms on the client clock. The service ignores 0.
+     * @public
+     */
+    endTime?: number | undefined;
 }
 /**
- * The caller's completed utterance that started a turn — after the runtime's filler and duplicate filter.
+ * A final caller utterance. It starts an agent turn.
  * @public
  */
-export interface VoiceCallReplyEvent {
+export interface VoiceReplyEvent {
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Value of `type` in the `event` of an event frame.
+     * @public
+     */
+    type: VoiceEventType;
+    /**
+     * Id of the utterance. Absent: the service makes a new id.
+     * @public
+     */
+    id?: string | undefined;
+    /**
+     * Text of the utterance. Must not be empty.
      * @public
      */
-    id: string;
     text: string;
     /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
-     *     when the model was released.
+     * Time of the utterance, in epoch ms. Absent: the time when the service received it.
+     * @public
+     */
+    time?: number | undefined;
+    /**
+     * Language that the recogniser identified for the utterance. A value that is different from the conversation language changes the conversation language. When the utterance has segments in more than one language, send the language of the last segment.
      * @public
      */
     language?: string | undefined;
-}
-/**
- * One sentence the agent speaks, as it is handed to the PBX (after playback sanitizing). Sentences of one reply share `replyId`.
- * @public
- */
-export interface VoiceCallSayEvent {
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Confidence of the recogniser for the utterance. The service ignores a value outside 0 to 1.
      * @public
      */
-    replyId: string;
-    text: string;
-    interruptible: boolean;
+    confidence?: number | undefined;
+    /**
+     * Start of the speech, in epoch ms on the client clock. The service ignores 0.
+     * @public
+     */
+    startTime?: number | undefined;
+    /**
+     * End of the speech, in epoch ms on the client clock. The service ignores 0.
+     * @public
+     */
+    endTime?: number | undefined;
 }
 /**
- * The session that answered the call, sent once per session of the call (a transfer starts another).
+ * A transcription chunk of caller speech. A client that does its own speech-to-text sends it. When the service does the speech-to-text, the service sends it to the client.
  * @public
  */
-export interface VoiceCallStartedEvent {
+export interface VoiceTranscriptionEvent {
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Value of `type` in the `event` of an event frame.
      * @public
      */
-    sessionId: string;
+    type: VoiceEventType;
     /**
-     * The session's trace, for the LLM-level detail this stream deliberately omits. Absent for a built-in agent, whose trace is not the tenant's to read.
+     * Id of the utterance. The interim chunks and the final chunk of one utterance have the same id. Absent: the service makes a new id.
      * @public
      */
-    traceId?: string | undefined;
-    agentId: string;
-    agentName?: string | undefined;
+    id?: string | undefined;
     /**
-     * Published agent version number. Monotonic within an agent's version history, starting at 1.
+     * Text of the chunk. Must not be empty.
      * @public
      */
-    agentVersion?: number | undefined;
+    text: string;
     /**
-     * True when the session runs the agent's draft.
+     * Confidence of the recogniser. The service ignores a value outside 0 to 1.
      * @public
      */
-    agentDraft?: boolean | undefined;
+    confidence?: number | undefined;
     /**
-     * BCP-47 language the call started in.
+     * True when the chunk is the final transcript of the utterance. False for an interim result. Absent: true.
+     * @public
+     */
+    final?: boolean | undefined;
+    /**
+     * Language that the recogniser identified for the chunk. The service records it and does not change the conversation language.
      * @public
      */
     language?: string | undefined;
+    /**
+     * Time of the chunk, in epoch ms. Absent: the time when the service received it.
+     * @public
+     */
+    time?: number | undefined;
 }
 /**
- * A tool call the agent made during a turn. Name and phase only — arguments and results live in the trace. Sent to a caller signed in to the system; never to a guest.
+ * The session ended. This is the last event of the session.
  * @public
  */
-export interface VoiceCallToolEvent {
+export interface VoiceSessionEndedEvent {
     /**
-     * Identifies the tool call inside the turn — the model's own call id, not the PBX call this stream follows.
+     * Value of `type` in the `event` of an event frame.
      * @public
      */
-    toolCallId: string;
-    toolName: string;
-    phase: VoiceCallToolPhase;
+    type: VoiceEventType;
     /**
-     * The phrase spoken while the tool runs, when the capability configures one.
+     * Why the session ended.
      * @public
      */
-    startMessage?: string | undefined;
+    reason?: string | undefined;
+    /**
+     * Present when the session ended because of an error.
+     * @public
+     */
+    error?: string | undefined;
+    /**
+     * Time of the event, in epoch ms.
+     * @public
+     */
+    time: number;
 }
 /**
- * A recogniser result for the caller's speech. Interim results (`final: false`) are replaced by the final one with the same `id`.
+ * An error on the connection. The session continues, unless a `ended` event follows.
  * @public
  */
-export interface VoiceCallTranscriptionEvent {
+export interface VoiceErrorEvent {
     /**
-     * Identifier of a transcription chunk within a session.
+     * Value of `type` in the `event` of an event frame.
      * @public
      */
-    id: string;
-    text: string;
-    final: boolean;
+    type: VoiceEventType;
     /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
-     *     when the model was released.
+     * Error code. The value is stable.
      * @public
      */
-    language?: string | undefined;
+    code: string;
     /**
-     * Milliseconds since the call started, as the PBX stamps it.
+     * Description of the error.
      * @public
      */
-    time?: number | undefined;
+    message: string;
     /**
-     * Present on a final that did not go to the agent as a caller turn. It came while the agent spoke, and its recognition confidence was below the minimum of the call or the recogniser labelled it with another speaker.
+     * Time of the event, in epoch ms.
      * @public
      */
-    dropped?: VoiceTranscriptionDropReason | undefined;
+    time: number;
 }
 /**
- * One event on a live call. The SSE frame's `event:` is the member name and `data:` this whole union document, so a frame reads `data: \{"say": \{...\}\}` — never the member's payload on its own.
+ * A chunk of synthesized audio of a reply. `data` is base64 of PCM audio at the sample rate of the `say` command. An empty `data` marks the end of the stream.
  * @public
  */
-export type VoiceCallEvent = VoiceCallEvent.AgentTranscriptionMember | VoiceCallEvent.EndedMember | VoiceCallEvent.InterruptionMember | VoiceCallEvent.LanguageMember | VoiceCallEvent.PlaybackMember | VoiceCallEvent.ReplyMember | VoiceCallEvent.SayMember | VoiceCallEvent.StartedMember | VoiceCallEvent.ToolMember | VoiceCallEvent.TranscriptionMember | VoiceCallEvent.$UnknownMember;
+export interface VoicePlayCommandData {
+    replyId: string;
+    streamId: string;
+    data: string;
+    /**
+     * Value of `type` in the `command` of a command frame.
+     * @public
+     */
+    type: VoiceCommandType;
+}
 /**
+ * Audio of a reply that the service synthesizes. `play` commands with this stream id follow the `say` command.
  * @public
  */
-export declare namespace VoiceCallEvent {
+export interface VoiceSayCommandAudioOptions {
+    streamId: string;
     /**
-     * The session that answered the call, sent once per session of the call (a transfer starts another).
+     * Sample rate of the `pcm_s16le` mono audio of the `play` commands, in Hz: 8000, 12000, 16000, 24000, 32000, 44100 or 48000.
      * @public
      */
-    interface StartedMember {
-        started: VoiceCallStartedEvent;
-        transcription?: never;
-        agentTranscription?: never;
-        reply?: never;
-        say?: never;
-        playback?: never;
-        interruption?: never;
-        language?: never;
-        tool?: never;
-        ended?: never;
-        $unknown?: never;
-    }
+    sampleRate: number;
+}
+/**
+ * Play a reply to the caller. When `audio` is present, the service sends the audio of the reply in `play` commands. When `audio` is absent, the client shows `text` or synthesizes it itself.
+ * @public
+ */
+export interface VoiceSayCommandData {
     /**
-     * A recogniser result for the caller's speech. Interim results (`final: false`) are replaced by the final one with the same `id`.
+     * Text of the reply.
      * @public
      */
-    interface TranscriptionMember {
-        started?: never;
-        transcription: VoiceCallTranscriptionEvent;
-        agentTranscription?: never;
-        reply?: never;
-        say?: never;
-        playback?: never;
-        interruption?: never;
-        language?: never;
-        tool?: never;
-        ended?: never;
-        $unknown?: never;
-    }
+    text: string;
     /**
-     * A recogniser result for the AGENT's own leg — what the caller actually heard. Same semantics as VoiceCallTranscriptionEvent; an interrupted reply simply stops.
+     * Id of the reply.
      * @public
      */
-    interface AgentTranscriptionMember {
-        started?: never;
+    replyId: string;
+    /**
+     * True when the caller can interrupt the reply.
+     * @public
+     */
+    interruptible?: boolean | undefined;
+    /**
+     * Audio of a reply that the service synthesizes. `play` commands with this stream id follow the `say` command.
+     * @public
+     */
+    audio?: VoiceSayCommandAudioOptions | undefined;
+    /**
+     * Value of `type` in the `command` of a command frame.
+     * @public
+     */
+    type: VoiceCommandType;
+}
+/**
+ * Speech recognition settings of the call. The client applies them to its recogniser.
+ * @public
+ */
+export interface VoiceSpeechPayload {
+    /**
+     * Recogniser URI. Always present.
+     * @public
+     */
+    engine: string;
+    /**
+     * All configured languages. These are the candidates for language identification.
+     * @public
+     */
+    languages: string[];
+    /**
+     * Language at the start of the call. Always a member of `languages`.
+     * @public
+     */
+    preferredLanguage: string;
+    /**
+     * True to identify the spoken language of each utterance. False when `languages` has fewer languages than the recogniser needs, or when the recogniser cannot identify languages.
+     * @public
+     */
+    autoDetect: boolean;
+}
+/**
+ * The session is ready. Sent once after the handshake, on the PBX voice socket only when the client sends protocol version 1 or more.
+ * @public
+ */
+export interface VoiceSessionStartedEvent {
+    /**
+     * Value of `type` in the `event` of an event frame.
+     * @public
+     */
+    type: VoiceEventType;
+    /**
+     * Time of the event, in epoch ms.
+     * @public
+     */
+    time: number;
+    /**
+     * Id of the session.
+     * @public
+     */
+    sessionId: string;
+    /**
+     * Agent of the session.
+     * @public
+     */
+    agentId: string;
+    /**
+     * Published agent version of the session. Absent when the session runs the agent draft.
+     * @public
+     */
+    agentVersion?: number | undefined;
+    /**
+     * Trace of the session. It does not change during the session.
+     * @public
+     */
+    traceId?: string | undefined;
+    /**
+     * Display name of the agent.
+     * @public
+     */
+    agentName?: string | undefined;
+    /**
+     * Category of the agent.
+     * @public
+     */
+    category?: string | undefined;
+    /**
+     * PBX group of the agent, for data access control. Empty when the agent has no group.
+     * @public
+     */
+    groupId?: string | undefined;
+    /**
+     * Speech recognition settings of the call. Present only at `protocolVersion` 2 or more and only when the agent has speech settings. Absent: use a single-language recogniser on the language of the channel.
+     * @public
+     */
+    speech?: VoiceSpeechPayload | undefined;
+    /**
+     * Music-on-hold class to play as background sound of the call. Absent: no background sound.
+     * @public
+     */
+    backgroundSound?: string | undefined;
+}
+/**
+ * Stop the audio of the agent.
+ * @public
+ */
+export interface VoiceStopCommandData {
+    /**
+     * Value of `type` in the `command` of a command frame.
+     * @public
+     */
+    type: VoiceCommandType;
+}
+/**
+ * Transfer the call to a PBX destination and end the session. Only a PBX client does the transfer.
+ * @public
+ */
+export interface VoiceTransferCommandData {
+    /**
+     * Dialplan context of the destination.
+     * @public
+     */
+    context: string;
+    /**
+     * Extension of the destination.
+     * @public
+     */
+    extension: string;
+    /**
+     * Value of `type` in the `command` of a command frame.
+     * @public
+     */
+    type: VoiceCommandType;
+}
+/**
+ * @public
+ */
+export interface DescribeVoiceProtocolInput {
+}
+/**
+ * A recogniser result for the AGENT's own leg — what the caller actually heard. Same semantics as VoiceCallTranscriptionEvent; an interrupted reply simply stops.
+ * @public
+ */
+export interface VoiceCallAgentTranscriptionEvent {
+    id: string;
+    text: string;
+    final: boolean;
+    /**
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
+     *     when the model was released.
+     * @public
+     */
+    language?: string | undefined;
+    time?: number | undefined;
+}
+/**
+ * The session ended. After `transfer` another session of the same call may follow with its own `started`.
+ * @public
+ */
+export interface VoiceCallEndedEvent {
+    /**
+     * Id of the voice session.
+     * @public
+     */
+    sessionId: string;
+    reason: VoiceCallEndReason;
+}
+/**
+ * The caller talked over the agent. `playedText` is what they heard before the cut.
+ * @public
+ */
+export interface VoiceCallInterruptionEvent {
+    replyId?: string | undefined;
+    playedText?: string | undefined;
+    originalText?: string | undefined;
+}
+/**
+ * The conversation language changed on a recognised utterance.
+ * @public
+ */
+export interface VoiceCallLanguageEvent {
+    /**
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
+     *     when the model was released.
+     * @public
+     */
+    from?: string | undefined;
+    /**
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
+     *     when the model was released.
+     * @public
+     */
+    to: string;
+    reason: string;
+}
+/**
+ * The PBX finished (or abandoned) playing a reply.
+ * @public
+ */
+export interface VoiceCallPlaybackEvent {
+    replyId: string;
+    complete: boolean;
+}
+/**
+ * The caller's completed utterance that started a turn — after the runtime's filler and duplicate filter.
+ * @public
+ */
+export interface VoiceCallReplyEvent {
+    id: string;
+    text: string;
+    /**
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
+     *     when the model was released.
+     * @public
+     */
+    language?: string | undefined;
+}
+/**
+ * One sentence the agent speaks, as it is handed to the PBX (after playback sanitizing). Sentences of one reply share `replyId`.
+ * @public
+ */
+export interface VoiceCallSayEvent {
+    replyId: string;
+    text: string;
+    interruptible: boolean;
+}
+/**
+ * The session that answered the call, sent once per session of the call (a transfer starts another).
+ * @public
+ */
+export interface VoiceCallStartedEvent {
+    /**
+     * Id of the voice session.
+     * @public
+     */
+    sessionId: string;
+    /**
+     * The session's trace, for the LLM-level detail this stream deliberately omits. Absent for a built-in agent, whose trace is not the tenant's to read.
+     * @public
+     */
+    traceId?: string | undefined;
+    agentId: string;
+    agentName?: string | undefined;
+    /**
+     * Published agent version number. Monotonic within an agent's version history, starting at 1.
+     * @public
+     */
+    agentVersion?: number | undefined;
+    /**
+     * True when the session runs the agent's draft.
+     * @public
+     */
+    agentDraft?: boolean | undefined;
+    /**
+     * BCP-47 language the call started in.
+     * @public
+     */
+    language?: string | undefined;
+}
+/**
+ * A tool call the agent made during a turn. Name and phase only — arguments and results live in the trace. Sent to a caller signed in to the system; never to a guest.
+ * @public
+ */
+export interface VoiceCallToolEvent {
+    /**
+     * Identifies the tool call inside the turn — the model's own call id, not the PBX call this stream follows.
+     * @public
+     */
+    toolCallId: string;
+    toolName: string;
+    /**
+     * Phase of a tool call of the agent.
+     * @public
+     */
+    phase: VoiceToolPhase;
+    /**
+     * The phrase spoken while the tool runs, when the capability configures one.
+     * @public
+     */
+    startMessage?: string | undefined;
+}
+/**
+ * A recogniser result for the caller's speech. Interim results (`final: false`) are replaced by the final one with the same `id`.
+ * @public
+ */
+export interface VoiceCallTranscriptionEvent {
+    id: string;
+    text: string;
+    final: boolean;
+    /**
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
+     *     when the model was released.
+     * @public
+     */
+    language?: string | undefined;
+    /**
+     * Milliseconds since the call started, as the PBX stamps it.
+     * @public
+     */
+    time?: number | undefined;
+    /**
+     * Present on a final that did not go to the agent as a caller turn. It came while the agent spoke, and its recognition confidence was below the minimum of the call or the recogniser labelled it with another speaker.
+     * @public
+     */
+    finalDropReason?: VoiceTranscriptionDropReason | undefined;
+}
+/**
+ * One event on a live call. The SSE frame's `event:` is the member name and `data:` this whole union document, so a frame reads `data: \{"say": \{...\}\}` — never the member's payload on its own.
+ * @public
+ */
+export type VoiceCallEvent = VoiceCallEvent.AgentTranscriptionMember | VoiceCallEvent.EndedMember | VoiceCallEvent.InterruptionMember | VoiceCallEvent.LanguageMember | VoiceCallEvent.PlaybackMember | VoiceCallEvent.ReplyMember | VoiceCallEvent.SayMember | VoiceCallEvent.StartedMember | VoiceCallEvent.ToolMember | VoiceCallEvent.TranscriptionMember | VoiceCallEvent.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace VoiceCallEvent {
+    /**
+     * The session that answered the call, sent once per session of the call (a transfer starts another).
+     * @public
+     */
+    interface StartedMember {
+        started: VoiceCallStartedEvent;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * A recogniser result for the caller's speech. Interim results (`final: false`) are replaced by the final one with the same `id`.
+     * @public
+     */
+    interface TranscriptionMember {
+        started?: never;
+        transcription: VoiceCallTranscriptionEvent;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * A recogniser result for the AGENT's own leg — what the caller actually heard. Same semantics as VoiceCallTranscriptionEvent; an interrupted reply simply stops.
+     * @public
+     */
+    interface AgentTranscriptionMember {
+        started?: never;
         transcription?: never;
         agentTranscription: VoiceCallAgentTranscriptionEvent;
         reply?: never;
@@ -561,580 +898,169 @@ export declare namespace VoiceCallEvent {
         transcription: (value: VoiceCallTranscriptionEvent) => T;
         agentTranscription: (value: VoiceCallAgentTranscriptionEvent) => T;
         reply: (value: VoiceCallReplyEvent) => T;
-        say: (value: VoiceCallSayEvent) => T;
-        playback: (value: VoiceCallPlaybackEvent) => T;
-        interruption: (value: VoiceCallInterruptionEvent) => T;
-        language: (value: VoiceCallLanguageEvent) => T;
-        tool: (value: VoiceCallToolEvent) => T;
-        ended: (value: VoiceCallEndedEvent) => T;
-        _: (name: string, value: any) => T;
-    }
-}
-/**
- * A PCM/compressed audio format description.
- * @public
- */
-export interface VoiceAudioFormat {
-    /**
-     * Encoding of raw audio carried over the connection (client `audio` chunks and server `play` frames).
-     * @public
-     */
-    encoding: VoiceAudioEncoding;
-    /**
-     * Samples per second, e.g. 8000, 16000 or 24000.
-     * @public
-     */
-    sampleRate: number;
-    /**
-     * Channel count. Defaults to 1 (mono).
-     * @public
-     */
-    channels?: number | undefined;
-}
-/**
- * Parameters supplied on the WebSocket connect (upgrade) request, as query-string parameters.
- * @public
- */
-export interface VoiceConnectParams {
-    /**
-     * Protocol version advertised by the client (query parameter `v`). 0 (or absent) is the legacy PBX protocol; >= 1 enables the sessionStarted event; >= 2 additionally means the client WAITS for `started` before opening its recognition stream and honours the `speech` payload on it.
-     * @public
-     */
-    protocolVersion?: number | undefined;
-    /**
-     * Caller-supplied session id, unique per connection.
-     * @public
-     */
-    sessionId: string;
-    /**
-     * Attach the running session `sessionId` again after a close with code `1001` or a lost connection. The session keeps its history and does not play the greeting again.
-     * @public
-     */
-    resume?: boolean | undefined;
-    /**
-     * The client connects again with `resume` after a close with code `1001`. Only then can the service move a PBX text-socket call to another server while the call runs; without it the socket stays open until the call ends or the server stops.
-     * @public
-     */
-    reconnect?: boolean | undefined;
-    /**
-     * Agent to run on this session.
-     * @public
-     */
-    agentId: string;
-    /**
-     * Published agent version to run. Mutually exclusive with agentDraft. When neither is set, the agent's deployment configuration selects the version. The PBX sends it only for a preview number (`<agentId>-vN`, WMS-27502); a customer call never carries it.
-     * @public
-     */
-    agentVersion?: number | undefined;
-    /**
-     * Run the agent's current draft (for testing). Mutually exclusive with agentVersion.
-     * @public
-     */
-    agentDraft?: boolean | undefined;
-    /**
-     * PBX call id, when the session is bridged to a call.
-     * @public
-     */
-    callId?: string | undefined;
-    /**
-     * Leg of the PBX call inside `callId` (pbx-data-engine's flow index). Kept on the session as metadata beside `callId` and `dialedNumber`; never interpreted by the runtime.
-     * @public
-     */
-    flowIndex?: number | undefined;
-    /**
-     * The number the caller dialled to reach the agent. Kept on the session as metadata beside `callId` and `flowIndex`.
-     * @public
-     */
-    dialedNumber?: string | undefined;
-    /**
-     * BCP-47 language of the conversation, e.g. 'en-US'.
-     * @public
-     */
-    language?: string | undefined;
-    callerName?: string | undefined;
-    callerNumber?: string | undefined;
-    callerEmail?: string | undefined;
-    callerCompany?: string | undefined;
-    /**
-     * Override the TTS voice for this session, as a voice URI, e.g. 'elevenlabs://<voiceId>?apiKey=...'. Defaults to the agent's configured voice.
-     * @public
-     */
-    voice?: string | undefined;
-    /**
-     * First message spoken to the caller. Overrides the agent's configured greeting.
-     * @public
-     */
-    initialMessage?: string | undefined;
-    /**
-     * Base64-encoded JSON object of agent variables for this session, e.g. base64('\{"orderId":"123"\}').
-     * @public
-     */
-    variables?: string | undefined;
-    /**
-     * How caller speech reaches the service. Defaults to TRANSCRIPTION (PBX). Web/app clients use AUDIO.
-     * @public
-     */
-    inputMode?: VoiceInputMode | undefined;
-    /**
-     * Format of client `audio` chunks in AUDIO mode.
-     * @public
-     */
-    inputAudio?: VoiceAudioFormat | undefined;
-    /**
-     * Preferred format for server-synthesized `play` frames.
-     * @public
-     */
-    outputAudio?: VoiceAudioFormat | undefined;
-}
-/**
- * An error surfaced on the connection. Non-terminal unless followed by a SessionEndedEvent.
- * @public
- */
-export interface VoiceErrorEvent {
-    /**
-     * Discriminator for the inner payload of an `event` frame.
-     * @public
-     */
-    type: VoiceEventType;
-    /**
-     * Stable machine-readable error code.
-     * @public
-     */
-    code: string;
-    message: string;
-    time: number;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface ErrorWebsocketEvent {
-    type: string;
-    /**
-     * An error surfaced on the connection. Non-terminal unless followed by a SessionEndedEvent.
-     * @public
-     */
-    event: VoiceErrorEvent;
-}
-/**
- * Terminate the session and hang up the call.
- * @public
- */
-export interface HangupCommandData {
-    reason?: string | undefined;
-    /**
-     * Discriminator for the inner payload of a `command` frame.
-     * @public
-     */
-    type: VoiceCommandType;
-}
-/**
- * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
- * @public
- */
-export interface HangupWebsocketCommand {
-    type: string;
-    /**
-     * Terminate the session and hang up the call.
-     * @public
-     */
-    command: HangupCommandData;
-}
-/**
- * The caller interrupted (barged in over) a reply that was being played.
- * @public
- */
-export interface InterruptionEvent {
-    /**
-     * Discriminator for the inner payload of an `event` frame.
-     * @public
-     */
-    type: VoiceEventType;
-    /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
-     * @public
-     */
-    replyId: string;
-    /**
-     * Portion of the reply that had been played before the interruption.
-     * @public
-     */
-    playedText: string;
-    /**
-     * The full reply text that was being played.
-     * @public
-     */
-    originalText: string;
-    time: number;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface InterruptionWebsocketEvent {
-    type: string;
-    /**
-     * The caller interrupted (barged in over) a reply that was being played.
-     * @public
-     */
-    event: InterruptionEvent;
-}
-/**
- * Opens an agent audio stream. `MediaCloudAudio` messages of the stream follow until `audio.end`. Streams do not interleave.
- * @public
- */
-export interface MediaAudioBeginFrame {
-    type: MediaAudioBeginFrameType;
-    /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
-     * @public
-     */
-    replyId: string;
-    /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
-     * @public
-     */
-    streamId: string;
-    /**
-     * Sample rate of the stream's `pcm_s16le` mono audio in Hz: 8000, 16000, 22050 or 24000.
-     * @public
-     */
-    sampleRate: number;
-}
-/**
- * Closes an agent audio stream.
- * @public
- */
-export interface MediaAudioEndFrame {
-    type: MediaAudioEndFrameType;
-    /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
-     * @public
-     */
-    streamId: string;
+        say: (value: VoiceCallSayEvent) => T;
+        playback: (value: VoiceCallPlaybackEvent) => T;
+        interruption: (value: VoiceCallInterruptionEvent) => T;
+        language: (value: VoiceCallLanguageEvent) => T;
+        tool: (value: VoiceCallToolEvent) => T;
+        ended: (value: VoiceCallEndedEvent) => T;
+        _: (name: string, value: any) => T;
+    }
 }
 /**
- * Lower the volume of a playing reply.
+ * Opens an agent audio stream. Binary audio messages of the stream follow until `audio.end`. Streams do not interleave.
  * @public
  */
-export interface MediaDuckFrame {
-    type: MediaDuckFrameType;
+export interface VoiceCallAudioBeginFrame {
     /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
+    type: VoiceCallServerFrameType;
     replyId: string;
+    streamId: string;
     /**
-     * Target gain in dB.
-     * @public
-     */
-    volumeDb: number;
-    /**
-     * Ramp duration in ms.
+     * Sample rate of the stream's `pcm_s16le` mono audio in Hz: 8000, 12000, 16000, 24000, 32000, 44100 or 48000.
      * @public
      */
-    rampMs: number;
+    sampleRate: number;
 }
 /**
- * An error on the run. When `retryable` is false, the socket closes after it.
+ * Closes an agent audio stream.
  * @public
  */
-export interface MediaErrorFrame {
-    type: MediaErrorFrameType;
+export interface VoiceCallAudioEndFrame {
     /**
-     * Stable error code, for example `START_TIMEOUT`, `PROTOCOL_ERROR` or `STT_FAILED`.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    code: string;
-    retryable: boolean;
-    message: string;
-}
-/**
- * Answer to `finish`: the cloud processed all audio. The socket closes with 1000 after it.
- * @public
- */
-export interface MediaFinishedFrame {
-    type: MediaFinishedFrameType;
-}
-/**
- * Hang up the call after the queued agent audio plays. Terminal: the PBX answers with `finish`.
- * @public
- */
-export interface MediaHangupFrame {
-    type: MediaHangupFrameType;
+    type: VoiceCallServerFrameType;
+    streamId: string;
 }
 /**
- * The call continues in another language.
+ * DTMF input that the PBX collected. The cloud takes `digits` as the caller's reply.
  * @public
  */
-export interface MediaLanguageFrame {
-    type: MediaLanguageFrameType;
+export interface VoiceCallDtmfFrame {
     /**
-     * Language that the call continues in.
+     * Value of `type` in a text frame from the client (the PBX).
      * @public
      */
-    language: string;
+    type: VoiceCallClientFrameType;
+    id: string;
+    digits: string;
 }
 /**
- * Return a reply to full volume.
+ * Change the volume of a playing reply. `volumeDb` 0 returns it to full volume.
  * @public
  */
-export interface MediaRestoreFrame {
-    type: MediaRestoreFrameType;
+export interface VoiceCallDuckFrame {
     /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
+    type: VoiceCallServerFrameType;
     replyId: string;
     /**
-     * Ramp duration in ms.
-     * @public
-     */
-    rampMs: number;
-}
-/**
- * The agent that answers the run.
- * @public
- */
-export interface MediaStartedAgent {
-    name: string;
-}
-/**
- * Caller voice detection of a run, with every value resolved.
- * @public
- */
-export interface MediaVoiceDetection {
-    /**
-     * Silence in ms that ends the caller speech.
-     * @public
-     */
-    silenceMs: number;
-    /**
-     * Mean frame level in dBFS below which caller audio is silence.
+     * Target gain in dB.
      * @public
      */
-    silenceLevelDb: number;
+    volumeDb: number;
     /**
-     * Mean frame level in dBFS from which caller audio is speech.
+     * Ramp duration in ms.
      * @public
      */
-    speechLevelDb: number;
+    rampMs: number;
 }
 /**
- * The cloud accepted `start`. Sent once per connection.
+ * The run ended on the PBX. The PBX sends no audio after it and waits up to 3 s for `ended`.
  * @public
  */
-export interface MediaStartedFrame {
-    type: MediaStartedFrameType;
-    /**
-     * Id of the cloud stream of this run. Cloud logs carry it; use it to match PBX and cloud logs.
-     * @public
-     */
-    streamId: string;
-    /**
-     * Present when the run purpose is `agent`.
-     * @public
-     */
-    agent?: MediaStartedAgent | undefined;
-    /**
-     * Group of the agent. Absent when the agent has none.
-     * @public
-     */
-    groupId?: string | undefined;
+export interface VoiceCallEndFrame {
     /**
-     * Music-on-hold class that the PBX plays after each caller turn until agent audio starts. Absent: none.
+     * Value of `type` in a text frame from the client (the PBX).
      * @public
      */
-    backgroundSound?: string | undefined;
+    type: VoiceCallClientFrameType;
     /**
-     * Caller voice detection that the PBX uses for the `vad` frames of this run. Absent: the PBX keeps its defaults.
+     * Who ended the run on the PBX. The live events of the call report it as `VoiceCallEndReason`: `caller-hangup` as `hangup`, `agent-hangup` as `complete`, `agent-transfer` as `transfer`, `timeout` as `timeout`.
      * @public
      */
-    voiceDetection?: MediaVoiceDetection | undefined;
-}
-/**
- * Stop every agent audio stream of the run: the one that plays and the ones that wait.
- * @public
- */
-export interface MediaStopFrame {
-    type: MediaStopFrameType;
+    reason: VoiceCallClientEndReason;
 }
 /**
- * Words of one party. Partials and the final of one utterance share `id`. For the agent, the words that played.
+ * Answer to `end`: the cloud processed all audio. The socket closes with close code 1000 after it.
  * @public
  */
-export interface MediaTranscriptionFrame {
-    type: MediaTranscriptionFrameType;
-    /**
-     * Party that spoke. The agent's own words are `callee`.
-     * @public
-     */
-    party: MediaParty;
-    /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
-     * @public
-     */
-    id: string;
-    final: boolean;
-    text: string;
-    /**
-     * Run-clock time or duration in ms of PBX audio since the run started. It continues across reconnects.
-     * @public
-     */
-    startMs: number;
-    /**
-     * Run-clock time or duration in ms of PBX audio since the run started. It continues across reconnects.
-     * @public
-     */
-    endMs: number;
-    /**
-     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
-     *     constrained string rather than an enum: the offerable set is a property of the selected
-     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
-     *     when the model was released.
-     * @public
-     */
-    language: string;
+export interface VoiceCallEndedFrame {
     /**
-     * Recogniser confidence from 0 to 1. Absent when the text is not from a recogniser, or the engine gives none.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    confidence?: number | undefined;
+    type: VoiceCallServerFrameType;
 }
 /**
- * Transfer the call after the queued agent audio plays. Terminal: the PBX answers with `finish`.
+ * An error on the run. When `retryable` is false, the socket closes after it.
  * @public
  */
-export interface MediaTransferFrame {
-    type: MediaTransferFrameType;
+export interface VoiceCallErrorFrame {
     /**
-     * Dialplan context of the target.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    context: string;
+    type: VoiceCallServerFrameType;
     /**
-     * Extension of the target.
+     * Stable error code, for example `START_TIMEOUT`, `PROTOCOL_ERROR` or `STT_FAILED`.
      * @public
      */
-    extension: string;
+    code: string;
+    retryable: boolean;
+    message: string;
 }
 /**
- * One example of each message that the cloud sends.
+ * Hang up the call after the queued agent audio plays. Terminal: the PBX answers with `end`.
  * @public
  */
-export interface MediaCloudFrames {
-    /**
-     * The cloud accepted `start`. Sent once per connection.
-     * @public
-     */
-    started?: MediaStartedFrame | undefined;
-    /**
-     * Words of one party. Partials and the final of one utterance share `id`. For the agent, the words that played.
-     * @public
-     */
-    transcription?: MediaTranscriptionFrame | undefined;
-    /**
-     * Opens an agent audio stream. `MediaCloudAudio` messages of the stream follow until `audio.end`. Streams do not interleave.
-     * @public
-     */
-    audioBegin?: MediaAudioBeginFrame | undefined;
-    /**
-     * One binary audio message. In the describe answer it is base64; on the socket it is raw bytes.
-     * @public
-     */
-    audio?: Uint8Array | undefined;
-    /**
-     * Closes an agent audio stream.
-     * @public
-     */
-    audioEnd?: MediaAudioEndFrame | undefined;
-    /**
-     * Stop every agent audio stream of the run: the one that plays and the ones that wait.
-     * @public
-     */
-    stop?: MediaStopFrame | undefined;
-    /**
-     * Lower the volume of a playing reply.
-     * @public
-     */
-    duck?: MediaDuckFrame | undefined;
-    /**
-     * Return a reply to full volume.
-     * @public
-     */
-    restore?: MediaRestoreFrame | undefined;
-    /**
-     * The call continues in another language.
-     * @public
-     */
-    language?: MediaLanguageFrame | undefined;
-    /**
-     * Transfer the call after the queued agent audio plays. Terminal: the PBX answers with `finish`.
-     * @public
-     */
-    transfer?: MediaTransferFrame | undefined;
-    /**
-     * Hang up the call after the queued agent audio plays. Terminal: the PBX answers with `finish`.
-     * @public
-     */
-    hangup?: MediaHangupFrame | undefined;
-    /**
-     * An error on the run. When `retryable` is false, the socket closes after it.
-     * @public
-     */
-    error?: MediaErrorFrame | undefined;
+export interface VoiceCallHangupFrame {
     /**
-     * Answer to `finish`: the cloud processed all audio. The socket closes with 1000 after it.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    finished?: MediaFinishedFrame | undefined;
+    type: VoiceCallServerFrameType;
 }
 /**
- * DTMF input that the PBX collected. The cloud takes `digits` as the caller's reply.
+ * The call continues in another language.
  * @public
  */
-export interface MediaDtmfFrame {
-    type: MediaDtmfFrameType;
+export interface VoiceCallLanguageFrame {
     /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    id: string;
-    digits: string;
-}
-/**
- * The run ended on the PBX. The PBX sends no audio after it and waits up to 3 s for `finished`.
- * @public
- */
-export interface MediaFinishFrame {
-    type: MediaFinishFrameType;
+    type: VoiceCallServerFrameType;
     /**
-     * Who ended the run on the PBX.
+     * Language that the call continues in.
      * @public
      */
-    reason: MediaFinishReason;
+    language: string;
 }
 /**
  * An agent audio stream changed state on the PBX.
  * @public
  */
-export interface MediaPlaybackFrame {
-    type: MediaPlaybackFrameType;
+export interface VoiceCallPlaybackFrame {
     /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
+     * Value of `type` in a text frame from the client (the PBX).
      * @public
      */
+    type: VoiceCallClientFrameType;
     replyId: string;
-    /**
-     * Id of a reply, a stream, an utterance or a DTMF input, unique in the run.
-     * @public
-     */
     streamId: string;
     /**
      * Event of an agent audio stream.
      * @public
      */
-    event: MediaPlaybackEvent;
+    event: VoiceCallPlaybackPhase;
     /**
      * Run-clock time or duration in ms of PBX audio since the run started. It continues across reconnects.
      * @public
@@ -1146,16 +1072,16 @@ export interface MediaPlaybackFrame {
      */
     playedMs?: number | undefined;
     /**
-     * Present with `stopped`.
+     * True when the PBX dropped the stream, for example at its queue limit. Only with `stopped`. Absent: false.
      * @public
      */
-    cause?: MediaPlaybackStopCause | undefined;
+    dropped?: boolean | undefined;
 }
 /**
- * The agent of a media run. At most one of `draft` and `version` is set.
+ * The agent of the run. At most one of `draft` and `version` is set.
  * @public
  */
-export interface MediaStartAgent {
+export interface VoiceCallStartAgent {
     /**
      * Agent id.
      * @public
@@ -1173,31 +1099,10 @@ export interface MediaStartAgent {
     version?: number | undefined;
 }
 /**
- * Format of the binary PBX audio (`MediaPbxAudio`). Channel 0 is the caller; channel 1, when present, is the callee. Samples interleave. The cloud accepts only 8000 Hz and one channel at this time; another format closes the socket with 4400.
- * @public
- */
-export interface MediaAudioFormat {
-    /**
-     * Sample encoding of PBX audio.
-     * @public
-     */
-    encoding: MediaAudioEncoding;
-    /**
-     * Sample rate in Hz.
-     * @public
-     */
-    sampleRate: number;
-    /**
-     * Number of channels.
-     * @public
-     */
-    channels: number;
-}
-/**
- * Caller identity. Each member is absent, null or empty when unknown.
+ * Caller identity from the lookup application of the PBX: an external lookup or the local phonebook. Each member is absent, null or empty when unknown.
  * @public
  */
-export interface MediaStartCaller {
+export interface VoiceCallStartCaller {
     name?: string | undefined;
     number?: string | undefined;
     email?: string | undefined;
@@ -1207,572 +1112,374 @@ export interface MediaStartCaller {
  * First text frame of a socket, sent within 10 s of the upgrade. Opens a run, or attaches a reconnect to it.
  * @public
  */
-export interface MediaStartFrame {
-    type: MediaStartFrameType;
+export interface VoiceCallStartFrame {
     /**
-     * Purpose of a media run.
+     * Value of `type` in a text frame from the client (the PBX).
      * @public
      */
-    purpose: MediaRunPurpose;
+    type: VoiceCallClientFrameType;
     /**
      * Id of the PBX call. Use it to correlate the call events of the run.
      * @public
      */
     callId: string;
     /**
-     * Index of this run on the call, from 0.
-     * @public
-     */
-    flowIndex: number;
-    /**
-     * Id of this run. The same on every connection of the run; the cloud attaches a reconnect and settles a takeover by it.
-     * @public
-     */
-    sessionId: string;
-    /**
-     * True when an earlier connection of this run got agent audio (`audio.begin`): the cloud continues that session without a new greeting.
-     * @public
-     */
-    resume: boolean;
-    /**
-     * Run-clock time of the first audio byte of this connection: 0 on the first connection.
-     * @public
-     */
-    resumeAtMs: number;
-    /**
-     * Format of the binary PBX audio (`MediaPbxAudio`). Channel 0 is the caller; channel 1, when present, is the callee. Samples interleave. The cloud accepts only 8000 Hz and one channel at this time; another format closes the socket with 4400.
-     * @public
-     */
-    audio: MediaAudioFormat;
-    /**
-     * Present when `purpose` is `agent`.
-     * @public
-     */
-    agent?: MediaStartAgent | undefined;
-    /**
-     * Languages to recognise when `purpose` is `transcription`. May be empty only when `autoDetect` is true. Ignored when `purpose` is `agent`: the agent settings give the languages.
-     * @public
-     */
-    languages?: string[] | undefined;
-    /**
-     * Language of the call. Required when `purpose` is `agent`: the agent starts in its configured language that matches it. With `transcription`, absent or null means the first of `languages`.
-     * @public
-     */
-    preferredLanguage?: string | undefined;
-    /**
-     * True to identify the caller's language among `languages` when `purpose` is `transcription`. Absent: false. Ignored when `purpose` is `agent`.
-     * @public
-     */
-    autoDetect?: boolean | undefined;
-    /**
-     * Caller identity. Each member is absent, null or empty when unknown.
-     * @public
-     */
-    caller: MediaStartCaller;
-    /**
-     * Number that the caller dialled. Absent, null or empty when unknown.
-     * @public
-     */
-    dialedNumber?: string | undefined;
-    /**
-     * Base64 of a JSON object of the `VOICEBOT_*` channel variables. Absent, null or empty when there are none.
-     * @public
-     */
-    variables?: string | undefined;
-}
-/**
- * Voice activity of a party as the PBX detects it. Sent when the state changes, and every 100 ms while agent audio plays.
- * @public
- */
-export interface MediaVadFrame {
-    type: MediaVadFrameType;
-    /**
-     * Party whose audio the report describes.
-     * @public
-     */
-    party: MediaParty;
-    /**
-     * True while the party speaks.
-     * @public
-     */
-    speaking: boolean;
-    /**
-     * Energy of the audio frame that produced the report, in dBFS.
-     * @public
-     */
-    energyDb: number;
-    /**
-     * Run-clock time or duration in ms of PBX audio since the run started. It continues across reconnects.
-     * @public
-     */
-    atMs: number;
-}
-/**
- * One example of each message that the PBX sends.
- * @public
- */
-export interface MediaPbxFrames {
+     * Index of this run on the call, from 0.
+     * @public
+     */
+    flowIndex: number;
     /**
-     * First text frame of a socket, sent within 10 s of the upgrade. Opens a run, or attaches a reconnect to it.
+     * Id of this run. The same on every connection of the run; the cloud attaches a reconnect and settles a takeover by it.
      * @public
      */
-    start?: MediaStartFrame | undefined;
+    sessionId: string;
     /**
-     * One binary audio message. In the describe answer it is base64; on the socket it is raw bytes.
+     * True when an earlier connection of this run got agent audio (`audio.begin`): the cloud continues that session without a new greeting.
      * @public
      */
-    audio?: Uint8Array | undefined;
+    resume: boolean;
     /**
-     * Voice activity of a party as the PBX detects it. Sent when the state changes, and every 100 ms while agent audio plays.
+     * Run-clock time of the first audio byte of this connection: 0 on the first connection.
      * @public
      */
-    vad?: MediaVadFrame | undefined;
+    resumeAtMs: number;
     /**
-     * DTMF input that the PBX collected. The cloud takes `digits` as the caller's reply.
+     * The agent of the run. At most one of `draft` and `version` is set.
      * @public
      */
-    dtmf?: MediaDtmfFrame | undefined;
+    agent: VoiceCallStartAgent;
     /**
-     * An agent audio stream changed state on the PBX.
+     * Language of the call, for example `en-US`. The agent starts in its configured language that matches it.
      * @public
      */
-    playback?: MediaPlaybackFrame | undefined;
+    language: string;
     /**
-     * The run ended on the PBX. The PBX sends no audio after it and waits up to 3 s for `finished`.
+     * Caller identity from the lookup application of the PBX: an external lookup or the local phonebook. Each member is absent, null or empty when unknown.
      * @public
      */
-    finish?: MediaFinishFrame | undefined;
-}
-/**
- * One example of each message of the PBX media socket.
- * @public
- */
-export interface MediaProtocolFrames {
+    caller: VoiceCallStartCaller;
     /**
-     * Messages that the PBX sends.
+     * Number that the caller dialled. Absent, null or empty when unknown.
      * @public
      */
-    pbx?: MediaPbxFrames | undefined;
+    dialedNumber?: string | undefined;
     /**
-     * Messages that the cloud sends.
+     * Base64 of a JSON object of the `VOICEBOT_*` channel variables. Absent, null or empty when there are none.
      * @public
      */
-    cloud?: MediaCloudFrames | undefined;
+    variables?: string | undefined;
 }
 /**
- * Client-reported progress of an in-flight reply playback.
+ * Answer to `start`: the session of the run is ready on this connection. Sent once per connection, also after a reconnect. Example: `\{"type":"started","connectionId":"0f6d…","agent":\{"id":"a_qqyHI7xWBH","name":"Support"\}\}`.
  * @public
  */
-export interface PlaybackEvent {
+export interface VoiceCallStartedFrame {
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    type: VoiceEventType;
+    type: VoiceCallServerFrameType;
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Id of this connection. Each connection of the run has its own.
      * @public
      */
-    replyId: string;
-    text: string;
-    complete: boolean;
-    startTime: number;
-    endTime?: number | undefined;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface PlaybackWebsocketEvent {
-    type: string;
+    connectionId: string;
     /**
-     * Client-reported progress of an in-flight reply playback.
+     * Display name of the agent.
      * @public
      */
-    event: PlaybackEvent;
-}
-/**
- * A chunk of synthesized reply audio to play. `data` is base64, PCM-encoded at the sample rate declared in the matching `say` command; an empty `data` marks the end of the stream.
- * @public
- */
-export interface PlayCommandData {
+    agentName: string;
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Group of the agent. Absent when the agent has none.
      * @public
      */
-    replyId: string;
+    groupId?: string | undefined;
     /**
-     * Identifies one synthesized audio stream within a session; carried by a `say` command and the `play` frames that render it.
+     * Music-on-hold class that the PBX plays after each caller turn until agent audio starts. Absent: none.
      * @public
      */
-    streamId: string;
-    data: string;
+    backgroundSound?: string | undefined;
     /**
-     * Discriminator for the inner payload of a `command` frame.
+     * Caller voice detection that the PBX uses for the `vad` frames of this run. The cloud sends every member. Absent: the PBX keeps its defaults.
      * @public
      */
-    type: VoiceCommandType;
+    voiceDetection?: VoiceDetectionSettings | undefined;
 }
 /**
- * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
+ * Stop every agent audio stream of the run: the one that plays and the ones that wait.
  * @public
  */
-export interface PlayWebsocketCommand {
-    type: string;
+export interface VoiceCallStopFrame {
     /**
-     * A chunk of synthesized reply audio to play. `data` is base64, PCM-encoded at the sample rate declared in the matching `say` command; an empty `data` marks the end of the stream.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    command: PlayCommandData;
+    type: VoiceCallServerFrameType;
 }
 /**
- * A final caller phrase that should trigger an agent turn (PBX / TRANSCRIPTION mode).
+ * Words of one party. Partials and the final of one utterance share `id`. For the agent, the words that played.
  * @public
  */
-export interface ReplyEvent {
+export interface VoiceCallTranscriptionFrame {
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    type: VoiceEventType;
+    type: VoiceCallServerFrameType;
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Party that spoke. The agent's own words are `callee`.
      * @public
      */
+    party: VoiceCallParty;
     id: string;
+    final: boolean;
     text: string;
     /**
-     * Language the recogniser identified for this completed utterance. THIS is the one that drives the language switch. When the recogniser reports several languages inside one utterance, the PBX sends the LAST labelled segment's language — it is the one the caller is speaking now.
+     * Run-clock time or duration in ms of PBX audio since the run started. It continues across reconnects.
      * @public
      */
-    language?: string | undefined;
-    startTime: number;
-    endTime: number;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface ReplyWebsocketEvent {
-    type: string;
+    startMs: number;
     /**
-     * A final caller phrase that should trigger an agent turn (PBX / TRANSCRIPTION mode).
+     * Run-clock time or duration in ms of PBX audio since the run started. It continues across reconnects.
      * @public
      */
-    event: ReplyEvent;
-}
-/**
- * Audio-stream parameters when the server synthesizes the reply itself (TTS provider configured on the agent): the `say` is followed by a stream of `play` frames on this stream id.
- * @public
- */
-export interface SayCommandAudioOptions {
+    endMs: number;
     /**
-     * Identifies one synthesized audio stream within a session; carried by a `say` command and the `play` frames that render it.
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     recogniser and changes with it, so an enumeration here would cap the set at whatever was known
+     *     when the model was released.
      * @public
      */
-    streamId: string;
-    sampleRate: number;
+    language: string;
+    /**
+     * Recogniser confidence from 0 to 1. Absent when the text is not from a recogniser, or the engine gives none.
+     * @public
+     */
+    confidence?: number | undefined;
 }
 /**
- * Play a reply to the caller. When `audio` is absent the client performs text-to-speech from `text`; when present the server streams synthesized `play` frames for this reply.
+ * Transfer the call after the queued agent audio plays. Terminal: the PBX answers with `end`.
  * @public
  */
-export interface SayCommandData {
-    text: string;
-    /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
-     * @public
-     */
-    replyId: string;
-    /**
-     * Whether the caller may barge in over this reply.
-     * @public
-     */
-    interruptible?: boolean | undefined;
+export interface VoiceCallTransferFrame {
     /**
-     * Bare Amazon Polly voice id, e.g. 'Joanna' — NOT a URI. The PBX consumes this verbatim as the
-     *     AMI `Voice=` action parameter, so it takes exactly what Polly names the voice, with the
-     *     `amazon_polly://` scheme and any query parameters already stripped by whoever builds this
-     *     command out of the agent's stored `VoiceUri`.
-     *
-     *     Set only for a provider whose synthesis runs ON THE PBX (Amazon Polly); ElevenLabs and Google
-     *     are synthesized in the cloud and streamed as PCM through `play` instead, and leave this
-     *     absent.
+     * Dialplan context of the destination.
      * @public
      */
-    voice?: string | undefined;
+    context: string;
     /**
-     * Audio-stream parameters when the server synthesizes the reply itself (TTS provider configured on the agent): the `say` is followed by a stream of `play` frames on this stream id.
+     * Extension of the destination.
      * @public
      */
-    audio?: SayCommandAudioOptions | undefined;
+    extension: string;
     /**
-     * Discriminator for the inner payload of a `command` frame.
+     * Value of `type` in a text frame from the server (the cloud).
      * @public
      */
-    type: VoiceCommandType;
+    type: VoiceCallServerFrameType;
 }
 /**
- * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
+ * Voice activity of the caller as the PBX detects it. Sent when the state changes, and every 100 ms while agent audio plays.
  * @public
  */
-export interface SayWebsocketCommand {
-    type: string;
+export interface VoiceCallVadFrame {
     /**
-     * Play a reply to the caller. When `audio` is absent the client performs text-to-speech from `text`; when present the server streams synthesized `play` frames for this reply.
+     * Value of `type` in a text frame from the client (the PBX).
      * @public
      */
-    command: SayCommandData;
-}
-/**
- * Terminal server event: the session ended, optionally with an error.
- * @public
- */
-export interface SessionEndedEvent {
+    type: VoiceCallClientFrameType;
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * True while the caller speaks.
      * @public
      */
-    type: VoiceEventType;
-    reason?: string | undefined;
+    speaking: boolean;
     /**
-     * Present when the session ended because of an error.
+     * Energy of the audio frame that produced the report, in dBFS.
      * @public
      */
-    error?: string | undefined;
-    time: number;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface SessionEndedWebsocketEvent {
-    type: string;
+    energyDb: number;
     /**
-     * Terminal server event: the session ended, optionally with an error.
+     * Run-clock time or duration in ms of PBX audio since the run started. It continues across reconnects.
      * @public
      */
-    event: SessionEndedEvent;
+    atMs: number;
 }
 /**
- * Recognition intent for the call, sent on `started` at protocolVersion >= 2. NOT recogniser
- *     parameters: the PBX translates it into its provider's API. Against Amazon Transcribe with
- *     autoDetect true that is identify-multiple-languages plus language-options and
- *     preferred-language; with autoDetect false, a single-language stream on preferredLanguage.
- *
- *     Both members the server can get wrong are RESOLVED here rather than forwarded: `engine` is
- *     always concrete (an absent one would let the PBX apply a different default than the console
- *     built its language list for), and `autoDetect` is clamped to false whenever the language count
- *     is below the recogniser's minimum or the recogniser cannot identify languages at all
- *     (forwarding true with one candidate makes Amazon reject the stream outright — a dead call).
+ * One example of each text message of the call socket.
  * @public
  */
-export interface VoiceSpeechPayload {
+export interface VoiceCallProtocolFrames {
     /**
-     * Concrete recogniser URI, resolved from the agent or from the platform default; never absent. See TranscriptionUri.
+     * First text frame of a socket, sent within 10 s of the upgrade. Opens a run, or attaches a reconnect to it.
      * @public
      */
-    engine: string;
+    start?: VoiceCallStartFrame | undefined;
     /**
-     * Every configured language, as candidates for identification.
+     * Voice activity of the caller as the PBX detects it. Sent when the state changes, and every 100 ms while agent audio plays.
      * @public
      */
-    languages: string[];
+    vad?: VoiceCallVadFrame | undefined;
     /**
-     * The language the call starts in, resolved from the channel. Always a member of `languages`.
+     * DTMF input that the PBX collected. The cloud takes `digits` as the caller's reply.
      * @public
      */
-    preferredLanguage: string;
+    dtmf?: VoiceCallDtmfFrame | undefined;
     /**
-     * Whether to identify the spoken language per utterance. Already clamped by the server — see the shape's documentation.
+     * An agent audio stream changed state on the PBX.
      * @public
      */
-    autoDetect: boolean;
-}
-/**
- * Emitted once right after the handshake to confirm the session and the agent it is bound to. Sent only when the client advertises protocol version >= 1.
- * @public
- */
-export interface SessionStartedEvent {
+    playback?: VoiceCallPlaybackFrame | undefined;
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * The run ended on the PBX. The PBX sends no audio after it and waits up to 3 s for `ended`.
      * @public
      */
-    type: VoiceEventType;
-    time: number;
+    end?: VoiceCallEndFrame | undefined;
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Answer to `start`: the session of the run is ready on this connection. Sent once per connection, also after a reconnect. Example: `\{"type":"started","connectionId":"0f6d…","agent":\{"id":"a_qqyHI7xWBH","name":"Support"\}\}`.
      * @public
      */
-    sessionId: string;
+    started?: VoiceCallStartedFrame | undefined;
     /**
-     * Agent bound to the session.
+     * Words of one party. Partials and the final of one utterance share `id`. For the agent, the words that played.
      * @public
      */
-    agentId: string;
+    transcription?: VoiceCallTranscriptionFrame | undefined;
     /**
-     * Published agent version resolved at connect; absent when running the agent draft.
+     * Opens an agent audio stream. Binary audio messages of the stream follow until `audio.end`. Streams do not interleave.
      * @public
      */
-    agentVersion?: number | undefined;
+    audioBegin?: VoiceCallAudioBeginFrame | undefined;
     /**
-     * Trace recording this voice session in wilma-traces — the caller's transcribed phrases, the
-     *     model calls they drove and the tools the agent ran. Read it with the wilma-traces GetTrace
-     *     operation, or tail it live with StreamTrace to follow a call while it is in progress.
-     *
-     *     Sent once at handshake and stable for the connection: a call is one trace. A caller who
-     *     redials gets a new session and therefore a new trace, since the trace is keyed on the session
-     *     id supplied at connect.
+     * Closes an agent audio stream.
      * @public
      */
-    traceId?: string | undefined;
+    audioEnd?: VoiceCallAudioEndFrame | undefined;
     /**
-     * Agent display name.
+     * Stop every agent audio stream of the run: the one that plays and the ones that wait.
      * @public
      */
-    agentName?: string | undefined;
+    stop?: VoiceCallStopFrame | undefined;
     /**
-     * Agent category.
+     * Change the volume of a playing reply. `volumeDb` 0 returns it to full volume.
      * @public
      */
-    category?: string | undefined;
+    duck?: VoiceCallDuckFrame | undefined;
     /**
-     * PBX group used for data ACL; empty when the agent is not assigned to a group.
+     * The call continues in another language.
      * @public
      */
-    groupId?: string | undefined;
+    language?: VoiceCallLanguageFrame | undefined;
     /**
-     * Recognition intent for the call. Sent only at protocolVersion >= 2 and only when the agent has `speech` configured. A v2 client that receives `started` WITHOUT this member falls back to exactly its pre-v2 behavior: a single-language stream on the channel's own `language`.
+     * Transfer the call after the queued agent audio plays. Terminal: the PBX answers with `end`.
      * @public
      */
-    speech?: VoiceSpeechPayload | undefined;
+    transfer?: VoiceCallTransferFrame | undefined;
     /**
-     * Music-on-hold class the PBX should play under the call as ambient background.
-     *
-     *     A BARE NAME, not the configuration object `VoiceBackgroundSoundSettings`: this is the RESOLVED
-     *     outcome. The server has already applied `enabled` and the class default, so the PBX gets a name
-     *     to play or nothing at all and needs no resolution rule of its own.
-     *
-     *     TOP LEVEL, NOT INSIDE `speech`, because it is not recognition intent and must not inherit
-     *     `speech`'s conditions: a call with no configured languages carries no `speech` payload and can
-     *     still have background audio.
-     *
-     *     ABSENT MEANS OFF, and absence is the only way to say it — there is no value for 'none'. A bot
-     *     whose administrator never touched the setting sends nothing here, which is exactly what every
-     *     call sent before it existed, so the PBX needs no new case.
+     * Hang up the call after the queued agent audio plays. Terminal: the PBX answers with `end`.
      * @public
      */
-    backgroundSound?: string | undefined;
+    hangup?: VoiceCallHangupFrame | undefined;
     /**
-     * Negotiated format of caller `audio` chunks the client should send (AUDIO mode).
+     * An error on the run. When `retryable` is false, the socket closes after it.
      * @public
      */
-    inputAudio?: VoiceAudioFormat | undefined;
+    error?: VoiceCallErrorFrame | undefined;
     /**
-     * Format of the synthesized `play` frames the server will send when it performs TTS.
+     * Answer to `end`: the cloud processed all audio. The socket closes with close code 1000 after it.
      * @public
      */
-    outputAudio?: VoiceAudioFormat | undefined;
+    ended?: VoiceCallEndedFrame | undefined;
 }
 /**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+ * Parameters supplied on the WebSocket connect (upgrade) request, as query-string parameters.
  * @public
  */
-export interface SessionStartedWebsocketEvent {
-    type: string;
+export interface VoiceConnectParams {
     /**
-     * Emitted once right after the handshake to confirm the session and the agent it is bound to. Sent only when the client advertises protocol version >= 1.
+     * Protocol version advertised by the client (query parameter `v`). 0 (or absent) is the legacy PBX protocol; >= 1 enables the sessionStarted event; >= 2 additionally means the client WAITS for `started` before opening its recognition stream and honours the `speech` payload on it; >= 3 additionally means the client connects again with `resume` after close code `1001`, so the service can move the call to another server while it runs.
      * @public
      */
-    event: SessionStartedEvent;
-}
-/**
- * @public
- */
-export interface StopCommandData {
+    protocolVersion?: number | undefined;
     /**
-     * Discriminator for the inner payload of a `command` frame.
+     * Caller-supplied session id, unique per connection.
      * @public
      */
-    type: VoiceCommandType;
-}
-/**
- * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
- * @public
- */
-export interface StopWebsocketCommand {
-    type: string;
-    command: StopCommandData;
-}
-/**
- * A transcription chunk of caller speech, provided by a client that does its own speech-to-text (PBX / TRANSCRIPTION mode), or emitted by the service (AUDIO mode) and echoed to the client.
- * @public
- */
-export interface TranscriptionEvent {
+    sessionId: string;
     /**
-     * Discriminator for the inner payload of an `event` frame.
+     * True when this connection attaches the running session `sessionId` again, after a close with close code `1001` or a lost connection. The session keeps its history and does not play the greeting again.
      * @public
      */
-    type: VoiceEventType;
+    resume?: boolean | undefined;
     /**
-     * Identifier of a transcription chunk within a session.
+     * Agent to run on this session.
      * @public
      */
-    id: string;
-    text: string;
+    agentId: string;
     /**
-     * Transcription confidence score (accuracy level) in range from 0.0 to 1.0. Value -1.0 indicates confidence is unavailable.
+     * Published agent version to run. Mutually exclusive with agentDraft. When neither is set, the agent's deployment configuration selects the version. The PBX sends it only for a preview number (`<agentId>-vN`, WMS-27502); a customer call never carries it.
      * @public
      */
-    confidence?: number | undefined;
+    agentVersion?: number | undefined;
     /**
-     * True when this is the final transcript for the utterance rather than an interim hypothesis. An absent value is read as final: a client that does not distinguish interim results sends none.
+     * Run the agent's current draft (for testing). Mutually exclusive with agentVersion.
      * @public
      */
-    final?: boolean | undefined;
+    agentDraft?: boolean | undefined;
+    /**
+     * PBX call id, when the session is bridged to a call.
+     * @public
+     */
+    callId?: string | undefined;
+    /**
+     * Leg of the PBX call inside `callId` (pbx-data-engine's flow index). Kept on the session as metadata beside `callId` and `dialedNumber`; never interpreted by the runtime.
+     * @public
+     */
+    flowIndex?: number | undefined;
+    /**
+     * The number the caller dialled to reach the agent. Kept on the session as metadata beside `callId` and `flowIndex`.
+     * @public
+     */
+    dialedNumber?: string | undefined;
     /**
-     * Language the recogniser identified for this chunk. Recorded in the trace only — it drives no behavior, so an operator can see what the recogniser thought during an utterance that never became a turn.
+     * BCP-47 language of the conversation, e.g. 'en-US'.
      * @public
      */
     language?: string | undefined;
-    time: number;
-}
-/**
- * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
- * @public
- */
-export interface TranscriptionWebsocketEvent {
-    type: string;
+    callerName?: string | undefined;
+    callerNumber?: string | undefined;
+    callerEmail?: string | undefined;
+    callerCompany?: string | undefined;
     /**
-     * A transcription chunk of caller speech, provided by a client that does its own speech-to-text (PBX / TRANSCRIPTION mode), or emitted by the service (AUDIO mode) and echoed to the client.
+     * Override the TTS voice for this session, as a voice URI, e.g. 'elevenlabs://<voiceId>?apiKey=...'. Defaults to the agent's configured voice.
      * @public
      */
-    event: TranscriptionEvent;
-}
-/**
- * Transfer the call to a PBX destination and terminate the session. Honoured on PBX clients.
- * @public
- */
-export interface TransferCommandData {
-    context: string;
-    extension: string;
+    voice?: string | undefined;
     /**
-     * Discriminator for the inner payload of a `command` frame.
+     * First message spoken to the caller. Overrides the agent's configured greeting.
      * @public
      */
-    type: VoiceCommandType;
-}
-/**
- * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
- * @public
- */
-export interface TransferWebsocketCommand {
-    type: string;
+    initialMessage?: string | undefined;
+    /**
+     * Base64-encoded JSON object of agent variables for this session, e.g. base64('\{"orderId":"123"\}').
+     * @public
+     */
+    variables?: string | undefined;
+    /**
+     * How caller speech reaches the service. Absent: `transcription`. The service refuses another value with HTTP 400.
+     * @public
+     */
+    inputMode?: VoiceInputMode | undefined;
+    /**
+     * Owner user of the session. Absent: no user. The service ignores it for a PBX token with `callId`.
+     * @public
+     */
+    user?: string | undefined;
     /**
-     * Transfer the call to a PBX destination and terminate the session. Honoured on PBX clients.
+     * Tenant of the session. Required for a service token, which carries no tenant. For another token a value different from the token tenant gets HTTP 401.
      * @public
      */
-    command: TransferCommandData;
+    company?: string | undefined;
 }
 /**
  * @public
@@ -1784,95 +1491,90 @@ export interface DescribeVoiceProtocolOutput {
      */
     connectParams?: VoiceConnectParams | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
-     * @public
-     */
-    audioWebsocketEvent?: AudioWebsocketEvent | undefined;
-    /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * Keepalive frame from the client: `\{"type": "healthcheck"\}`. The service sends no answer.
      * @public
      */
-    transcriptionWebsocketEvent?: TranscriptionWebsocketEvent | undefined;
+    healthcheckWebsocketFrame?: VoiceHealthcheckWebsocketFrame | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * A transcription chunk of caller speech. A client that does its own speech-to-text sends it. When the service does the speech-to-text, the service sends it to the client.
      * @public
      */
-    agentTranscriptionWebsocketEvent?: AgentTranscriptionWebsocketEvent | undefined;
+    transcriptionEvent?: VoiceTranscriptionEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * A transcription chunk of the agent speech, as the caller hears it. It does not start a turn.
      * @public
      */
-    replyWebsocketEvent?: ReplyWebsocketEvent | undefined;
+    agentTranscriptionEvent?: VoiceAgentTranscriptionEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * A final caller utterance. It starts an agent turn.
      * @public
      */
-    playbackWebsocketEvent?: PlaybackWebsocketEvent | undefined;
+    replyEvent?: VoiceReplyEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * Progress of the playback of a reply on the client.
      * @public
      */
-    interruptionWebsocketEvent?: InterruptionWebsocketEvent | undefined;
+    playbackEvent?: VoicePlaybackEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * The caller spoke over a reply while the client played it.
      * @public
      */
-    completeWebsocketEvent?: CompleteWebsocketEvent | undefined;
+    interruptionEvent?: VoiceInterruptionEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * The call or the conversation is complete, for example because the caller hung up. The service ends the session. The service also accepts `type` `ended` with the same meaning.
      * @public
      */
-    controlWebsocketEvent?: ControlWebsocketEvent | undefined;
+    completeEvent?: VoiceCompleteEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * The session is ready. Sent once after the handshake, on the PBX voice socket only when the client sends protocol version 1 or more.
      * @public
      */
-    sessionStartedWebsocketEvent?: SessionStartedWebsocketEvent | undefined;
+    sessionStartedEvent?: VoiceSessionStartedEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * The session ended. This is the last event of the session.
      * @public
      */
-    sessionEndedWebsocketEvent?: SessionEndedWebsocketEvent | undefined;
+    sessionEndedEvent?: VoiceSessionEndedEvent | undefined;
     /**
-     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * An error on the connection. The session continues, unless a `ended` event follows.
      * @public
      */
-    errorWebsocketEvent?: ErrorWebsocketEvent | undefined;
+    errorEvent?: VoiceErrorEvent | undefined;
     /**
-     * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
+     * Play a reply to the caller. When `audio` is present, the service sends the audio of the reply in `play` commands. When `audio` is absent, the client shows `text` or synthesizes it itself.
      * @public
      */
-    sayWebsocketCommand?: SayWebsocketCommand | undefined;
+    sayCommand?: VoiceSayCommandData | undefined;
     /**
-     * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
+     * A chunk of synthesized audio of a reply. `data` is base64 of PCM audio at the sample rate of the `say` command. An empty `data` marks the end of the stream.
      * @public
      */
-    playWebsocketCommand?: PlayWebsocketCommand | undefined;
+    playCommand?: VoicePlayCommandData | undefined;
     /**
-     * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
+     * Stop the audio of the agent.
      * @public
      */
-    stopWebsocketCommand?: StopWebsocketCommand | undefined;
+    stopCommand?: VoiceStopCommandData | undefined;
     /**
-     * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
+     * End the session and hang up the call.
      * @public
      */
-    hangupWebsocketCommand?: HangupWebsocketCommand | undefined;
+    hangupCommand?: VoiceHangupCommandData | undefined;
     /**
-     * Envelope of a WebSocket command frame: `\{ "type": "command", "command": \{ ... \} \}`.
+     * Transfer the call to a PBX destination and end the session. Only a PBX client does the transfer.
      * @public
      */
-    transferWebsocketCommand?: TransferWebsocketCommand | undefined;
+    transferCommand?: VoiceTransferCommandData | undefined;
     /**
      * One event of the StreamCallEvents SSE stream (`event:` is the member name, `data:` its JSON). Listed here so the generated SDKs carry the union; the stream body itself is an opaque byte stream.
      * @public
      */
     callEvent?: VoiceCallEvent | undefined;
     /**
-     * Messages of the PBX media socket `/v2/voice/media/ws` (subprotocol `wilma-media-v2`): one example of each. The binary audio messages are base64 here and raw bytes on the socket.
+     * Text messages of the call socket `/v2/voice/calls/ws`: one example of each.
      * @public
      */
-    media?: MediaProtocolFrames | undefined;
+    callSocket?: VoiceCallProtocolFrames | undefined;
 }
 /**
  * @public
@@ -1936,13 +1638,17 @@ export interface ListVoicesOutput {
     voices: Voice[];
 }
 /**
- * Terminate the session and hang up the call.
+ * End the session and hang up the call.
  * @public
  */
 export interface SendHangupInput {
+    /**
+     * Why the session ended.
+     * @public
+     */
     reason?: string | undefined;
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Id of the voice session.
      * @public
      */
     sessionId: string;
@@ -1953,23 +1659,15 @@ export interface SendHangupInput {
 export interface SendHangupOutput {
 }
 /**
- * A chunk of synthesized reply audio to play. `data` is base64, PCM-encoded at the sample rate declared in the matching `say` command; an empty `data` marks the end of the stream.
+ * A chunk of synthesized audio of a reply. `data` is base64 of PCM audio at the sample rate of the `say` command. An empty `data` marks the end of the stream.
  * @public
  */
 export interface SendPlayInput {
-    /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
-     * @public
-     */
     replyId: string;
-    /**
-     * Identifies one synthesized audio stream within a session; carried by a `say` command and the `play` frames that render it.
-     * @public
-     */
     streamId: string;
     data: string;
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Id of the voice session.
      * @public
      */
     sessionId: string;
@@ -1980,40 +1678,32 @@ export interface SendPlayInput {
 export interface SendPlayOutput {
 }
 /**
- * Play a reply to the caller. When `audio` is absent the client performs text-to-speech from `text`; when present the server streams synthesized `play` frames for this reply.
+ * Play a reply to the caller. When `audio` is present, the service sends the audio of the reply in `play` commands. When `audio` is absent, the client shows `text` or synthesizes it itself.
  * @public
  */
 export interface SendSayInput {
-    text: string;
     /**
-     * Correlates a caller phrase, the agent reply it produced, and the playback/interruption of that reply.
+     * Text of the reply.
      * @public
      */
-    replyId: string;
+    text: string;
     /**
-     * Whether the caller may barge in over this reply.
+     * Id of the reply.
      * @public
      */
-    interruptible?: boolean | undefined;
+    replyId: string;
     /**
-     * Bare Amazon Polly voice id, e.g. 'Joanna' — NOT a URI. The PBX consumes this verbatim as the
-     *     AMI `Voice=` action parameter, so it takes exactly what Polly names the voice, with the
-     *     `amazon_polly://` scheme and any query parameters already stripped by whoever builds this
-     *     command out of the agent's stored `VoiceUri`.
-     *
-     *     Set only for a provider whose synthesis runs ON THE PBX (Amazon Polly); ElevenLabs and Google
-     *     are synthesized in the cloud and streamed as PCM through `play` instead, and leave this
-     *     absent.
+     * True when the caller can interrupt the reply.
      * @public
      */
-    voice?: string | undefined;
+    interruptible?: boolean | undefined;
     /**
-     * Audio-stream parameters when the server synthesizes the reply itself (TTS provider configured on the agent): the `say` is followed by a stream of `play` frames on this stream id.
+     * Audio of a reply that the service synthesizes. `play` commands with this stream id follow the `say` command.
      * @public
      */
-    audio?: SayCommandAudioOptions | undefined;
+    audio?: VoiceSayCommandAudioOptions | undefined;
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Id of the voice session.
      * @public
      */
     sessionId: string;
@@ -2028,7 +1718,7 @@ export interface SendSayOutput {
  */
 export interface SendStopInput {
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Id of the voice session.
      * @public
      */
     sessionId: string;
@@ -2039,14 +1729,22 @@ export interface SendStopInput {
 export interface SendStopOutput {
 }
 /**
- * Transfer the call to a PBX destination and terminate the session. Honoured on PBX clients.
+ * Transfer the call to a PBX destination and end the session. Only a PBX client does the transfer.
  * @public
  */
 export interface SendTransferInput {
+    /**
+     * Dialplan context of the destination.
+     * @public
+     */
     context: string;
+    /**
+     * Extension of the destination.
+     * @public
+     */
     extension: string;
     /**
-     * Caller-facing voice session identifier, unique per connection. Supplied by the client at connect (the PBX call/session id, or a client-generated id for web sessions).
+     * Id of the voice session.
      * @public
      */
     sessionId: string;