@wildix/wilma-voice-client 0.0.1

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

@@ -0,0 +1,79 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { SendHangupInput, SendHangupOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link SendHangupCommand}.
+ */
+export interface SendHangupCommandInput extends SendHangupInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link SendHangupCommand}.
+ */
+export interface SendHangupCommandOutput extends SendHangupOutput, __MetadataBearer {
+}
+declare const SendHangupCommand_base: {
+    new (input: SendHangupCommandInput): import("@smithy/core/client").CommandImpl<SendHangupCommandInput, SendHangupCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: SendHangupCommandInput): import("@smithy/core/client").CommandImpl<SendHangupCommandInput, SendHangupCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Terminates the voice session and the call.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, SendHangupCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, SendHangupCommand } = 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 = { // SendHangupInput
+ *   reason: "STRING_VALUE",
+ *   sessionId: "STRING_VALUE", // required
+ * };
+ * const command = new SendHangupCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param SendHangupCommandInput - {@link SendHangupCommandInput}
+ * @returns {@link SendHangupCommandOutput}
+ * @see {@link SendHangupCommandInput} for command's `input` shape.
+ * @see {@link SendHangupCommandOutput} for command's `response` shape.
+ * @see {@link WilmaVoiceClientResolvedConfig | config} for WilmaVoiceClient's `config` shape.
+ *
+ * @throws {@link VoiceSessionNotFoundException} (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 SendHangupCommand extends SendHangupCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: SendHangupInput;
+            output: {};
+        };
+        sdk: {
+            input: SendHangupCommandInput;
+            output: SendHangupCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,81 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { SendPlayInput, SendPlayOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link SendPlayCommand}.
+ */
+export interface SendPlayCommandInput extends SendPlayInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link SendPlayCommand}.
+ */
+export interface SendPlayCommandOutput extends SendPlayOutput, __MetadataBearer {
+}
+declare const SendPlayCommand_base: {
+    new (input: SendPlayCommandInput): import("@smithy/core/client").CommandImpl<SendPlayCommandInput, SendPlayCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: SendPlayCommandInput): import("@smithy/core/client").CommandImpl<SendPlayCommandInput, SendPlayCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Plays the specified audio chunk through the audio stream of the voice session.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, SendPlayCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, SendPlayCommand } = 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 = { // SendPlayInput
+ *   replyId: "STRING_VALUE", // required
+ *   streamId: "STRING_VALUE", // required
+ *   data: "STRING_VALUE", // required
+ *   sessionId: "STRING_VALUE", // required
+ * };
+ * const command = new SendPlayCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param SendPlayCommandInput - {@link SendPlayCommandInput}
+ * @returns {@link SendPlayCommandOutput}
+ * @see {@link SendPlayCommandInput} for command's `input` shape.
+ * @see {@link SendPlayCommandOutput} for command's `response` shape.
+ * @see {@link WilmaVoiceClientResolvedConfig | config} for WilmaVoiceClient's `config` shape.
+ *
+ * @throws {@link VoiceSessionNotFoundException} (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 SendPlayCommand extends SendPlayCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: SendPlayInput;
+            output: {};
+        };
+        sdk: {
+            input: SendPlayCommandInput;
+            output: SendPlayCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,85 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { SendSayInput, SendSayOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link SendSayCommand}.
+ */
+export interface SendSayCommandInput extends SendSayInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link SendSayCommand}.
+ */
+export interface SendSayCommandOutput extends SendSayOutput, __MetadataBearer {
+}
+declare const SendSayCommand_base: {
+    new (input: SendSayCommandInput): import("@smithy/core/client").CommandImpl<SendSayCommandInput, SendSayCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: SendSayCommandInput): import("@smithy/core/client").CommandImpl<SendSayCommandInput, SendSayCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Generates and plays the specified text through the audio stream of the voice session.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, SendSayCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, SendSayCommand } = 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 = { // SendSayInput
+ *   text: "STRING_VALUE", // required
+ *   replyId: "STRING_VALUE", // required
+ *   interruptible: true || false,
+ *   audio: { // SayCommandAudioOptions
+ *     streamId: "STRING_VALUE", // required
+ *     sampleRate: Number("int"), // required
+ *   },
+ *   sessionId: "STRING_VALUE", // required
+ * };
+ * const command = new SendSayCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param SendSayCommandInput - {@link SendSayCommandInput}
+ * @returns {@link SendSayCommandOutput}
+ * @see {@link SendSayCommandInput} for command's `input` shape.
+ * @see {@link SendSayCommandOutput} for command's `response` shape.
+ * @see {@link WilmaVoiceClientResolvedConfig | config} for WilmaVoiceClient's `config` shape.
+ *
+ * @throws {@link VoiceSessionNotFoundException} (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 SendSayCommand extends SendSayCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: SendSayInput;
+            output: {};
+        };
+        sdk: {
+            input: SendSayCommandInput;
+            output: SendSayCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,78 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { SendStopInput, SendStopOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link SendStopCommand}.
+ */
+export interface SendStopCommandInput extends SendStopInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link SendStopCommand}.
+ */
+export interface SendStopCommandOutput extends SendStopOutput, __MetadataBearer {
+}
+declare const SendStopCommand_base: {
+    new (input: SendStopCommandInput): import("@smithy/core/client").CommandImpl<SendStopCommandInput, SendStopCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: SendStopCommandInput): import("@smithy/core/client").CommandImpl<SendStopCommandInput, SendStopCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Stops any audio currently being played by the voice session.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, SendStopCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, SendStopCommand } = 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 = { // SendStopInput
+ *   sessionId: "STRING_VALUE", // required
+ * };
+ * const command = new SendStopCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param SendStopCommandInput - {@link SendStopCommandInput}
+ * @returns {@link SendStopCommandOutput}
+ * @see {@link SendStopCommandInput} for command's `input` shape.
+ * @see {@link SendStopCommandOutput} for command's `response` shape.
+ * @see {@link WilmaVoiceClientResolvedConfig | config} for WilmaVoiceClient's `config` shape.
+ *
+ * @throws {@link VoiceSessionNotFoundException} (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 SendStopCommand extends SendStopCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: SendStopInput;
+            output: {};
+        };
+        sdk: {
+            input: SendStopCommandInput;
+            output: SendStopCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,80 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { SendTransferInput, SendTransferOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link SendTransferCommand}.
+ */
+export interface SendTransferCommandInput extends SendTransferInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link SendTransferCommand}.
+ */
+export interface SendTransferCommandOutput extends SendTransferOutput, __MetadataBearer {
+}
+declare const SendTransferCommand_base: {
+    new (input: SendTransferCommandInput): import("@smithy/core/client").CommandImpl<SendTransferCommandInput, SendTransferCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: SendTransferCommandInput): import("@smithy/core/client").CommandImpl<SendTransferCommandInput, SendTransferCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Transfers the call to the specified context and extension, and terminates the voice session.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, SendTransferCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, SendTransferCommand } = 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 = { // SendTransferInput
+ *   context: "STRING_VALUE", // required
+ *   extension: "STRING_VALUE", // required
+ *   sessionId: "STRING_VALUE", // required
+ * };
+ * const command = new SendTransferCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param SendTransferCommandInput - {@link SendTransferCommandInput}
+ * @returns {@link SendTransferCommandOutput}
+ * @see {@link SendTransferCommandInput} for command's `input` shape.
+ * @see {@link SendTransferCommandOutput} for command's `response` shape.
+ * @see {@link WilmaVoiceClientResolvedConfig | config} for WilmaVoiceClient's `config` shape.
+ *
+ * @throws {@link VoiceSessionNotFoundException} (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 SendTransferCommand extends SendTransferCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: SendTransferInput;
+            output: {};
+        };
+        sdk: {
+            input: SendTransferCommandInput;
+            output: SendTransferCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,6 @@
+export * from "./DescribeVoiceProtocolCommand";
+export * from "./SendHangupCommand";
+export * from "./SendPlayCommand";
+export * from "./SendSayCommand";
+export * from "./SendStopCommand";
+export * from "./SendTransferCommand";

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -0,0 +1,41 @@
+import type { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2, Provider } from "@smithy/types";
+/**
+ * @public
+ */
+export interface ClientInputEndpointParameters {
+    clientContextParams?: {
+        env?: string | undefined | Provider<string | undefined>;
+    };
+    env?: string | undefined | Provider<string | undefined>;
+    endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+}
+/**
+ * @public
+ */
+export type ClientResolvedEndpointParameters = Omit<ClientInputEndpointParameters, "endpoint"> & {
+    defaultSigningName: string;
+};
+/**
+ * @internal
+ */
+export declare const resolveClientEndpointParameters: <T>(options: T & ClientInputEndpointParameters) => T & ClientResolvedEndpointParameters;
+/**
+ * @internal
+ */
+export declare const commonParams: {
+    readonly env: {
+        readonly type: "clientContextParams";
+        readonly name: "env";
+    };
+    readonly endpoint: {
+        readonly type: "builtInParams";
+        readonly name: "endpoint";
+    };
+};
+/**
+ * @internal
+ */
+export interface EndpointParameters extends __EndpointParameters {
+    env?: string | undefined;
+    endpoint?: string | undefined;
+}

package/dist-types/endpoint/bdd.d.ts

@@ -0,0 +1,2 @@
+import { BinaryDecisionDiagram } from "@smithy/core/endpoints";
+export declare const bdd: BinaryDecisionDiagram;

package/dist-types/endpoint/endpointResolver.d.ts

@@ -0,0 +1,8 @@
+import type { EndpointV2, Logger } from "@smithy/types";
+import type { EndpointParameters } from "./EndpointParameters";
+/**
+ * @internal
+ */
+export declare const defaultEndpointResolver: (endpointParams: EndpointParameters, context?: {
+    logger?: Logger;
+}) => EndpointV2;

package/dist-types/extensionConfiguration.d.ts

@@ -0,0 +1,8 @@
+import type { HttpHandlerExtensionConfiguration } from "@smithy/core/protocols";
+import type { DefaultExtensionConfiguration } from "@smithy/types";
+import type { HttpAuthExtensionConfiguration } from "./auth/httpAuthExtensionConfiguration";
+/**
+ * @internal
+ */
+export interface WilmaVoiceExtensionConfiguration extends HttpHandlerExtensionConfiguration, DefaultExtensionConfiguration, HttpAuthExtensionConfiguration {
+}

package/dist-types/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ *
+ * @packageDocumentation
+ */
+export * from "./WilmaVoiceClient";
+export * from "./WilmaVoice";
+export type { ClientInputEndpointParameters } from "./endpoint/EndpointParameters";
+export type { RuntimeExtension } from "./runtimeExtensions";
+export type { WilmaVoiceExtensionConfiguration } from "./extensionConfiguration";
+export * from "./commands";
+export * from "./schemas/schemas_0";
+export * from "./models/enums";
+export * from "./models/errors";
+export * from "./models/models_0";
+export { WilmaVoiceServiceException } from "./models/WilmaVoiceServiceException";

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

@@ -0,0 +1,14 @@
+import { type ServiceExceptionOptions as __ServiceExceptionOptions, ServiceException as __ServiceException } from "@smithy/core/client";
+export type { __ServiceExceptionOptions };
+export { __ServiceException };
+/**
+ * @public
+ *
+ * Base exception class for all service exceptions from WilmaVoice service.
+ */
+export declare class WilmaVoiceServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

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

@@ -0,0 +1,101 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceEventType: {
+    readonly AUDIO: "audio";
+    readonly COMPLETE: "complete";
+    readonly CONTROL: "control";
+    readonly ENDED: "ended";
+    readonly ERROR: "error";
+    readonly INTERRUPTION: "interruption";
+    readonly PLAYBACK: "playback";
+    readonly REPLY: "reply";
+    readonly STARTED: "started";
+    readonly TRANSCRIPTION: "transcription";
+};
+/**
+ * @public
+ */
+export type VoiceEventType = (typeof VoiceEventType)[keyof typeof VoiceEventType];
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceControlAction: {
+    /**
+     * Discard buffered caller audio and cancel the in-progress input turn.
+     */
+    readonly CLEAR: "clear";
+    /**
+     * Push-to-talk: the caller finished the current utterance; transcribe and run the agent now.
+     */
+    readonly END_OF_TURN: "end_of_turn";
+    /**
+     * Application-level keepalive.
+     */
+    readonly KEEPALIVE: "keepalive";
+};
+/**
+ * @public
+ */
+export type VoiceControlAction = (typeof VoiceControlAction)[keyof typeof VoiceControlAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceAudioEncoding: {
+    /**
+     * G.711 A-law.
+     */
+    readonly ALAW: "alaw";
+    /**
+     * G.711 μ-law.
+     */
+    readonly MULAW: "mulaw";
+    /**
+     * Opus.
+     */
+    readonly OPUS: "opus";
+    /**
+     * 16-bit signed little-endian linear PCM.
+     */
+    readonly PCM_S16LE: "pcm_s16le";
+};
+/**
+ * @public
+ */
+export type VoiceAudioEncoding = (typeof VoiceAudioEncoding)[keyof typeof VoiceAudioEncoding];
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceInputMode: {
+    /**
+     * The client pushes raw caller `audio` chunks and the service transcribes them server-side (web/app clients).
+     */
+    readonly AUDIO: "audio";
+    /**
+     * The client sends `transcription` / `reply` text events; it performs speech-to-text itself (PBX behaviour, same as wim-voicebots).
+     */
+    readonly TRANSCRIPTION: "transcription";
+};
+/**
+ * @public
+ */
+export type VoiceInputMode = (typeof VoiceInputMode)[keyof typeof VoiceInputMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const VoiceCommandType: {
+    readonly HANGUP: "hangup";
+    readonly PLAY: "play";
+    readonly SAY: "say";
+    readonly STOP: "stop";
+    readonly TRANSFER: "transfer";
+};
+/**
+ * @public
+ */
+export type VoiceCommandType = (typeof VoiceCommandType)[keyof typeof VoiceCommandType];

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

@@ -0,0 +1,36 @@
+import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/core/client";
+import { WilmaVoiceServiceException as __BaseException } from "./WilmaVoiceServiceException";
+/**
+ * @public
+ */
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+/**
+ * @public
+ */
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+/**
+ * @public
+ */
+export declare class VoiceSessionNotFoundException extends __BaseException {
+    readonly name: "VoiceSessionNotFoundException";
+    readonly $fault: "client";
+    type?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<VoiceSessionNotFoundException, __BaseException>);
+}