@wildix/wilma-voice-client 0.0.31 → 0.0.34

package/dist-types/commands/StreamCallEventsCommand.d.ts

@@ -0,0 +1,91 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer, StreamingBlobPayloadOutputTypes } from "@smithy/types";
+import type { StreamCallEventsInput, StreamCallEventsOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link StreamCallEventsCommand}.
+ */
+export interface StreamCallEventsCommandInput extends StreamCallEventsInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link StreamCallEventsCommand}.
+ */
+export interface StreamCallEventsCommandOutput extends Omit<StreamCallEventsOutput, "events">, __MetadataBearer {
+    events: StreamingBlobPayloadOutputTypes;
+}
+declare const StreamCallEventsCommand_base: {
+    new (input: StreamCallEventsCommandInput): import("@smithy/core/client").CommandImpl<StreamCallEventsCommandInput, StreamCallEventsCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: StreamCallEventsCommandInput): import("@smithy/core/client").CommandImpl<StreamCallEventsCommandInput, StreamCallEventsCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Tails a live call's events as Server-Sent Events (`text/event-stream`): the caller's recognised speech, the agent's spoken sentences, playback, interruptions, language switches and the session lifecycle. Live only — nothing before the subscription is replayed, and the stream is not a record of the call (the session trace is). Ends after an `ended` event whose reason is not `transfer`; after a transfer it stays open briefly for the next session of the same call. `include=tools` adds tool events and is honoured only for management-class callers.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, StreamCallEventsCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, StreamCallEventsCommand } = require("@wildix/wilma-voice-client"); // CommonJS import
+ * // import type { WilmaVoiceClientConfig } from "@wildix/wilma-voice-client";
+ * const config = {}; // type is WilmaVoiceClientConfig
+ * const client = new WilmaVoiceClient(config);
+ * const input = { // StreamCallEventsInput
+ *   callId: "STRING_VALUE", // required
+ *   company: "STRING_VALUE",
+ *   include: [ // VoiceCallEventIncludeList
+ *     "commands" || "tools",
+ *   ],
+ * };
+ * const command = new StreamCallEventsCommand(input);
+ * const response = await client.send(command);
+ * // consume or destroy the stream to free the socket.
+ * const bytes = await response.events.transformToByteArray();
+ * // const str = await response.events.transformToString();
+ * // response.events.destroy(); // only applicable to Node.js Readable streams.
+ *
+ * // { // StreamCallEventsOutput
+ * //   events: "<SdkStream>", // see \@smithy/types -> StreamingBlobPayloadOutputTypes // required
+ * //   contentType: "STRING_VALUE", // required
+ * // };
+ *
+ * ```
+ *
+ * @param StreamCallEventsCommandInput - {@link StreamCallEventsCommandInput}
+ * @returns {@link StreamCallEventsCommandOutput}
+ * @see {@link StreamCallEventsCommandInput} for command's `input` shape.
+ * @see {@link StreamCallEventsCommandOutput} for command's `response` shape.
+ * @see {@link WilmaVoiceClientResolvedConfig | config} for WilmaVoiceClient's `config` shape.
+ *
+ * @throws {@link NotFoundException} (client fault)
+ *
+ * @throws {@link ValidationException} (client fault)
+ *
+ * @throws {@link ForbiddenException} (client fault)
+ *
+ * @throws {@link WilmaVoiceServiceException}
+ * <p>Base exception class for all service exceptions from WilmaVoice service.</p>
+ *
+ *
+ * @public
+ */
+export declare class StreamCallEventsCommand extends StreamCallEventsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: StreamCallEventsInput;
+            output: StreamCallEventsOutput;
+        };
+        sdk: {
+            input: StreamCallEventsCommandInput;
+            output: StreamCallEventsCommandOutput;
+        };
+    };
+}

package/dist-types/commands/index.d.ts

@@ -5,4 +5,5 @@ export * from "./SendPlayCommand";
 export * from "./SendSayCommand";
 export * from "./SendStopCommand";
 export * from "./SendTransferCommand";
+export * from "./StreamCallEventsCommand";
 export * from "./TextToSpeechCommand";

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

@@ -21,6 +21,7 @@ export type VoicePronunciationEncoding = (typeof VoicePronunciationEncoding)[key
  * @enum
  */
 export declare const VoiceEventType: {
+    readonly AGENT_TRANSCRIPTION: "agentTranscription";
     readonly AUDIO: "audio";
     readonly COMPLETE: "complete";
     readonly CONTROL: "control";
@@ -58,6 +59,33 @@ export declare const VoiceControlAction: {
  * @public
  */
 export type VoiceControlAction = (typeof VoiceControlAction)[keyof typeof VoiceControlAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceCallEndReason: {
+    readonly COMPLETE: "complete";
+    readonly ERROR: "error";
+    readonly HANGUP: "hangup";
+    readonly TIMEOUT: "timeout";
+    readonly TRANSFER: "transfer";
+};
+/**
+ * @public
+ */
+export type VoiceCallEndReason = (typeof VoiceCallEndReason)[keyof typeof VoiceCallEndReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceCallToolPhase: {
+    readonly FINISHED: "finished";
+    readonly STARTED: "started";
+};
+/**
+ * @public
+ */
+export type VoiceCallToolPhase = (typeof VoiceCallToolPhase)[keyof typeof VoiceCallToolPhase];
 /**
  * @public
  * @enum
@@ -117,3 +145,15 @@ export declare const VoiceCommandType: {
  * @public
  */
 export type VoiceCommandType = (typeof VoiceCommandType)[keyof typeof VoiceCommandType];
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceCallEventInclude: {
+    readonly COMMANDS: "commands";
+    readonly TOOLS: "tools";
+};
+/**
+ * @public
+ */
+export type VoiceCallEventInclude = (typeof VoiceCallEventInclude)[keyof typeof VoiceCallEventInclude];

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

@@ -1,5 +1,5 @@
-import type { DocumentType as __DocumentType } from "@smithy/types";
-import type { VoiceAudioEncoding, VoiceCommandType, VoiceControlAction, VoiceEventType, VoiceInputMode, VoicePronunciationEncoding } from "./enums";
+import type { DocumentType as __DocumentType, StreamingBlobTypes } from "@smithy/types";
+import type { VoiceAudioEncoding, VoiceCallEndReason, VoiceCallEventInclude, VoiceCallToolPhase, VoiceCommandType, VoiceControlAction, VoiceEventType, VoiceInputMode, VoicePronunciationEncoding } 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
@@ -24,6 +24,51 @@ 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.
+ * @public
+ */
+export interface AgentTranscriptionEvent {
+    /**
+     * Discriminator for the inner payload of an `event` frame.
+     * @public
+     */
+    type: VoiceEventType;
+    /**
+     * Identifier of a transcription chunk within a session.
+     * @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.
+     * @public
+     */
+    confidence?: number | undefined;
+    /**
+     * True when this is the final transcript for the utterance rather than an interim hypothesis.
+     * @public
+     */
+    final?: boolean | undefined;
+    /**
+     * Language the recogniser identified for this chunk. Recorded in the trace only — it drives no behavior.
+     * @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.
+     * @public
+     */
+    event: AgentTranscriptionEvent;
+}
 /**
  * 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
@@ -115,6 +160,348 @@ export interface ControlWebsocketEvent {
  */
 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;
+    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 {
+    /**
+     * 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).
+     * @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 {
+    from?: string | undefined;
+    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;
+    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 {
+    /**
+     * 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).
+     * @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 only to management callers that asked for `include=tools`.
+ * @public
+ */
+export interface VoiceCallToolEvent {
+    callId: string;
+    toolName: string;
+    phase: VoiceCallToolPhase;
+    /**
+     * 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;
+    language?: string | undefined;
+    /**
+     * Milliseconds since the call started, as the PBX stamps it.
+     * @public
+     */
+    time?: number | undefined;
+}
+/**
+ * One event on a live call. The SSE frame's `event:` is the member name and `data:` the member's JSON.
+ * @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;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * The caller's completed utterance that started a turn — after the runtime's filler and duplicate filter.
+     * @public
+     */
+    interface ReplyMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply: VoiceCallReplyEvent;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * One sentence the agent speaks, as it is handed to the PBX (after playback sanitizing). Sentences of one reply share `replyId`.
+     * @public
+     */
+    interface SayMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say: VoiceCallSayEvent;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * The PBX finished (or abandoned) playing a reply.
+     * @public
+     */
+    interface PlaybackMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback: VoiceCallPlaybackEvent;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * The caller talked over the agent. `playedText` is what they heard before the cut.
+     * @public
+     */
+    interface InterruptionMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback?: never;
+        interruption: VoiceCallInterruptionEvent;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * The conversation language changed on a recognised utterance.
+     * @public
+     */
+    interface LanguageMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language: VoiceCallLanguageEvent;
+        tool?: never;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * A tool call the agent made during a turn. Name and phase only — arguments and results live in the trace. Sent only to management callers that asked for `include=tools`.
+     * @public
+     */
+    interface ToolMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool: VoiceCallToolEvent;
+        ended?: never;
+        $unknown?: never;
+    }
+    /**
+     * The session ended. After `transfer` another session of the same call may follow with its own `started`.
+     * @public
+     */
+    interface EndedMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended: VoiceCallEndedEvent;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        started?: never;
+        transcription?: never;
+        agentTranscription?: never;
+        reply?: never;
+        say?: never;
+        playback?: never;
+        interruption?: never;
+        language?: never;
+        tool?: never;
+        ended?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        started: (value: VoiceCallStartedEvent) => T;
+        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
@@ -157,7 +544,7 @@ export interface VoiceConnectParams {
      */
     agentId: string;
     /**
-     * Published agent version to run. Mutually exclusive with agentDraft. When neither is set, the agent's deployment configuration selects the version.
+     * 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;
@@ -171,6 +558,16 @@ export interface VoiceConnectParams {
      * @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
@@ -738,6 +1135,11 @@ export interface DescribeVoiceProtocolOutput {
      * @public
      */
     transcriptionWebsocketEvent?: TranscriptionWebsocketEvent | undefined;
+    /**
+     * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
+     * @public
+     */
+    agentTranscriptionWebsocketEvent?: AgentTranscriptionWebsocketEvent | undefined;
     /**
      * Envelope of a WebSocket event frame: `\{ "type": "event", "event": \{ ... \} \}`.
      * @public
@@ -803,6 +1205,11 @@ export interface DescribeVoiceProtocolOutput {
      * @public
      */
     transferWebsocketCommand?: TransferWebsocketCommand | 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;
 }
 /**
  * @public
@@ -986,6 +1393,33 @@ export interface SendTransferInput {
  */
 export interface SendTransferOutput {
 }
+/**
+ * @public
+ */
+export interface StreamCallEventsInput {
+    /**
+     * The PBX call id (LinkedID) — `callId` of the voice session's connect query, and the SIP `X-Session-ID` header the caller's own leg received.
+     * @public
+     */
+    callId: string;
+    /**
+     * Owning company. Only S2S callers may set it; every other token carries its company.
+     * @public
+     */
+    company?: string | undefined;
+    include?: VoiceCallEventInclude[] | undefined;
+}
+/**
+ * @public
+ */
+export interface StreamCallEventsOutput {
+    /**
+     * Raw Server-Sent Events byte stream (`text/event-stream`). Each frame carries one VoiceCallEvent: `id:` is a per-connection counter (there is no replay), `event:` the union member name, `data:` the JSON document of the union value, e.g. `\{"say": \{...\}\}`.
+     * @public
+     */
+    events: StreamingBlobTypes;
+    contentType: string;
+}
 /**
  * @public
  */

package/dist-types/runtimeConfig.browser.d.ts

@@ -29,6 +29,7 @@ export declare const getRuntimeConfig: (config: WilmaVoiceClientConfig) => {
     profile?: string;
     logger: import("@smithy/types").Logger;
     extensions: import("./runtimeExtensions").RuntimeExtension[];
+    sdkStreamMixin: import("@smithy/types").SdkStreamMixinInjector;
     customUserAgent?: string | import("@smithy/types").UserAgent;
     userAgentAppId?: string | undefined | import("@smithy/types").Provider<string | undefined>;
     retryStrategy?: import("@smithy/types").RetryStrategy | import("@smithy/types").RetryStrategyV2;

package/dist-types/runtimeConfig.d.ts

@@ -30,6 +30,7 @@ export declare const getRuntimeConfig: (config: WilmaVoiceClientConfig) => {
     profile?: string;
     logger: import("@smithy/types").Logger;
     extensions: import("./runtimeExtensions").RuntimeExtension[];
+    sdkStreamMixin: import("@smithy/types").SdkStreamMixinInjector;
     customUserAgent?: string | import("@smithy/types").UserAgent;
     retryStrategy?: import("@smithy/types").RetryStrategy | import("@smithy/types").RetryStrategyV2;
     endpoint?: ((string | import("@smithy/types").Endpoint | import("@smithy/types").Provider<import("@smithy/types").Endpoint> | import("@smithy/types").EndpointV2 | import("@smithy/types").Provider<import("@smithy/types").EndpointV2>) & (string | import("@smithy/types").Provider<string> | import("@smithy/types").Endpoint | import("@smithy/types").Provider<import("@smithy/types").Endpoint> | import("@smithy/types").EndpointV2 | import("@smithy/types").Provider<import("@smithy/types").EndpointV2>)) | undefined;

package/dist-types/runtimeConfig.native.d.ts

@@ -29,6 +29,7 @@ export declare const getRuntimeConfig: (config: WilmaVoiceClientConfig) => {
     logger: import("@smithy/types").Logger;
     extensions: import("./runtimeExtensions").RuntimeExtension[];
     defaultsMode: import("@smithy/core/client").DefaultsMode | import("@smithy/types").Provider<import("@smithy/core/client").DefaultsMode>;
+    sdkStreamMixin: import("@smithy/types").SdkStreamMixinInjector;
     customUserAgent?: string | import("@smithy/types").UserAgent;
     userAgentAppId?: string | undefined | import("@smithy/types").Provider<string | undefined>;
     retryStrategy?: import("@smithy/types").RetryStrategy | import("@smithy/types").RetryStrategyV2;

package/dist-types/runtimeConfig.shared.d.ts

@@ -26,6 +26,7 @@ export declare const getRuntimeConfig: (config: WilmaVoiceClientConfig) => {
         [setting: string]: unknown;
         defaultNamespace?: string;
     };
+    sdkStreamMixin: import("@smithy/types").SdkStreamMixinInjector;
     urlParser: import("@smithy/types").UrlParser;
     utf8Decoder: import("@smithy/types").Decoder;
     utf8Encoder: (input: Uint8Array | string) => string;