@wildix/wilma-voice-client 0.0.26 → 0.0.27

package/dist-types/WilmaVoiceClient.d.ts

@@ -6,24 +6,24 @@ import { type RetryInputConfig, type RetryResolvedConfig } from "@smithy/core/re
 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 { ListSpeechVoicesCommandInput, ListSpeechVoicesCommandOutput } from "./commands/ListSpeechVoicesCommand";
-import type { PreviewSpeechCommandInput, PreviewSpeechCommandOutput } from "./commands/PreviewSpeechCommand";
+import type { ListVoicesCommandInput, ListVoicesCommandOutput } from "./commands/ListVoicesCommand";
 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 { TextToSpeechCommandInput, TextToSpeechCommandOutput } from "./commands/TextToSpeechCommand";
 import { type ClientInputEndpointParameters, type ClientResolvedEndpointParameters, type EndpointParameters } from "./endpoint/EndpointParameters";
 import { type RuntimeExtension, type RuntimeExtensionsConfig } from "./runtimeExtensions";
 export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = DescribeVoiceProtocolCommandInput | ListSpeechVoicesCommandInput | PreviewSpeechCommandInput | SendHangupCommandInput | SendPlayCommandInput | SendSayCommandInput | SendStopCommandInput | SendTransferCommandInput;
+export type ServiceInputTypes = DescribeVoiceProtocolCommandInput | ListVoicesCommandInput | SendHangupCommandInput | SendPlayCommandInput | SendSayCommandInput | SendStopCommandInput | SendTransferCommandInput | TextToSpeechCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = DescribeVoiceProtocolCommandOutput | ListSpeechVoicesCommandOutput | PreviewSpeechCommandOutput | SendHangupCommandOutput | SendPlayCommandOutput | SendSayCommandOutput | SendStopCommandOutput | SendTransferCommandOutput;
+export type ServiceOutputTypes = DescribeVoiceProtocolCommandOutput | ListVoicesCommandOutput | SendHangupCommandOutput | SendPlayCommandOutput | SendSayCommandOutput | SendStopCommandOutput | SendTransferCommandOutput | TextToSpeechCommandOutput;
 /**
  * @public
  */

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

@@ -147,7 +147,7 @@ declare const DescribeVoiceProtocolCommand_base: {
  * //       category: "STRING_VALUE",
  * //       groupId: "STRING_VALUE",
  * //       speech: { // VoiceSpeechPayload
- * //         vendor: "aws", // required
+ * //         engine: "STRING_VALUE", // required
  * //         languages: [ // LanguageCodeList // required
  * //           "STRING_VALUE",
  * //         ],

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

@@ -0,0 +1,87 @@
+import { Command as $Command } from "@smithy/core/client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { ListVoicesInput, ListVoicesOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListVoicesCommand}.
+ */
+export interface ListVoicesCommandInput extends ListVoicesInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListVoicesCommand}.
+ */
+export interface ListVoicesCommandOutput extends ListVoicesOutput, __MetadataBearer {
+}
+declare const ListVoicesCommand_base: {
+    new (input: ListVoicesCommandInput): import("@smithy/core/client").CommandImpl<ListVoicesCommandInput, ListVoicesCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: ListVoicesCommandInput): import("@smithy/core/client").CommandImpl<ListVoicesCommandInput, ListVoicesCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Lists the voices a synthesis provider offers, read from the provider's own API and cached per company, provider, credential and language. Answers a URI per voice, so a picker stores what it selected rather than composing one.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, ListVoicesCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, ListVoicesCommand } = 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 = { // ListVoicesInput
+ *   provider: "STRING_VALUE", // required
+ *   language: "STRING_VALUE",
+ *   search: "STRING_VALUE",
+ *   credential: "STRING_VALUE",
+ * };
+ * const command = new ListVoicesCommand(input);
+ * const response = await client.send(command);
+ * // { // ListVoicesOutput
+ * //   voices: [ // VoiceList // required
+ * //     { // Voice
+ * //       uri: "STRING_VALUE", // required
+ * //       name: "STRING_VALUE", // required
+ * //       options: "DOCUMENT_VALUE",
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param ListVoicesCommandInput - {@link ListVoicesCommandInput}
+ * @returns {@link ListVoicesCommandOutput}
+ * @see {@link ListVoicesCommandInput} for command's `input` shape.
+ * @see {@link ListVoicesCommandOutput} 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 ListVoicesCommand extends ListVoicesCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: ListVoicesInput;
+            output: ListVoicesOutput;
+        };
+        sdk: {
+            input: ListVoicesCommandInput;
+            output: ListVoicesCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,103 @@
+import { Command as $Command } from "@smithy/core/client";
+import { Uint8ArrayBlobAdapter } from "@smithy/core/serde";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { TextToSpeechInput, TextToSpeechOutput } from "../models/models_0";
+import type { ServiceInputTypes, ServiceOutputTypes, WilmaVoiceClientResolvedConfig } from "../WilmaVoiceClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link TextToSpeechCommand}.
+ */
+export interface TextToSpeechCommandInput extends TextToSpeechInput {
+}
+/**
+ * @public
+ */
+export type TextToSpeechCommandOutputType = Omit<TextToSpeechOutput, "audio"> & {
+    audio: Uint8ArrayBlobAdapter;
+};
+/**
+ * @public
+ *
+ * The output of {@link TextToSpeechCommand}.
+ */
+export interface TextToSpeechCommandOutput extends TextToSpeechCommandOutputType, __MetadataBearer {
+}
+declare const TextToSpeechCommand_base: {
+    new (input: TextToSpeechCommandInput): import("@smithy/core/client").CommandImpl<TextToSpeechCommandInput, TextToSpeechCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: TextToSpeechCommandInput): import("@smithy/core/client").CommandImpl<TextToSpeechCommandInput, TextToSpeechCommandOutput, WilmaVoiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * Synthesizes one phrase and returns MP3.
+ *
+ *     NOT NAMED FOR THE PREVIEW IT SERVES. Auditioning an unsaved voice in the console is the first
+ *     caller, but nothing about the operation is preview-specific — it is the platform's
+ *     text-to-speech, reachable by anything holding the scope, and a name naming one caller's screen
+ *     would have to be worked around by the second one.
+ *
+ *     EVERYTHING TRAVELS IN THE REQUEST and the operation reads no stored record — not the agent, and
+ *     no dictionary behind it. The settings being auditioned are unsaved form state, and the rules
+ *     that apply are the ones on `pronunciations`, so what is heard here is what the call would say.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WilmaVoiceClient, TextToSpeechCommand } from "@wildix/wilma-voice-client"; // ES Modules import
+ * // const { WilmaVoiceClient, TextToSpeechCommand } = 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 = { // TextToSpeechInput
+ *   voice: "STRING_VALUE", // required
+ *   language: "STRING_VALUE", // required
+ *   text: "STRING_VALUE", // required
+ *   pronunciations: [ // VoicePronunciationList
+ *     { // VoicePronunciation
+ *       phrase: "STRING_VALUE", // required
+ *       as: "STRING_VALUE", // required
+ *       encoding: "alias" || "ipa",
+ *     },
+ *   ],
+ * };
+ * const command = new TextToSpeechCommand(input);
+ * const response = await client.send(command);
+ * // { // TextToSpeechOutput
+ * //   audio: new Uint8Array(), // required
+ * // };
+ *
+ * ```
+ *
+ * @param TextToSpeechCommandInput - {@link TextToSpeechCommandInput}
+ * @returns {@link TextToSpeechCommandOutput}
+ * @see {@link TextToSpeechCommandInput} for command's `input` shape.
+ * @see {@link TextToSpeechCommandOutput} 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 TextToSpeechCommand extends TextToSpeechCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: TextToSpeechInput;
+            output: TextToSpeechOutput;
+        };
+        sdk: {
+            input: TextToSpeechCommandInput;
+            output: TextToSpeechCommandOutput;
+        };
+    };
+}

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

@@ -1,8 +1,8 @@
 export * from "./DescribeVoiceProtocolCommand";
-export * from "./ListSpeechVoicesCommand";
-export * from "./PreviewSpeechCommand";
+export * from "./ListVoicesCommand";
 export * from "./SendHangupCommand";
 export * from "./SendPlayCommand";
 export * from "./SendSayCommand";
 export * from "./SendStopCommand";
 export * from "./SendTransferCommand";
+export * from "./TextToSpeechCommand";

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

@@ -16,30 +16,6 @@ export declare const VoicePronunciationEncoding: {
  * @public
  */
 export type VoicePronunciationEncoding = (typeof VoicePronunciationEncoding)[keyof typeof VoicePronunciationEncoding];
-/**
- * @public
- * @enum
- */
-export declare const VoiceSpeechProvider: {
-    readonly AMAZON_POLLY: "amazon_polly";
-    readonly ELEVENLABS: "elevenlabs";
-    readonly GOOGLE: "google";
-};
-/**
- * @public
- */
-export type VoiceSpeechProvider = (typeof VoiceSpeechProvider)[keyof typeof VoiceSpeechProvider];
-/**
- * @public
- * @enum
- */
-export declare const VoiceTranscriptionVendor: {
-    readonly AWS: "aws";
-};
-/**
- * @public
- */
-export type VoiceTranscriptionVendor = (typeof VoiceTranscriptionVendor)[keyof typeof VoiceTranscriptionVendor];
 /**
  * @public
  * @enum

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

@@ -1,9 +1,10 @@
-import type { VoiceAudioEncoding, VoiceCommandType, VoiceControlAction, VoiceEventType, VoiceInputMode, VoicePronunciationEncoding, VoiceSpeechProvider, VoiceTranscriptionVendor } from "./enums";
+import type { DocumentType as __DocumentType } from "@smithy/types";
+import type { VoiceAudioEncoding, 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. A dictionary shared ACROSS languages
- *     would fight itself, which is why the company dictionary is keyed by language too — see
- *     PronunciationDictionary.
+ *     respelled differently for an Italian and a German voice, so one list shared ACROSS languages
+ *     would fight itself. That is why the rules hang off the language and nowhere else — there is no
+ *     company-wide dictionary above them to inherit from, or to disagree with.
  * @public
  */
 export interface VoicePronunciation {
@@ -23,57 +24,6 @@ export interface VoicePronunciation {
      */
     encoding?: VoicePronunciationEncoding | undefined;
 }
-/**
- * Synthesis options, used at two levels: as provider-level defaults on VoiceSpeechSettings and as
- *     per-language overrides on VoiceLanguage. Absent means inherit; there is no way to express
- *     'explicitly the same as the parent', which is the intended simplification — the merged result is
- *     identical either way. Which members apply is a property of the provider AND the model (Chirp 3:
- *     HD documents only speakingRate; eleven_v3 carries no stability, similarity or speaker boost), so
- *     the console renders them from a catalog rather than unconditionally.
- * @public
- */
-export interface VoiceSynthesisOptions {
-    /**
-     * Provider model id, e.g. 'eleven_flash_v2_5'.
-     * @public
-     */
-    model?: string | undefined;
-    /**
-     * Speaking rate. ElevenLabs 0.7-1.2 (default 1.0); Google 0.25-2.0 (default 1.0).
-     * @public
-     */
-    speed?: number | undefined;
-    /**
-     * ElevenLabs stability, 0-1 (default 0.5). Our clamp, not a vendor-stated bound.
-     * @public
-     */
-    stability?: number | undefined;
-    /**
-     * ElevenLabs similarity boost, 0-1 (default 0.75). Our clamp.
-     * @public
-     */
-    similarity?: number | undefined;
-    /**
-     * ElevenLabs style exaggeration, 0-1 (default 0). Our clamp.
-     * @public
-     */
-    style?: number | undefined;
-    /**
-     * ElevenLabs speaker boost (default true).
-     * @public
-     */
-    speakerBoost?: boolean | undefined;
-    /**
-     * Google pitch in semitones, -20 to 20. Not offered for Chirp 3: HD voices.
-     * @public
-     */
-    pitch?: number | undefined;
-    /**
-     * Google volume gain in dB, -96 to 16 (default 0); the vendor recommends staying under +10. Not offered for Chirp 3: HD voices.
-     * @public
-     */
-    volumeGain?: 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
@@ -485,7 +435,7 @@ export interface SayCommandData {
      */
     interruptible?: boolean | undefined;
     /**
-     * Polly voice the PBX should synthesize with. Set only for provider AMAZON_POLLY, whose synthesis runs on the PBX; ElevenLabs and Google stream PCM through `play` instead and leave this absent.
+     * Voice URI the PBX should synthesize with. 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.
      * @public
      */
     voice?: string | undefined;
@@ -544,23 +494,23 @@ export interface SessionEndedWebsocketEvent {
 }
 /**
  * Recognition intent for the call, sent on `started` at protocolVersion >= 2. NOT recogniser
- *     parameters: the PBX translates it into its vendor's API. Against Amazon Transcribe with
+ *     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: `vendor` is
+ *     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 vendor's minimum or the vendor cannot identify languages at all (forwarding true
- *     with one candidate makes Amazon reject the stream outright — a dead call).
+ *     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).
  * @public
  */
 export interface VoiceSpeechPayload {
     /**
-     * Concrete transcription vendor; never absent.
+     * Concrete recogniser URI, resolved from the agent or from the platform default; never absent. See TranscriptionUri.
      * @public
      */
-    vendor: VoiceTranscriptionVendor;
+    engine: string;
     /**
      * Every configured language, as candidates for identification.
      * @public
@@ -572,7 +522,7 @@ export interface VoiceSpeechPayload {
      */
     preferredLanguage: string;
     /**
-     * Whether to identify the spoken language per utterance. Already clamped by the server.
+     * Whether to identify the spoken language per utterance. Already clamped by the server — see the shape's documentation.
      * @public
      */
     autoDetect: boolean;
@@ -637,6 +587,10 @@ export interface SessionStartedEvent {
     /**
      * 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.
@@ -846,12 +800,12 @@ export interface DescribeVoiceProtocolOutput {
 /**
  * @public
  */
-export interface ListSpeechVoicesInput {
+export interface ListVoicesInput {
     /**
-     * Text-to-speech provider used to synthesize the agent's replies.
+     * Provider whose catalog to read: 'elevenlabs', 'google', 'amazon_polly'. This is the scheme of the URIs answered on `voices`.
      * @public
      */
-    provider: VoiceSpeechProvider;
+    provider: string;
     /**
      * Server-side filter for language-bound providers: only voices whose language SET CONTAINS this code. Ignored for ElevenLabs, whose voices are not language bound.
      * @public
@@ -859,124 +813,55 @@ export interface ListSpeechVoicesInput {
     language?: string | undefined;
     search?: string | undefined;
     /**
-     * Id of the company's own provider credential, so the picker lists that account's voices including cloned ones. Resolved under the CALLER's company; an id that does not resolve there is rejected. Absent means the platform key.
+     * The company's own provider credential to read the catalog with, so the picker lists that
+     *       account's voices including cloned ones. Absent means the platform key.
+     *
+     *       EITHER A REFERENCE OR THE KEY ITSELF: `secrets:\{secretId\}` for a stored credential, resolved
+     *       under the CALLER's company — an id that does not resolve there is rejected — or the provider
+     *       key, for an account being configured whose key is not stored yet, which is the case this
+     *       operation has to serve before there is anything to reference.
+     *
+     *       A STORED VOICE URI is not the same latitude: its `apiKey` carries a reference, and a literal
+     *       key in one is the legacy dialplan form that nothing new writes.
+     *
+     *       A PLAIN KEY HERE IS IN A URL. `@sensitive` keeps it out of the generated clients' and servers'
+     *       log filters, but it cannot keep it out of an access log, a proxy or a browser history, and the
+     *       service must not put it in a cache identity. Send a reference wherever one exists.
      * @public
      */
     credential?: string | undefined;
 }
 /**
- * One voice offered by a synthesis provider.
- * @public
- */
-export interface SpeechVoice {
-    /**
-     * ElevenLabs voice_id, Google name, or Polly Id.
-     * @public
-     */
-    id: string;
-    name: string;
-    /**
-     * ElevenLabs verified_languages, Google languageCodes, or Polly LanguageCode plus AdditionalLanguageCodes. For an unbound provider this is metadata, not a constraint.
-     * @public
-     */
-    languages?: string[] | undefined;
-    gender?: string | undefined;
-    accent?: string | undefined;
-    /**
-     * ElevenLabs category, Google tier, or the Polly engines the voice supports.
-     * @public
-     */
-    category?: string | undefined;
-    /**
-     * Playable sample published by the provider. ElevenLabs only; the others publish none.
-     * @public
-     */
-    previewUrl?: string | undefined;
-    /**
-     * ElevenLabs high_quality_base_model_ids — which models support this voice.
-     * @public
-     */
-    models?: string[] | undefined;
-}
-/**
- * @public
- */
-export interface ListSpeechVoicesOutput {
-    voices: SpeechVoice[];
-    /**
-     * The provider's FULL language set, independent of the `language` filter — this is what a form intersects with the transcription vendor's set to populate its language select. Empty when voices are not language bound, which means 'imposes no restriction'.
-     * @public
-     */
-    languages?: string[] | undefined;
-    /**
-     * When this catalog was last read from the provider. `IsoTimestamp` rather than a bare `Timestamp`: restJson1 serialises the latter as epoch-seconds, which would make this the only Wilma operation answering with a numeric timestamp.
-     * @public
-     */
-    refreshedAt: string;
-    /**
-     * True when the provider failed and an expired cache entry was served.
-     * @public
-     */
-    stale?: boolean | undefined;
-}
-/**
+ * One voice a provider offers: the URI to store it by, a name to show, and the provider's own
+ *     metadata.
+ *
+ *     `uri` IS THE RESULT. It is exactly what goes into `VoiceLanguage.voice`, so a form stores what
+ *     it was given instead of assembling a string out of a provider name and an id — the one place a
+ *     client could get the convention wrong.
  * @public
  */
-export interface PreviewSpeechInput {
-    /**
-     * Text-to-speech provider used to synthesize the agent's replies.
-     * @public
-     */
-    provider: VoiceSpeechProvider;
-    voice: 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
-     *     transcription vendor 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 Voice {
     /**
-     * Text to speak, BEFORE pronunciation rules are applied.
+     * Voice URI, ready to store as `VoiceLanguage.voice` or send to TextToSpeech. Carries no parameters — the caller appends the synthesis parameters and, where applicable, the `apiKey=secrets:\{secretId\}` reference it wants.
      * @public
      */
-    text: string;
+    uri: string;
     /**
-     * Provider-level defaults. Merged SERVER-SIDE with the overrides below, by the same helper the call path uses — never pre-merged by the caller, or the form reimplements a rule the server owns and the preview can silently diverge from the call.
+     * Display name as the provider publishes it, e.g. 'Rachel'. A member rather than part of `options` because it is the one thing every provider has and every picker shows.
      * @public
      */
-    synthesis?: VoiceSynthesisOptions | undefined;
-    /**
-     * The selected language's overrides of the above.
-     * @public
-     */
-    languageSynthesis?: VoiceSynthesisOptions | undefined;
-    /**
-     * The agent's OWN rules for this language, unmerged. The company dictionary for `language` is applied server-side, for the reason given on `synthesis`.
-     * @public
-     */
-    pronunciations?: VoicePronunciation[] | undefined;
-    /**
-     * Company-dictionary phrases this language declines. Applied SERVER-SIDE with the rules above, by the same helper the call path uses.
-     * @public
-     */
-    suppressions?: string[] | undefined;
+    name: string;
     /**
-     * Credential id, resolved under the CALLER's company. Absent means the platform key.
+     * The provider's own metadata for this voice, for rendering and filtering only. See VoiceOptions.
      * @public
      */
-    credential?: string | undefined;
+    options?: __DocumentType | undefined;
 }
 /**
  * @public
  */
-export interface PreviewSpeechOutput {
-    /**
-     * audio/mpeg. The call path streams raw PCM to the PBX; the preview returns MP3 so a browser <audio> element plays it with no client-side decoding.
-     * @public
-     */
-    audio: Uint8Array;
+export interface ListVoicesOutput {
+    voices: Voice[];
 }
 /**
  * Terminate the session and hang up the call.
@@ -1039,7 +924,7 @@ export interface SendSayInput {
      */
     interruptible?: boolean | undefined;
     /**
-     * Polly voice the PBX should synthesize with. Set only for provider AMAZON_POLLY, whose synthesis runs on the PBX; ElevenLabs and Google stream PCM through `play` instead and leave this absent.
+     * Voice URI the PBX should synthesize with. 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.
      * @public
      */
     voice?: string | undefined;
@@ -1092,3 +977,38 @@ export interface SendTransferInput {
  */
 export interface SendTransferOutput {
 }
+/**
+ * @public
+ */
+export interface TextToSpeechInput {
+    /**
+     * Voice to speak with, as the URI a call would use — provider, voice id, synthesis parameters and, for a company's own account, `apiKey=secrets:\{secretId\}`. Passing the call's own value is what keeps an audition from diverging from the call it is auditioning.
+     * @public
+     */
+    voice: string;
+    /**
+     * Language the phrase is in. Reaches the provider as the synthesis language, and is the language `pronunciations` was written for.
+     * @public
+     */
+    language: string;
+    /**
+     * Text to speak, BEFORE pronunciation rules are applied.
+     * @public
+     */
+    text: string;
+    /**
+     * Rules to apply to `text`, applied SERVER-SIDE by the same helper the call path uses — never pre-applied by the caller, or the form reimplements a rule the server owns and can silently diverge from the call. Pass the language's own list to hear exactly what a call would say.
+     * @public
+     */
+    pronunciations?: VoicePronunciation[] | undefined;
+}
+/**
+ * @public
+ */
+export interface TextToSpeechOutput {
+    /**
+     * audio/mpeg. The call path streams raw PCM to the PBX; this returns MP3 so a browser <audio> element plays it with no client-side decoding.
+     * @public
+     */
+    audio: Uint8Array;
+}