@wildix/wilma-voice-client 0.0.1

package/dist-types/WilmaVoice.d.ts

@@ -0,0 +1,70 @@
+import type { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
+import { type DescribeVoiceProtocolCommandInput, type DescribeVoiceProtocolCommandOutput } from "./commands/DescribeVoiceProtocolCommand";
+import { type SendHangupCommandInput, type SendHangupCommandOutput } from "./commands/SendHangupCommand";
+import { type SendPlayCommandInput, type SendPlayCommandOutput } from "./commands/SendPlayCommand";
+import { type SendSayCommandInput, type SendSayCommandOutput } from "./commands/SendSayCommand";
+import { type SendStopCommandInput, type SendStopCommandOutput } from "./commands/SendStopCommand";
+import { type SendTransferCommandInput, type SendTransferCommandOutput } from "./commands/SendTransferCommand";
+import { WilmaVoiceClient } from "./WilmaVoiceClient";
+export interface WilmaVoice {
+    /**
+     * @see {@link DescribeVoiceProtocolCommand}
+     */
+    describeVoiceProtocol(): Promise<DescribeVoiceProtocolCommandOutput>;
+    describeVoiceProtocol(args: DescribeVoiceProtocolCommandInput, options?: __HttpHandlerOptions): Promise<DescribeVoiceProtocolCommandOutput>;
+    describeVoiceProtocol(args: DescribeVoiceProtocolCommandInput, cb: (err: any, data?: DescribeVoiceProtocolCommandOutput) => void): void;
+    describeVoiceProtocol(args: DescribeVoiceProtocolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeVoiceProtocolCommandOutput) => void): void;
+    /**
+     * @see {@link SendHangupCommand}
+     */
+    sendHangup(args: SendHangupCommandInput, options?: __HttpHandlerOptions): Promise<SendHangupCommandOutput>;
+    sendHangup(args: SendHangupCommandInput, cb: (err: any, data?: SendHangupCommandOutput) => void): void;
+    sendHangup(args: SendHangupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SendHangupCommandOutput) => void): void;
+    /**
+     * @see {@link SendPlayCommand}
+     */
+    sendPlay(args: SendPlayCommandInput, options?: __HttpHandlerOptions): Promise<SendPlayCommandOutput>;
+    sendPlay(args: SendPlayCommandInput, cb: (err: any, data?: SendPlayCommandOutput) => void): void;
+    sendPlay(args: SendPlayCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SendPlayCommandOutput) => void): void;
+    /**
+     * @see {@link SendSayCommand}
+     */
+    sendSay(args: SendSayCommandInput, options?: __HttpHandlerOptions): Promise<SendSayCommandOutput>;
+    sendSay(args: SendSayCommandInput, cb: (err: any, data?: SendSayCommandOutput) => void): void;
+    sendSay(args: SendSayCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SendSayCommandOutput) => void): void;
+    /**
+     * @see {@link SendStopCommand}
+     */
+    sendStop(args: SendStopCommandInput, options?: __HttpHandlerOptions): Promise<SendStopCommandOutput>;
+    sendStop(args: SendStopCommandInput, cb: (err: any, data?: SendStopCommandOutput) => void): void;
+    sendStop(args: SendStopCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SendStopCommandOutput) => void): void;
+    /**
+     * @see {@link SendTransferCommand}
+     */
+    sendTransfer(args: SendTransferCommandInput, options?: __HttpHandlerOptions): Promise<SendTransferCommandOutput>;
+    sendTransfer(args: SendTransferCommandInput, cb: (err: any, data?: SendTransferCommandOutput) => void): void;
+    sendTransfer(args: SendTransferCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SendTransferCommandOutput) => void): void;
+}
+/**
+ * Voice-session runtime for the Wilma agent platform. Runs a wilma-agents agent on the voice
+ *     channel over a live WebSocket: it greets, listens, replies via TTS, transfers, hangs up, runs
+ *     tools and looks up knowledge — driven entirely by the agent definition resolved at connect
+ *     (engine, instructions, capabilities and channels.voice settings). This is a runtime only: there
+ *     is no agent/bot CRUD here — agents are authored and versioned in wilma-agents.
+ *
+ *     The WebSocket (transport host `wilma-voice-ws.wildix.com`) preserves the wim-voicebots message
+ *     protocol so existing PBX clients work unchanged: the PBX transcribes caller speech and sends
+ *     `transcription` / `reply` text, and the service returns `say` / `play` / `stop` / `hangup` /
+ *     `transfer`. In addition, web/app clients connect with inputMode=AUDIO and push raw caller `audio`
+ *     chunks, which the service transcribes server-side. Every WebSocket message shape (connect params,
+ *     events and commands) is declared as a structure and enumerated by DescribeVoiceProtocol so the
+ *     generated SDKs carry the types and (de)serializers; the WebSocket transport itself is hand-coded,
+ *     as in wim-voicebots. The HTTP Send* operations push the same commands into a live session
+ *     out-of-band.
+ *
+ *     Session observability and history are recorded in wilma-traces; this service does not expose
+ *     bot configuration, traces or listing.
+ * @public
+ */
+export declare class WilmaVoice extends WilmaVoiceClient implements WilmaVoice {
+}

package/dist-types/WilmaVoiceClient.d.ts

@@ -0,0 +1,185 @@
+import { type HostHeaderInputConfig, type HostHeaderResolvedConfig, type UserAgentInputConfig, type UserAgentResolvedConfig } from "@aws-sdk/core/client";
+import { type DefaultsMode as __DefaultsMode, type SmithyConfiguration as __SmithyConfiguration, type SmithyResolvedConfiguration as __SmithyResolvedConfiguration, Client as __Client } from "@smithy/core/client";
+import { type EndpointInputConfig, type EndpointResolvedConfig } from "@smithy/core/endpoints";
+import { type HttpHandlerUserInput as __HttpHandlerUserInput } from "@smithy/core/protocols";
+import { type RetryInputConfig, type RetryResolvedConfig } from "@smithy/core/retry";
+import type { BodyLengthCalculator as __BodyLengthCalculator, CheckOptionalClientConfig as __CheckOptionalClientConfig, ChecksumConstructor as __ChecksumConstructor, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@smithy/types";
+import { type HttpAuthSchemeInputConfig, type HttpAuthSchemeResolvedConfig } from "./auth/httpAuthSchemeProvider";
+import type { DescribeVoiceProtocolCommandInput, DescribeVoiceProtocolCommandOutput } from "./commands/DescribeVoiceProtocolCommand";
+import type { SendHangupCommandInput, SendHangupCommandOutput } from "./commands/SendHangupCommand";
+import type { SendPlayCommandInput, SendPlayCommandOutput } from "./commands/SendPlayCommand";
+import type { SendSayCommandInput, SendSayCommandOutput } from "./commands/SendSayCommand";
+import type { SendStopCommandInput, SendStopCommandOutput } from "./commands/SendStopCommand";
+import type { SendTransferCommandInput, SendTransferCommandOutput } from "./commands/SendTransferCommand";
+import { type ClientInputEndpointParameters, type ClientResolvedEndpointParameters, type EndpointParameters } from "./endpoint/EndpointParameters";
+import { type RuntimeExtension, type RuntimeExtensionsConfig } from "./runtimeExtensions";
+export { __Client };
+/**
+ * @public
+ */
+export type ServiceInputTypes = DescribeVoiceProtocolCommandInput | SendHangupCommandInput | SendPlayCommandInput | SendSayCommandInput | SendStopCommandInput | SendTransferCommandInput;
+/**
+ * @public
+ */
+export type ServiceOutputTypes = DescribeVoiceProtocolCommandOutput | SendHangupCommandOutput | SendPlayCommandOutput | SendSayCommandOutput | SendStopCommandOutput | SendTransferCommandOutput;
+/**
+ * @public
+ */
+export interface ClientDefaults extends Partial<__SmithyConfiguration<__HttpHandlerOptions>> {
+    /**
+     * The HTTP handler to use or its constructor options. Fetch in browser and Https in Nodejs.
+     */
+    requestHandler?: __HttpHandlerUserInput;
+    /**
+     * A constructor for a class implementing the {@link @smithy/types#ChecksumConstructor} interface
+     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
+     * @internal
+     */
+    sha256?: __ChecksumConstructor | __HashConstructor;
+    /**
+     * The function that will be used to convert strings into HTTP endpoints.
+     * @internal
+     */
+    urlParser?: __UrlParser;
+    /**
+     * A function that can calculate the length of a request body.
+     * @internal
+     */
+    bodyLengthChecker?: __BodyLengthCalculator;
+    /**
+     * A function that converts a stream into an array of bytes.
+     * @internal
+     */
+    streamCollector?: __StreamCollector;
+    /**
+     * The function that will be used to convert a base64-encoded string to a byte array.
+     * @internal
+     */
+    base64Decoder?: __Decoder;
+    /**
+     * The function that will be used to convert binary data to a base64-encoded string.
+     * @internal
+     */
+    base64Encoder?: __Encoder;
+    /**
+     * The function that will be used to convert a UTF8-encoded string to a byte array.
+     * @internal
+     */
+    utf8Decoder?: __Decoder;
+    /**
+     * The function that will be used to convert binary data to a UTF-8 encoded string.
+     * @internal
+     */
+    utf8Encoder?: __Encoder;
+    /**
+     * The runtime environment.
+     * @internal
+     */
+    runtime?: string;
+    /**
+     * Disable dynamically changing the endpoint of the client based on the hostPrefix
+     * trait of an operation.
+     */
+    disableHostPrefix?: boolean;
+    /**
+     * Setting a client profile is similar to setting a value for the
+     * AWS_PROFILE environment variable. Setting a profile on a client
+     * in code only affects the single client instance, unlike AWS_PROFILE.
+     *
+     * When set, and only for environments where an AWS configuration
+     * file exists, fields configurable by this file will be retrieved
+     * from the specified profile within that file.
+     * Conflicting code configuration and environment variables will
+     * still have higher priority.
+     *
+     * For client credential resolution that involves checking the AWS
+     * configuration file, the client's profile (this value) will be
+     * used unless a different profile is set in the credential
+     * provider options.
+     *
+     */
+    profile?: string;
+    /**
+     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
+     * @internal
+     */
+    defaultUserAgentProvider?: __Provider<__UserAgent>;
+    /**
+     * Value for how many times a request will be made at most in case of retry.
+     */
+    maxAttempts?: number | __Provider<number>;
+    /**
+     * Specifies which retry algorithm to use.
+     * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-smithy-util-retry/Enum/RETRY_MODES/
+     *
+     */
+    retryMode?: string | __Provider<string>;
+    /**
+     * Optional logger for logging debug/info/warn/error.
+     */
+    logger?: __Logger;
+    /**
+     * Optional extensions
+     */
+    extensions?: RuntimeExtension[];
+    /**
+     * The {@link @smithy/smithy-client#DefaultsMode} that will be used to determine how certain default configuration options are resolved in the SDK.
+     */
+    defaultsMode?: __DefaultsMode | __Provider<__DefaultsMode>;
+}
+/**
+ * @public
+ */
+export type WilmaVoiceClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & UserAgentInputConfig & RetryInputConfig & HostHeaderInputConfig & EndpointInputConfig<EndpointParameters> & HttpAuthSchemeInputConfig & ClientInputEndpointParameters;
+/**
+ * @public
+ *
+ *  The configuration interface of WilmaVoiceClient class constructor that set the region, credentials and other options.
+ */
+export interface WilmaVoiceClientConfig extends WilmaVoiceClientConfigType {
+}
+/**
+ * @public
+ */
+export type WilmaVoiceClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RuntimeExtensionsConfig & UserAgentResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & EndpointResolvedConfig<EndpointParameters> & HttpAuthSchemeResolvedConfig & ClientResolvedEndpointParameters;
+/**
+ * @public
+ *
+ *  The resolved configuration interface of WilmaVoiceClient class. This is resolved and normalized from the {@link WilmaVoiceClientConfig | constructor configuration interface}.
+ */
+export interface WilmaVoiceClientResolvedConfig extends WilmaVoiceClientResolvedConfigType {
+}
+/**
+ * Voice-session runtime for the Wilma agent platform. Runs a wilma-agents agent on the voice
+ *     channel over a live WebSocket: it greets, listens, replies via TTS, transfers, hangs up, runs
+ *     tools and looks up knowledge — driven entirely by the agent definition resolved at connect
+ *     (engine, instructions, capabilities and channels.voice settings). This is a runtime only: there
+ *     is no agent/bot CRUD here — agents are authored and versioned in wilma-agents.
+ *
+ *     The WebSocket (transport host `wilma-voice-ws.wildix.com`) preserves the wim-voicebots message
+ *     protocol so existing PBX clients work unchanged: the PBX transcribes caller speech and sends
+ *     `transcription` / `reply` text, and the service returns `say` / `play` / `stop` / `hangup` /
+ *     `transfer`. In addition, web/app clients connect with inputMode=AUDIO and push raw caller `audio`
+ *     chunks, which the service transcribes server-side. Every WebSocket message shape (connect params,
+ *     events and commands) is declared as a structure and enumerated by DescribeVoiceProtocol so the
+ *     generated SDKs carry the types and (de)serializers; the WebSocket transport itself is hand-coded,
+ *     as in wim-voicebots. The HTTP Send* operations push the same commands into a live session
+ *     out-of-band.
+ *
+ *     Session observability and history are recorded in wilma-traces; this service does not expose
+ *     bot configuration, traces or listing.
+ * @public
+ */
+export declare class WilmaVoiceClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig> {
+    /**
+     * The resolved configuration of WilmaVoiceClient class. This is resolved and normalized from the {@link WilmaVoiceClientConfig | constructor configuration interface}.
+     */
+    readonly config: WilmaVoiceClientResolvedConfig;
+    constructor(...[configuration]: __CheckOptionalClientConfig<WilmaVoiceClientConfig>);
+    /**
+     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+     */
+    destroy(): void;
+}

package/dist-types/auth/httpAuthExtensionConfiguration.d.ts

@@ -0,0 +1,29 @@
+import { type HttpAuthScheme, TokenIdentity, TokenIdentityProvider } from "@smithy/types";
+import type { WilmaVoiceHttpAuthSchemeProvider } from "./httpAuthSchemeProvider";
+/**
+ * @internal
+ */
+export interface HttpAuthExtensionConfiguration {
+    setHttpAuthScheme(httpAuthScheme: HttpAuthScheme): void;
+    httpAuthSchemes(): HttpAuthScheme[];
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider: WilmaVoiceHttpAuthSchemeProvider): void;
+    httpAuthSchemeProvider(): WilmaVoiceHttpAuthSchemeProvider;
+    setToken(token: TokenIdentity | TokenIdentityProvider): void;
+    token(): TokenIdentity | TokenIdentityProvider | undefined;
+}
+/**
+ * @internal
+ */
+export type HttpAuthRuntimeConfig = Partial<{
+    httpAuthSchemes: HttpAuthScheme[];
+    httpAuthSchemeProvider: WilmaVoiceHttpAuthSchemeProvider;
+    token: TokenIdentity | TokenIdentityProvider;
+}>;
+/**
+ * @internal
+ */
+export declare const getHttpAuthExtensionConfiguration: (runtimeConfig: HttpAuthRuntimeConfig) => HttpAuthExtensionConfiguration;
+/**
+ * @internal
+ */
+export declare const resolveHttpAuthRuntimeConfig: (config: HttpAuthExtensionConfiguration) => HttpAuthRuntimeConfig;

package/dist-types/auth/httpAuthSchemeProvider.d.ts

@@ -0,0 +1,81 @@
+import { type HandlerExecutionContext, type HttpAuthScheme, type HttpAuthSchemeParameters, type HttpAuthSchemeParametersProvider, type HttpAuthSchemeProvider, type Provider, TokenIdentity, TokenIdentityProvider } from "@smithy/types";
+import type { WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @internal
+ */
+export interface WilmaVoiceHttpAuthSchemeParameters extends HttpAuthSchemeParameters {
+}
+/**
+ * @internal
+ */
+export interface WilmaVoiceHttpAuthSchemeParametersProvider extends HttpAuthSchemeParametersProvider<WilmaVoiceClientResolvedConfig, HandlerExecutionContext, WilmaVoiceHttpAuthSchemeParameters, object> {
+}
+/**
+ * @internal
+ */
+export declare const defaultWilmaVoiceHttpAuthSchemeParametersProvider: (config: WilmaVoiceClientResolvedConfig, context: HandlerExecutionContext, input: object) => Promise<WilmaVoiceHttpAuthSchemeParameters>;
+/**
+ * @internal
+ */
+export interface WilmaVoiceHttpAuthSchemeProvider extends HttpAuthSchemeProvider<WilmaVoiceHttpAuthSchemeParameters> {
+}
+/**
+ * @internal
+ */
+export declare const defaultWilmaVoiceHttpAuthSchemeProvider: WilmaVoiceHttpAuthSchemeProvider;
+/**
+ * @public
+ */
+export interface HttpAuthSchemeInputConfig {
+    /**
+     * A comma-separated list of case-sensitive auth scheme names.
+     * An auth scheme name is a fully qualified auth scheme ID with the namespace prefix trimmed.
+     * For example, the auth scheme with ID aws.auth#sigv4 is named sigv4.
+     * @public
+     */
+    authSchemePreference?: string[] | Provider<string[]>;
+    /**
+     * Configuration of HttpAuthSchemes for a client which provides default identity providers and signers per auth scheme.
+     * @internal
+     */
+    httpAuthSchemes?: HttpAuthScheme[];
+    /**
+     * Configuration of an HttpAuthSchemeProvider for a client which resolves which HttpAuthScheme to use.
+     * @internal
+     */
+    httpAuthSchemeProvider?: WilmaVoiceHttpAuthSchemeProvider;
+    /**
+     * The token used to authenticate requests.
+     */
+    token?: TokenIdentity | TokenIdentityProvider;
+}
+/**
+ * @internal
+ */
+export interface HttpAuthSchemeResolvedConfig {
+    /**
+     * A comma-separated list of case-sensitive auth scheme names.
+     * An auth scheme name is a fully qualified auth scheme ID with the namespace prefix trimmed.
+     * For example, the auth scheme with ID aws.auth#sigv4 is named sigv4.
+     * @public
+     */
+    readonly authSchemePreference: Provider<string[]>;
+    /**
+     * Configuration of HttpAuthSchemes for a client which provides default identity providers and signers per auth scheme.
+     * @internal
+     */
+    readonly httpAuthSchemes: HttpAuthScheme[];
+    /**
+     * Configuration of an HttpAuthSchemeProvider for a client which resolves which HttpAuthScheme to use.
+     * @internal
+     */
+    readonly httpAuthSchemeProvider: WilmaVoiceHttpAuthSchemeProvider;
+    /**
+     * The token used to authenticate requests.
+     */
+    readonly token?: TokenIdentityProvider;
+}
+/**
+ * @internal
+ */
+export declare const resolveHttpAuthSchemeConfig: <T>(config: T & HttpAuthSchemeInputConfig) => T & HttpAuthSchemeResolvedConfig;

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

@@ -0,0 +1,252 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { DescribeVoiceProtocolInput, DescribeVoiceProtocolOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link DescribeVoiceProtocolCommand}.
+ */
+export interface DescribeVoiceProtocolCommandInput extends DescribeVoiceProtocolInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link DescribeVoiceProtocolCommand}.
+ */
+export interface DescribeVoiceProtocolCommandOutput extends DescribeVoiceProtocolOutput, __MetadataBearer {
+}
+declare const DescribeVoiceProtocolCommand_base: {
+    new (input: DescribeVoiceProtocolCommandInput): import("@smithy/core/client").CommandImpl<DescribeVoiceProtocolCommandInput, DescribeVoiceProtocolCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (...[input]: [] | [DescribeVoiceProtocolCommandInput]): import("@smithy/core/client").CommandImpl<DescribeVoiceProtocolCommandInput, DescribeVoiceProtocolCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Describes the WebSocket connect parameters, events and commands of the voice protocol. Utility method; the generated shapes are the source of truth for building a WebSocket client or server by hand.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, DescribeVoiceProtocolCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, DescribeVoiceProtocolCommand } = 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 = {};
+ * const command = new DescribeVoiceProtocolCommand(input);
+ * const response = await client.send(command);
+ * // { // DescribeVoiceProtocolOutput
+ * //   connectParams: { // VoiceConnectParams
+ * //     protocolVersion: Number("int"),
+ * //     sessionId: "STRING_VALUE", // required
+ * //     agentId: "STRING_VALUE", // required
+ * //     agentDeployment: "STRING_VALUE",
+ * //     agentVersion: Number("int"),
+ * //     agentDraft: true || false,
+ * //     callId: "STRING_VALUE",
+ * //     language: "STRING_VALUE",
+ * //     callerName: "STRING_VALUE",
+ * //     callerNumber: "STRING_VALUE",
+ * //     callerEmail: "STRING_VALUE",
+ * //     callerCompany: "STRING_VALUE",
+ * //     voice: "STRING_VALUE",
+ * //     initialMessage: "STRING_VALUE",
+ * //     variables: "STRING_VALUE",
+ * //     inputMode: "transcription" || "audio",
+ * //     inputAudio: { // VoiceAudioFormat
+ * //       encoding: "pcm_s16le" || "mulaw" || "alaw" || "opus", // required
+ * //       sampleRate: Number("int"), // required
+ * //       channels: Number("int"),
+ * //     },
+ * //     outputAudio: {
+ * //       encoding: "pcm_s16le" || "mulaw" || "alaw" || "opus", // required
+ * //       sampleRate: Number("int"), // required
+ * //       channels: Number("int"),
+ * //     },
+ * //   },
+ * //   audioWebsocketEvent: { // AudioWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // AudioEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       data: "STRING_VALUE", // required
+ * //       seq: Number("int"),
+ * //     },
+ * //   },
+ * //   transcriptionWebsocketEvent: { // TranscriptionWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // TranscriptionEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       id: "STRING_VALUE", // required
+ * //       text: "STRING_VALUE", // required
+ * //       confidence: Number("double"),
+ * //       final: true || false,
+ * //       time: Number("long"), // required
+ * //     },
+ * //   },
+ * //   replyWebsocketEvent: { // ReplyWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // ReplyEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       id: "STRING_VALUE", // required
+ * //       text: "STRING_VALUE", // required
+ * //       startTime: Number("long"), // required
+ * //       endTime: Number("long"), // required
+ * //     },
+ * //   },
+ * //   playbackWebsocketEvent: { // PlaybackWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // PlaybackEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       replyId: "STRING_VALUE", // required
+ * //       text: "STRING_VALUE", // required
+ * //       complete: true || false, // required
+ * //       startTime: Number("long"), // required
+ * //       endTime: Number("long"),
+ * //     },
+ * //   },
+ * //   interruptionWebsocketEvent: { // InterruptionWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // InterruptionEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       replyId: "STRING_VALUE", // required
+ * //       playedText: "STRING_VALUE", // required
+ * //       originalText: "STRING_VALUE", // required
+ * //       time: Number("long"), // required
+ * //     },
+ * //   },
+ * //   completeWebsocketEvent: { // CompleteWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // CompleteEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       reason: "STRING_VALUE", // required
+ * //       time: Number("long"), // required
+ * //     },
+ * //   },
+ * //   controlWebsocketEvent: { // ControlWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // ControlEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       action: "end_of_turn" || "clear" || "keepalive", // required
+ * //     },
+ * //   },
+ * //   sessionStartedWebsocketEvent: { // SessionStartedWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // SessionStartedEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       time: Number("long"), // required
+ * //       sessionId: "STRING_VALUE", // required
+ * //       agentId: "STRING_VALUE", // required
+ * //       agentVersion: Number("int"),
+ * //       agentName: "STRING_VALUE",
+ * //       category: "STRING_VALUE",
+ * //       groupId: "STRING_VALUE",
+ * //       inputAudio: {
+ * //         encoding: "pcm_s16le" || "mulaw" || "alaw" || "opus", // required
+ * //         sampleRate: Number("int"), // required
+ * //         channels: Number("int"),
+ * //       },
+ * //       outputAudio: {
+ * //         encoding: "pcm_s16le" || "mulaw" || "alaw" || "opus", // required
+ * //         sampleRate: Number("int"), // required
+ * //         channels: Number("int"),
+ * //       },
+ * //     },
+ * //   },
+ * //   sessionEndedWebsocketEvent: { // SessionEndedWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // SessionEndedEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       reason: "STRING_VALUE",
+ * //       error: "STRING_VALUE",
+ * //       time: Number("long"), // required
+ * //     },
+ * //   },
+ * //   errorWebsocketEvent: { // ErrorWebsocketEvent
+ * //     type: "STRING_VALUE", // required
+ * //     event: { // VoiceErrorEvent
+ * //       type: "started" || "ended" || "error" || "audio" || "transcription" || "reply" || "playback" || "interruption" || "complete" || "control", // required
+ * //       code: "STRING_VALUE", // required
+ * //       message: "STRING_VALUE", // required
+ * //       time: Number("long"), // required
+ * //     },
+ * //   },
+ * //   sayWebsocketCommand: { // SayWebsocketCommand
+ * //     type: "STRING_VALUE", // required
+ * //     command: { // SayCommandData
+ * //       text: "STRING_VALUE", // required
+ * //       replyId: "STRING_VALUE", // required
+ * //       interruptible: true || false,
+ * //       audio: { // SayCommandAudioOptions
+ * //         streamId: "STRING_VALUE", // required
+ * //         sampleRate: Number("int"), // required
+ * //       },
+ * //       type: "say" || "play" || "stop" || "hangup" || "transfer", // required
+ * //     },
+ * //   },
+ * //   playWebsocketCommand: { // PlayWebsocketCommand
+ * //     type: "STRING_VALUE", // required
+ * //     command: { // PlayCommandData
+ * //       replyId: "STRING_VALUE", // required
+ * //       streamId: "STRING_VALUE", // required
+ * //       data: "STRING_VALUE", // required
+ * //       type: "say" || "play" || "stop" || "hangup" || "transfer", // required
+ * //     },
+ * //   },
+ * //   stopWebsocketCommand: { // StopWebsocketCommand
+ * //     type: "STRING_VALUE", // required
+ * //     command: { // StopCommandData
+ * //       type: "say" || "play" || "stop" || "hangup" || "transfer", // required
+ * //     },
+ * //   },
+ * //   hangupWebsocketCommand: { // HangupWebsocketCommand
+ * //     type: "STRING_VALUE", // required
+ * //     command: { // HangupCommandData
+ * //       reason: "STRING_VALUE",
+ * //       type: "say" || "play" || "stop" || "hangup" || "transfer", // required
+ * //     },
+ * //   },
+ * //   transferWebsocketCommand: { // TransferWebsocketCommand
+ * //     type: "STRING_VALUE", // required
+ * //     command: { // TransferCommandData
+ * //       context: "STRING_VALUE", // required
+ * //       extension: "STRING_VALUE", // required
+ * //       type: "say" || "play" || "stop" || "hangup" || "transfer", // required
+ * //     },
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param DescribeVoiceProtocolCommandInput - {@link DescribeVoiceProtocolCommandInput}
+ * @returns {@link DescribeVoiceProtocolCommandOutput}
+ * @see {@link DescribeVoiceProtocolCommandInput} for command's `input` shape.
+ * @see {@link DescribeVoiceProtocolCommandOutput} for command's `response` shape.
+ * @see {@link WilmaVoiceClientResolvedConfig | config} for WilmaVoiceClient's `config` shape.
+ *
+ * @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 DescribeVoiceProtocolCommand extends DescribeVoiceProtocolCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: {};
+            output: DescribeVoiceProtocolOutput;
+        };
+        sdk: {
+            input: DescribeVoiceProtocolCommandInput;
+            output: DescribeVoiceProtocolCommandOutput;
+        };
+    };
+}