@wildix/wilma-agents-client 1.0.27 → 1.0.29

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

@@ -1,5 +1,5 @@
 import type { DocumentType as __DocumentType } from "@smithy/types";
-import type { ActorType, AgentHandoverPipelineType, AgentHandoverVariant, AgentHangupPipelineType, AgentStatus, AgentToolPipelineType, AgentTransferPipelineType, AgentTransferVariant, AgentVariableType, AgentVisibility, AgentWorkflowEntryBehavior, AgentWorkflowFailureKind, AgentWorkflowLayout, AgentWorkflowMessageButtonVariant, ChannelType, SandboxNetworkAccess, SandboxSize, WebSearchContextSize } from "./enums";
+import type { ActorType, AgentGuardrailErrorMode, AgentGuardrailMode, AgentGuardrailPreset, AgentGuardrailSensitivity, AgentGuardrailWindow, AgentHandoverPipelineType, AgentHandoverVariant, AgentHangupPipelineType, AgentStatus, AgentToolPipelineType, AgentTransferPipelineType, AgentTransferVariant, AgentVariableType, AgentVisibility, AgentWorkflowEntryBehavior, AgentWorkflowFailureKind, AgentWorkflowLayout, AgentWorkflowMessageButtonVariant, ChannelType, SandboxNetworkAccess, SandboxSize, VoicePronunciationEncoding, VoiceSpeechProvider, VoiceTranscriptionVendor, WebSearchContextSize } from "./enums";
 /**
  * A user or group that access is granted to.
  * @public
@@ -40,8 +40,9 @@ export declare namespace AgentGrantPrincipal {
 /**
  * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
  *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
- *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `workflow` agents agent-level
- *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
+ *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`). When an agent is
+ *     invoked as a background task its agent-level access is not used — invocation access is configured per reference on the calling agent
+ *     (see AgentCallCapability.access).
  * @public
  */
 export interface AgentAccess {
@@ -56,6 +57,64 @@ export interface AgentAccess {
      */
     grants?: AgentGrantPrincipal[] | undefined;
 }
+/**
+ * A starter prompt offered as a card on an empty thread. Picking it sends `prompt` as the user's first message, so the user never types it.
+ * @public
+ */
+export interface AssistantQuickCommand {
+    /**
+     * Card label, e.g. 'Summarize my day'. Rendered on one line and truncated when it does not fit.
+     * @public
+     */
+    title: string;
+    /**
+     * Optional line under the label. Also one line, so keep it to a short clarification of what the command does.
+     * @public
+     */
+    description?: string | undefined;
+    /**
+     * The message actually sent when the card is picked. Usually longer and more explicit than the label, since it is what the model reads.
+     * @public
+     */
+    prompt: string;
+}
+/**
+ * Greeting shown on an empty thread, above the quick commands.
+ * @public
+ */
+export interface AssistantWelcomeSettings {
+    /**
+     * Heading, e.g. 'How can I help?'. Rendered on one line.
+     * @public
+     */
+    title?: string | undefined;
+    /**
+     * Line under the heading, saying what this agent is for, e.g. 'Ask about your conversations, accounts and calls.'.
+     * @public
+     */
+    subtitle?: string | undefined;
+}
+/**
+ * How the agent presents itself in the assistant UI: what the user reads before typing anything, and what they can start from without typing at all. Everything here is presentation — it never changes what the agent can do.
+ * @public
+ */
+export interface AssistantUiSettings {
+    /**
+     * Greeting shown on an empty thread, above the quick commands.
+     * @public
+     */
+    welcome?: AssistantWelcomeSettings | undefined;
+    /**
+     * Cards offered under the welcome message on an empty thread, in the order given. Empty or omitted shows no cards.
+     * @public
+     */
+    commands?: AssistantQuickCommand[] | undefined;
+    /**
+     * Placeholder text in the composer, e.g. 'Ask about an account…'. Defaults to the client's own placeholder when omitted.
+     * @public
+     */
+    placeholder?: string | undefined;
+}
 /**
  * @public
  */
@@ -65,6 +124,11 @@ export interface AssistantChannelSettings {
      * @public
      */
     default?: boolean | undefined;
+    /**
+     * How the agent presents itself in the assistant UI. Served to clients on AgentInfo, so it reaches the end user without exposing the rest of the agent definition.
+     * @public
+     */
+    ui?: AssistantUiSettings | undefined;
 }
 /**
  * @public
@@ -218,6 +282,262 @@ export interface VoiceSilenceTimeoutSettings {
     seconds: number;
     action: VoiceTerminateAction;
 }
+/**
+ * A reference to a stored secret, held by other services in place of the value.
+ * Resolved server-to-server via GetSecretValue at execution time — always to the current value.
+ * @public
+ */
+export interface SecretRef {
+    /**
+     * Unique identifier of a secret.
+     * @public
+     */
+    id: string;
+}
+/**
+ * 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.
+ * @public
+ */
+export interface VoicePronunciation {
+    /**
+     * The phrase as it appears in the text, e.g. 'Wildix'. Bounded because every rule is compiled into ONE regular expression — see the list below.
+     * @public
+     */
+    phrase: string;
+    /**
+     * Respelling (ALIAS) or phonetic transcription (IPA), e.g. 'Wil-dix'.
+     * @public
+     */
+    as: string;
+    /**
+     * Defaults to ALIAS.
+     * @public
+     */
+    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;
+}
+/**
+ * One configured language: its voice, its initial phrase and its overrides.
+ * @public
+ */
+export interface VoiceLanguage {
+    /**
+     * BCP-47 code with locale, e.g. 'en-US', 'it-IT'.
+     * @public
+     */
+    code: string;
+    /**
+     * Text-to-speech provider for THIS language. Absent falls back to
+     *         VoiceSpeechSettings.provider, which is what records written before this member
+     *         existed rely on. The console writes it on every language it creates.
+     *
+     *         Per language rather than per bot because provider quality is not uniform across
+     *         languages, and because a single bot-wide provider made changing it invalidate
+     *         every configured voice at once: a voice id belongs to one provider, so switching
+     *         the bot meant reselecting a speaker for every language.
+     * @public
+     */
+    provider?: VoiceSpeechProvider | undefined;
+    /**
+     * Provider voice id (ElevenLabs voice_id, Google voice name, Polly Id).
+     *   A CR OR LF IS REFUSED BY THE PATTERN, and the reason is not tidiness: this value reaches the
+     *   PBX as an AMI action parameter, and AMI frames on CRLF, so a newline inside it closes the
+     *   action and starts another one on a local, already-authenticated manager connection. Whoever
+     *   configures a voice agent in the cloud needs no PBX credential, so the model is the first place
+     *   that can refuse it. `pbx-data-engine` refuses it again on the send path — two layers, because
+     *   the AMI serializer is out of tree and neither layer can promise the other's behaviour.
+     * @public
+     */
+    voice: string;
+    /**
+     * Initial phrase spoken when the call starts in this language. Absent or empty means
+     *         the agent says nothing and waits — it does NOT fall back to VoiceChannelSettings.greeting,
+     *         which would speak one language's text in another language's voice.
+     * @public
+     */
+    greeting?: string | undefined;
+    /**
+     * Marks the language a caller hears when their own matches nothing configured.
+     *
+     *         THE FULL RESOLUTION ORDER, since a client author reading only this contract cannot
+     *         otherwise find it: an exact match on the call's language, then a match on its primary
+     *         subtag (`fr` finds `fr-FR`), then the language marked here, then a language whose
+     *         primary subtag is `en`, then the first entry in the list.
+     *
+     *         Marked is consulted BEFORE the English step, so a record with none marked resolves
+     *         exactly as it did before this member existed. English is deliberate rather than
+     *         arbitrary — it is the language a caller the agent was not built for is likeliest to
+     *         understand — and the last step exists only to keep the rule total, which is why list
+     *         order should not be treated as configuration.
+     *
+     *         At most one language may carry it. A record with two — reachable through the API or
+     *         the CLI, where no form prevents it — resolves to the first marked one in list order,
+     *         because refusing a call over configuration drift is worse than serving it and saying
+     *         so in the trace.
+     * @public
+     */
+    isDefault?: boolean | undefined;
+    /**
+     * Extra instructions active only while the conversation runs in this language.
+     * @public
+     */
+    instructions?: string | undefined;
+    /**
+     * Overrides VoiceSpeechSettings.synthesis member by member.
+     * @public
+     */
+    synthesis?: VoiceSynthesisOptions | undefined;
+    /**
+     * The company's own credential for THIS language's provider (secret variant
+     *         `auth_bearer`). Absent falls back to VoiceSpeechSettings.credential, then to the
+     *         platform key.
+     *
+     *         It lives beside the provider because a credential belongs to one: a company's
+     *         ElevenLabs key cannot serve a language synthesized by Google, and a single
+     *         bot-wide credential would have been silently inapplicable to some languages.
+     * @public
+     */
+    credential?: SecretRef | undefined;
+    /**
+     * This agent's OWN rules for this language. A rule whose phrase also exists in the
+     *         company dictionary replaces it; a rule whose phrase does not is simply an addition —
+     *         the two are the same member because they are the same act.
+     * @public
+     */
+    pronunciations?: VoicePronunciation[] | undefined;
+    /**
+     * Company-dictionary phrases this agent declines. See VoicePronunciationSuppressionList.
+     * @public
+     */
+    pronunciationSuppressions?: string[] | undefined;
+}
+/**
+ * Speech-to-text configuration. Vendor-specific recognition options — term hints, custom
+ *     vocabulary — land here alongside the vendors that take them; nothing writes them today.
+ * @public
+ */
+export interface VoiceTranscriptionSettings {
+    /**
+     * Recognition vendor. Absent resolves to the platform default (`aws` today), resolved by the
+     *         server so exactly one component decides it.
+     *
+     *         DELIBERATELY NOT @required, and the sentence above is why: the server already answers the
+     *         default for a `transcription` that carries no vendor, and both consoles were written to
+     *         that promise. @required contradicted it — it made the server-side default reachable only
+     *         for a WHOLLY ABSENT `transcription`, and refused a shape this documentation describes as
+     *         legal.
+     * @public
+     */
+    vendor?: VoiceTranscriptionVendor | undefined;
+}
+/**
+ * Speech configuration for the voice channel. When present it WINS over the dialplan's `voice` and
+ *     `initialMessage` connect parameters; `language` is the single exception, because it is the
+ *     channel's own input signal and the feature has no starting point without it.
+ * @public
+ */
+export interface VoiceSpeechSettings {
+    /**
+     * DEFAULT text-to-speech provider, used by a language that names none of its own.
+     *         Still required, so a record always answers 'which provider' — but the console now
+     *         writes `provider` on every language, so this is what pre-existing records and API
+     *         callers fall back to rather than the primary control.
+     * @public
+     */
+    provider: VoiceSpeechProvider;
+    /**
+     * Configured languages. The @length bound is a STORAGE ceiling, not the product rule: the real
+     *         cap is the selected transcription vendor's `maxCandidates` (five for Amazon Transcribe),
+     *         enforced in the service from its catalog so a vendor with a different limit needs no model
+     *         change.
+     * @public
+     */
+    languages: VoiceLanguage[];
+    /**
+     * Identify the caller's language automatically and switch voice and reply language mid-call. Requires at least two languages and a vendor that can identify languages; the server clamps it to false otherwise.
+     * @public
+     */
+    autoDetect?: boolean | undefined;
+    /**
+     * Speak the first message of every configured language in turn when the call is answered, each
+     *         in the voice, provider account and pronunciation rules of its own language, instead of only the
+     *         language the call resolved to. Languages whose first message is empty, and languages the PBX
+     *         synthesizes itself, are skipped. Absent means off. Requires at least two languages carrying a
+     *         first message; below that the runtime speaks only the resolved language's phrase, and the
+     *         console clamps the member on save.
+     * @public
+     */
+    greetEveryLanguage?: boolean | undefined;
+    /**
+     * Speech-to-text configuration. Vendor-specific recognition options — term hints, custom
+     *     vocabulary — land here alongside the vendors that take them; nothing writes them today.
+     * @public
+     */
+    transcription?: VoiceTranscriptionSettings | undefined;
+    /**
+     * Provider-level synthesis defaults, inherited by every language.
+     * @public
+     */
+    synthesis?: VoiceSynthesisOptions | undefined;
+    /**
+     * The company's own provider credential (secret variant `auth_bearer`). Absent means the platform key. Has no counterpart in wim-voicebots — a deliberate parity gap.
+     * @public
+     */
+    credential?: SecretRef | undefined;
+}
 /**
  * Voice channel settings. Note: a voice agent's AgentAccess.grants are ignored — inbound calls are routed by the PBX dialplan and data ACL is the agent-level `settings.pbxGroupId`, not per-user grants.
  * @public
@@ -228,6 +548,25 @@ export interface VoiceChannelSettings {
      * @public
      */
     greeting?: string | undefined;
+    /**
+     * Ambient background played under the call, as a music-on-hold class name.
+     *
+     *         ABSENT MEANS OFF. There is no value meaning 'none': the member is simply not sent, which is
+     *         exactly the state every call was in before this setting existed, so a bot that never touches
+     *         it behaves as it always did and the PBX needs no new case.
+     *
+     *         It belongs to the CHANNEL rather than to `speech`, even though the console shows the control
+     *         under the automatic-language switch. `speech` is the recognition and synthesis
+     *         configuration and is sent only when languages are configured — background audio has nothing
+     *         to do with either, and a bot with no languages must still be able to have it.
+     * @public
+     */
+    backgroundSound?: string | undefined;
+    /**
+     * Provider, languages, voices, initial phrases and pronunciation. Absent means the legacy behavior: voice URI from the dialplan connect parameter, one voice, language as prompt context only.
+     * @public
+     */
+    speech?: VoiceSpeechSettings | undefined;
     interruptions?: VoiceInterruptionSettings | undefined;
     silenceTimeout?: VoiceSilenceTimeoutSettings | undefined;
     maxDuration?: VoiceMaxDurationSettings | undefined;
@@ -238,12 +577,6 @@ export interface VoiceChannelSettings {
      */
     callerMetadata?: VoiceCallerMetadataSettings | undefined;
 }
-/**
- * Workflow channel settings. Currently empty; presence enables the workflow channel.
- * @public
- */
-export interface WorkflowChannelSettings {
-}
 /**
  * The channels an agent serves and their channel-specific settings. Presence of a member enables that channel; at least one must be set. Enabled channels are mirrored as ChannelType values on AgentInfo.
  * @public
@@ -256,11 +589,6 @@ export interface AgentChannels {
     voice?: VoiceChannelSettings | undefined;
     chat?: ChatChannelSettings | undefined;
     assistant?: AssistantChannelSettings | undefined;
-    /**
-     * Workflow channel settings. Currently empty; presence enables the workflow channel.
-     * @public
-     */
-    workflow?: WorkflowChannelSettings | undefined;
 }
 /**
  * Who performed an action: an interactive user, an API key or an internal service.
@@ -384,7 +712,7 @@ export interface AgentToolVariable {
     handler?: AgentToolVariableHandler | undefined;
 }
 /**
- * Invoke another agent (typically a workflow agent) as a dedicated execution with its own state. The called agent runs independently and returns its result.
+ * Invoke another agent as a dedicated execution with its own state. The called agent runs independently and returns its result.
  * @public
  */
 export interface AgentCallCapability {
@@ -397,12 +725,19 @@ export interface AgentCallCapability {
     /**
      * Who may invoke this sub-agent tool. Evaluated per invoking user when the calling agent (chat / assistant) builds its
      *         toolset: if the user is not granted, this capability is omitted from the tools offered to the model for that session.
-     *         When omitted, the tool is available to everyone who can use the calling agent. This is where a workflow agent's
-     *         invocation access is configured, since workflow agents have no agent-level access of their own.
+     *         When omitted, the tool is available to everyone who can use the calling agent. This is the only place invocation
+     *         access is configured — the called agent's own access settings do not apply to being invoked.
      * @public
      */
     access?: AgentAccess | undefined;
     variables?: AgentToolVariable[] | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
 }
 /**
  * Comment annotation emitted after a tool completes.
@@ -587,6 +922,13 @@ export interface AgentConnectorCapability {
      * @public
      */
     approval?: AgentToolApproval | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -614,6 +956,13 @@ export interface AgentDelegationCapability {
      * @public
      */
     agentVersion?: number | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -664,6 +1013,13 @@ export interface AgentHandoverCapability {
      */
     silent?: boolean | undefined;
     pipeline?: AgentHandoverPipeline | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -693,6 +1049,13 @@ export interface AgentHangupCapability {
      */
     description?: string | undefined;
     pipeline?: AgentHangupPipeline | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -705,6 +1068,13 @@ export interface AgentKnowledgeBase {
      * @public
      */
     instructions?: string | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -755,7 +1125,7 @@ export interface AgentVercelSandboxOptions {
     allowedDomains?: string[] | undefined;
 }
 /**
- * Embedded sandbox: shell + file tools backed by an execution environment.
+ * Embedded sandbox: shell + file tools backed by an execution environment. The only capability with no `channels` list — being a union it has nowhere to carry one — so it is offered on every channel the agent serves.
  * @public
  */
 export type AgentSandboxCapability = AgentSandboxCapability.SnapshotMember | AgentSandboxCapability.VercelMember | AgentSandboxCapability.$UnknownMember;
@@ -809,6 +1179,13 @@ export interface AgentSuggestionsCapability {
      * @public
      */
     name?: string | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -920,6 +1297,13 @@ export interface AgentTool {
      * @public
      */
     approval?: AgentToolApproval | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -960,6 +1344,13 @@ export interface AgentTransferCapability {
      */
     extension?: string | undefined;
     pipeline?: AgentTransferPipeline | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -982,6 +1373,13 @@ export interface AgentWaitCapability {
      * @public
      */
     message?: string | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
     annotations?: AgentToolAnnotation[] | undefined;
 }
 /**
@@ -994,6 +1392,13 @@ export interface AgentWebFetchCapability {
      * @public
      */
     allowedDomains?: string[] | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
 }
 /**
  * @public
@@ -1028,6 +1433,13 @@ export interface AgentWebSearchCapability {
      */
     allowedDomains?: string[] | undefined;
     userLocation?: WebSearchUserLocation | undefined;
+    /**
+     * Channels this capability is offered on. Absent or empty — the default — means every channel the agent serves
+     *     that can honour it. Listing channels narrows that set and never widens it: a `transfer` listed for `chat` is
+     *     still ignored there, because the chat channel has no call to transfer.
+     * @public
+     */
+    channels?: ChannelType[] | undefined;
 }
 /**
  * @public
@@ -1093,7 +1505,7 @@ export declare namespace AgentCapability {
         $unknown?: never;
     }
     /**
-     * Embedded sandbox: shell + file tools backed by an execution environment.
+     * Embedded sandbox: shell + file tools backed by an execution environment. The only capability with no `channels` list — being a union it has nowhere to carry one — so it is offered on every channel the agent serves.
      * @public
      */
     interface SandboxMember {
@@ -1153,7 +1565,7 @@ export declare namespace AgentCapability {
         $unknown?: never;
     }
     /**
-     * Invoke another agent (typically a workflow agent) as a dedicated execution with its own state. The called agent runs independently and returns its result.
+     * Invoke another agent as a dedicated execution with its own state. The called agent runs independently and returns its result.
      * @public
      */
     interface AgentMember {
@@ -1332,6 +1744,298 @@ export declare namespace AgentCapability {
         _: (name: string, value: any) => T;
     }
 }
+/**
+ * Refuse the turn. The agent's model is never called, no tool runs, and the caller is answered with `message` instead. The session stays alive and the conversation continues, so on a check meant to redirect rather than stop — 'let me take a few details first' — the message is doing the work.
+ * @public
+ */
+export interface AgentGuardrailBlockAction {
+    /**
+     * Said to the caller in place of the agent's reply. Falls back to a channel default when unset.
+     * @public
+     */
+    message?: string | undefined;
+}
+/**
+ * End the session. It lands in SessionStatus TERMINATED — not STOPPED, which is what a user asking to stop means — so a refused session is never read back as a clean finish. On voice this hangs up the call; on the other channels the session simply accepts no further turns.
+ * @public
+ */
+export interface AgentGuardrailEndAction {
+    /**
+     * Said to the caller before the session ends.
+     * @public
+     */
+    message?: string | undefined;
+}
+/**
+ * Record the verdict and let the turn through. The rollout mode: every guardrail should run here first, against real traffic, until its trips are read and its sensitivity is tuned. A tripped check still emits GuardrailTrippedEvent and still appears in the trace, which is what makes this a tuning tool rather than a switched-off check.
+ * @public
+ */
+export interface AgentGuardrailObserveAction {
+}
+/**
+ * Mask the matched spans and let the turn continue. The mask is chosen by the platform and is not configurable — a tenant-authored placeholder that collides with real text, or that the model reads as an instruction, is worse than having no choice. Only valid on checks that return spans (PII, SECRETS).
+ * @public
+ */
+export interface AgentGuardrailRedactAction {
+}
+/**
+ * What happens when a check trips. Exactly one member is set.
+ *
+ *     Ordered by severity: observe < redact < block < end. When more than one check trips in the same call the
+ *     most severe action wins and ties break on the order of `checks`, so a set can mix an observed check with
+ *     an enforced one without the observation weakening the enforcement.
+ *
+ *     There is no hand-over member yet. Handing a session to a human is a different mechanism on every channel
+ *     — a voice transfer, a chat assignment, an assistant with no human behind it — and wiring a guardrail into
+ *     all of them is out of proportion to the rest of this feature. Until AgentHandoverCapability has a runtime
+ *     on more than one channel, the crisis path is a block whose message routes the caller.
+ * @public
+ */
+export type AgentGuardrailAction = AgentGuardrailAction.BlockMember | AgentGuardrailAction.EndMember | AgentGuardrailAction.ObserveMember | AgentGuardrailAction.RedactMember | AgentGuardrailAction.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace AgentGuardrailAction {
+    /**
+     * Record the verdict and let the turn through. The rollout mode: every guardrail should run here first, against real traffic, until its trips are read and its sensitivity is tuned. A tripped check still emits GuardrailTrippedEvent and still appears in the trace, which is what makes this a tuning tool rather than a switched-off check.
+     * @public
+     */
+    interface ObserveMember {
+        observe: AgentGuardrailObserveAction;
+        redact?: never;
+        block?: never;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * Mask the matched spans and let the turn continue. The mask is chosen by the platform and is not configurable — a tenant-authored placeholder that collides with real text, or that the model reads as an instruction, is worse than having no choice. Only valid on checks that return spans (PII, SECRETS).
+     * @public
+     */
+    interface RedactMember {
+        observe?: never;
+        redact: AgentGuardrailRedactAction;
+        block?: never;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * Refuse the turn. The agent's model is never called, no tool runs, and the caller is answered with `message` instead. The session stays alive and the conversation continues, so on a check meant to redirect rather than stop — 'let me take a few details first' — the message is doing the work.
+     * @public
+     */
+    interface BlockMember {
+        observe?: never;
+        redact?: never;
+        block: AgentGuardrailBlockAction;
+        end?: never;
+        $unknown?: never;
+    }
+    /**
+     * End the session. It lands in SessionStatus TERMINATED — not STOPPED, which is what a user asking to stop means — so a refused session is never read back as a clean finish. On voice this hangs up the call; on the other channels the session simply accepts no further turns.
+     * @public
+     */
+    interface EndMember {
+        observe?: never;
+        redact?: never;
+        block?: never;
+        end: AgentGuardrailEndAction;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        observe?: never;
+        redact?: never;
+        block?: never;
+        end?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        observe: (value: AgentGuardrailObserveAction) => T;
+        redact: (value: AgentGuardrailRedactAction) => T;
+        block: (value: AgentGuardrailBlockAction) => T;
+        end: (value: AgentGuardrailEndAction) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * A check written by the tenant. A name and a prompt is the whole surface: no category enum can express the rules customers actually buy, such as refusing to quote a price before qualifying.
+ * @public
+ */
+export interface AgentGuardrailCustomCheck {
+    /**
+     * Natural-language description of what a custom check looks for. Describe the *content* to be caught, not an instruction to the checker: 'The caller is asking about cryptocurrency investments' works, 'Block all content about crypto' does not, and a negative definition ('anything except billing questions') reliably misfires.
+     * @public
+     */
+    instructions: string;
+    /**
+     * Up to five turns that should trip this check. They steer the model's judgement and are NOT matched literally — a description plus examples catches the plural, the typo and the paraphrase that a term list misses.
+     * @public
+     */
+    examples?: string[] | undefined;
+}
+/**
+ * A check backed by one of the platform's prebuilt prompts.
+ * @public
+ */
+export interface AgentGuardrailPresetCheck {
+    /**
+     * A prebuilt check. Each preset is a platform-maintained prompt shipped in code and versioned with the
+     *     platform, not a tenant row — so a support question about what a preset caught has one answer. A preset
+     *     check is otherwise an ordinary AgentGuardrailCheck: its sensitivity and action are the tenant's to set,
+     *     and `notes` narrows its prompt without replacing it.
+     * @public
+     */
+    preset: AgentGuardrailPreset;
+    /**
+     * Appended to the preset's prompt. For narrowing, not redefining — 'ignore card numbers read back after our own IVR prompts for them' — so the preset keeps its maintenance while fitting a tenant whose product would otherwise fight it.
+     * @public
+     */
+    notes?: string | undefined;
+}
+/**
+ * What a check is: one of the platform's presets, or a prompt the tenant wrote. Exactly one member is set.
+ * @public
+ */
+export type AgentGuardrailCheckKind = AgentGuardrailCheckKind.CustomMember | AgentGuardrailCheckKind.PresetMember | AgentGuardrailCheckKind.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace AgentGuardrailCheckKind {
+    /**
+     * A check backed by one of the platform's prebuilt prompts.
+     * @public
+     */
+    interface PresetMember {
+        preset: AgentGuardrailPresetCheck;
+        custom?: never;
+        $unknown?: never;
+    }
+    /**
+     * A check written by the tenant. A name and a prompt is the whole surface: no category enum can express the rules customers actually buy, such as refusing to quote a price before qualifying.
+     * @public
+     */
+    interface CustomMember {
+        preset?: never;
+        custom: AgentGuardrailCustomCheck;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        preset?: never;
+        custom?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        preset: (value: AgentGuardrailPresetCheck) => T;
+        custom: (value: AgentGuardrailCustomCheck) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * One thing the checker is asked about a turn. There is deliberately no `enabled` flag: a check that
+ *     should not run is removed, so a published version never carries a switched-off check that reads like
+ *     policy.
+ * @public
+ */
+export interface AgentGuardrailCheck {
+    /**
+     * Name of a check, unique within a guardrail set. Stable and machine-facing: session events and trace spans report a verdict by this name, so a reader needs no copy of the agent definition to tell which check fired.
+     * @public
+     */
+    name: string;
+    description?: string | undefined;
+    /**
+     * What a check is: one of the platform's presets, or a prompt the tenant wrote. Exactly one member is set.
+     * @public
+     */
+    kind: AgentGuardrailCheckKind;
+    /**
+     * How much confidence a verdict needs before it counts as tripped. The checker reports a confidence per
+     *     check and this is the threshold against it, so raising sensitivity catches more and costs more false
+     *     positives without changing the prompt or the model: `low` trips only on high confidence, `medium` on
+     *     high and medium, `high` on anything but a clear pass. Defaults to MEDIUM.
+     * @public
+     */
+    sensitivity?: AgentGuardrailSensitivity | undefined;
+    /**
+     * What happens when this check trips. Defaults to the preset's own — a block for most, a redaction for PII and SECRETS, and for SELF_HARM a block whose message routes the caller. A custom check with none defaults to a block.
+     * @public
+     */
+    action?: AgentGuardrailAction | undefined;
+}
+/**
+ * Screening applied to what reaches the model.
+ *
+ *     There is deliberately no bundle or preset-group member. A named group that expands to a set of checks
+ *     reads like convenience and behaves like version skew: the same agent definition would mean different
+ *     things before and after a platform release, invisibly to the tenant who published it. Listing the checks
+ *     costs a few lines in a document the console writes anyway, and the published version then states exactly
+ *     what it enforces.
+ *
+ *     There is also no set-level default action. One field standing behind every check reads as a convenience
+ *     and hides the thing a reader most needs to see: what a given check will actually do. A check's action is
+ *     its own or its preset's, and both are visible on the check.
+ * @public
+ */
+export interface AgentGuardrailInput {
+    /**
+     * The checks to run, evaluated together in one call. Absent or empty means no screening.
+     * @public
+     */
+    checks?: AgentGuardrailCheck[] | undefined;
+    /**
+     * The model that runs the checks. Defaults to the platform's guardrail model — deliberately small and fast, and deliberately not the agent's own, whose cost and latency are what this exists to avoid spending on a bad turn.
+     * @public
+     */
+    model?: string | undefined;
+    /**
+     * Runs the checker before the agent's model (BLOCKING) or alongside it (PARALLEL). Blocking costs the checker's latency on every turn but guarantees that a refused turn spent no tokens and fired no tool; parallel adds no latency and is the right trade on voice, where the delay is audible, at the risk that part of a reply reaches the caller and that a tool has already run before the cancellation lands. Defaults to BLOCKING.
+     * @public
+     */
+    mode?: AgentGuardrailMode | undefined;
+    /**
+     * What happens when the checker itself errors or times out. OPEN lets the turn through unscreened and records GuardrailFailedEvent, so an unscreened turn is a fact in the log rather than an absence; CLOSED refuses it. Defaults to OPEN: an agent that stops answering because a small model had a bad minute is a worse and far likelier outage than the rare turn that goes unscreened. Background tasks, where nobody is waiting and a retry is free, are the case for CLOSED.
+     * @public
+     */
+    errorMode?: AgentGuardrailErrorMode | undefined;
+    /**
+     * How much of the conversation the checker sees. Defaults to LAST_WITH_PRIOR, because the jailbreaks worth catching are built across several turns — establish a fiction, then cash it in — and a checker shown only the last turn sees an innocuous sentence. There is no full-transcript option: screening a whole call on every turn would make the guardrail dearer than the agent.
+     * @public
+     */
+    window?: AgentGuardrailWindow | undefined;
+}
+/**
+ * Turn screening, by side. Only `input` exists: it guards what reaches the model, and output screening is a separate policy with different actions, added here when it is built.
+ * @public
+ */
+export interface AgentGuardrails {
+    /**
+     * Screening applied to what reaches the model.
+     *
+     *     There is deliberately no bundle or preset-group member. A named group that expands to a set of checks
+     *     reads like convenience and behaves like version skew: the same agent definition would mean different
+     *     things before and after a platform release, invisibly to the tenant who published it. Listing the checks
+     *     costs a few lines in a document the console writes anyway, and the published version then states exactly
+     *     what it enforces.
+     *
+     *     There is also no set-level default action. One field standing behind every check reads as a convenience
+     *     and hides the thing a reader most needs to see: what a given check will actually do. A check's action is
+     *     its own or its preset's, and both are visible on the check.
+     * @public
+     */
+    input?: AgentGuardrailInput | undefined;
+}
 /**
  * Reference to a skill attached to an agent.
  * @public
@@ -2298,15 +3002,12 @@ export interface AgentWorkflowStep {
      */
     id: string;
     /**
-     * Human readable name of a step, shown in the builder and in traces. Never a routing key — see AgentWorkflowStepId — but it is read by the model as the fallback preview of an exit that leads here when the step carries no `summary`.
+     * Human readable name of a step, e.g. 'Transfer to the sales desk'. Shown in the builder and in traces, and
+     *     read by the model too: when this step is an exit of the live step, the label is the preview offered alongside
+     *     the exit's condition. Never a routing key — see AgentWorkflowStepId — so renaming one never unwires a graph.
      * @public
      */
     label: string;
-    /**
-     * One line saying what happens here, shown to the model as the preview of any exit that leads to this step.
-     * @public
-     */
-    summary?: string | undefined;
     /**
      * The phase this step belongs to. Inherited by steps downstream, so a handful of tags organise a long graph.
      * @public
@@ -2425,6 +3126,15 @@ export interface AgentAiEngine {
      * @public
      */
     workflow?: AgentWorkflow | undefined;
+    /**
+     * Screening applied to a turn before this agent's model sees it. Sits next to `instructions` and
+     *         `workflow` because it is the third thing that governs a session, and it is enforced outside the prompt
+     *         on purpose: a refusal written into `instructions` is one the caller can argue the agent out of.
+     *         Optional — absent means no screening, which is what every agent authored before guardrails existed
+     *         keeps doing. See AgentGuardrails.
+     * @public
+     */
+    guardrails?: AgentGuardrails | undefined;
     /**
      * Defaults to the platform default model when omitted.
      * @public
@@ -2452,18 +3162,6 @@ export interface AgentAiEngine {
     capabilities?: AgentCapability[] | undefined;
     variables?: AgentVariable[] | undefined;
 }
-/**
- * A reference to a stored secret, held by other services in place of the value.
- * Resolved server-to-server via GetSecretValue at execution time — always to the current value.
- * @public
- */
-export interface SecretRef {
-    /**
-     * Unique identifier of a secret.
-     * @public
-     */
-    id: string;
-}
 /**
  * Bring-your-own backend over SQS: turns are forwarded to the queue, replies are posted back via the API.
  * @public
@@ -2595,8 +3293,9 @@ export interface Agent {
     /**
      * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
      *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
-     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `workflow` agents agent-level
-     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`). When an agent is
+     *     invoked as a background task its agent-level access is not used — invocation access is configured per reference on the calling agent
+     *     (see AgentCallCapability.access).
      * @public
      */
     access?: AgentAccess | undefined;
@@ -2710,25 +3409,44 @@ export interface AgentDefinitionSnapshot {
     /**
      * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
      *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
-     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `workflow` agents agent-level
-     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`). When an agent is
+     *     invoked as a background task its agent-level access is not used — invocation access is configured per reference on the calling agent
+     *     (see AgentCallCapability.access).
      * @public
      */
     access?: AgentAccess | undefined;
 }
 /**
+ * What a client needs to render an agent, and nothing more: AgentInfo is the end-user view of an agent,
+ *     served by the channel runtimes (e.g. GetAgent / GetSettings on wilma-assistant) to callers who must not
+ *     see instructions, capabilities or access rules. Everything here is safe to show to whoever can use the agent.
  * @public
  */
 export interface AgentInfo {
     id: string;
     name: string;
+    /**
+     * Avatar URL, from the agent definition.
+     * @public
+     */
+    picture?: string | undefined;
     category?: string | undefined;
     status: AgentStatus;
     /**
-     * The channels this agent serves (voice / chat / assistant / workflow).
+     * The channels this agent serves (voice / chat / assistant).
      * @public
      */
     channels: ChannelType[];
+    /**
+     * Whether the agent's voice channel has at least one configured speech language. A dialplan form partitions its application lists on this, so the answer has to travel with the list rather than cost one lookup per entry. Absent is read as false.
+     * @public
+     */
+    speechConfigured?: boolean | undefined;
+    /**
+     * How the agent presents itself in the assistant UI: welcome message, quick commands and composer placeholder, copied from `channels.assistant.ui`. Absent when the agent does not serve the assistant channel, or when its author configured no presentation and the client should use its own defaults.
+     * @public
+     */
+    assistant?: AssistantUiSettings | undefined;
     /**
      * Published agent version number. Monotonic within an agent's version history, starting at 1.
      * @public
@@ -2897,8 +3615,9 @@ export interface CreateAgentInput {
     /**
      * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
      *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
-     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `workflow` agents agent-level
-     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`). When an agent is
+     *     invoked as a background task its agent-level access is not used — invocation access is configured per reference on the calling agent
+     *     (see AgentCallCapability.access).
      * @public
      */
     access?: AgentAccess | undefined;
@@ -2963,6 +3682,25 @@ export interface DeleteAgentApiKeyInput {
  */
 export interface DeleteAgentApiKeyOutput {
 }
+/**
+ * @public
+ */
+export interface DeletePronunciationDictionaryInput {
+    company?: string | undefined;
+    /**
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     transcription vendor and changes with it, so an enumeration here would cap the set at whatever
+     *     was known when the model was released.
+     * @public
+     */
+    code: string;
+}
+/**
+ * @public
+ */
+export interface DeletePronunciationDictionaryOutput {
+}
 /**
  * @public
  */
@@ -3034,7 +3772,7 @@ export interface ListAgentApiKeysOutput {
 export interface ListAgentsInput {
     company?: string | undefined;
     /**
-     * Only agents that have this channel enabled (voice / chat / assistant / workflow).
+     * Only agents that have this channel enabled (voice / chat / assistant).
      * @public
      */
     channel?: ChannelType | undefined;
@@ -3068,7 +3806,7 @@ export interface ListAgentsOutput {
 export interface ListAgentsNamesInput {
     company?: string | undefined;
     /**
-     * A channel an agent can serve (see AgentChannels for enablement). Also the runtime channel recorded by the channel runtimes / wilma-traces.
+     * A channel an agent can serve (see AgentChannels for enablement). Also the runtime channel recorded by the channel runtimes / wilma-traces. A background task has no delivery surface and therefore no channel.
      * @public
      */
     channel?: ChannelType | undefined;
@@ -3103,6 +3841,72 @@ export interface ListAgentVersionsOutput {
      */
     nextCursor?: string | undefined;
 }
+/**
+ * @public
+ */
+export interface ListPronunciationDictionariesInput {
+    company?: string | undefined;
+    /**
+     * Page size. ABSENT MEANS EVERY DICTIONARY — see the operation's documentation.
+     * @public
+     */
+    limit?: number | undefined;
+    /**
+     * Opaque cursor returned by a previous page; pass it back to fetch the next page.
+     * @public
+     */
+    cursor?: string | undefined;
+}
+/**
+ * Every pronunciation rule a company has written for one language.
+ * @public
+ */
+export interface PronunciationDictionary {
+    id: string;
+    /**
+     * BCP-47 code with locale, e.g. 'en-US'. Unique per company — this is the link.
+     * @public
+     */
+    code: string;
+    /**
+     * Pronunciation rules for one language.
+     *
+     *     BOUNDED, and the bound is not decoration. Both runtimes compile every rule of a language into
+     *     a SINGLE alternating regular expression, so the cost is the pattern's total size: measured
+     *     against the real escaping and matching logic, 1,000 rules cost ~0.9 s of CPU per synthesized
+     *     sentence, 5,000 cost ~4.9 s, and around 10,000 `new RegExp` throws V8's pattern-size error.
+     *
+     *     200 is far above any real use — a product glossary is a handful of names — and far below where
+     *     either cost begins. Found by a security review.
+     *     NO LOWER BOUND on `phrase` or `as`, deliberately. Both consoles add an EMPTY rule row the
+     *     moment someone clicks 'Add pronunciation', so a `min: 1` would make saving an agent with a
+     *     half-typed row fail entirely — and the runtime already ignores a rule with no phrase. Dropping
+     *     blank rows belongs in the consoles' save filters, not in a refusal here.
+     * @public
+     */
+    rules: VoicePronunciation[];
+    /**
+     * ISO-8601 timestamp with millisecond precision, e.g. '2026-07-10T14:12:30.123Z'.
+     * @public
+     */
+    updatedAt: string;
+    /**
+     * Who performed an action: an interactive user, an API key or an internal service.
+     * @public
+     */
+    updatedBy: Actor;
+}
+/**
+ * @public
+ */
+export interface ListPronunciationDictionariesOutput {
+    dictionaries: PronunciationDictionary[];
+    /**
+     * Absent on the last page, and always absent when `limit` was not sent — there is then nothing left to continue from.
+     * @public
+     */
+    nextCursor?: string | undefined;
+}
 /**
  * @public
  */
@@ -3153,6 +3957,65 @@ export interface PutAgentDeploymentOutput {
      */
     deployment: AgentDeploymentRoute[];
 }
+/**
+ * @public
+ */
+export interface PutPronunciationDictionaryInput {
+    company?: string | undefined;
+    /**
+     * BCP-47 language tag, optionally with a region subtag: 'en', 'en-US', 'pt-BR'. Deliberately a
+     *     constrained string rather than an enum: the offerable set is a property of the selected
+     *     transcription vendor and changes with it, so an enumeration here would cap the set at whatever
+     *     was known when the model was released.
+     * @public
+     */
+    code: string;
+    /**
+     * Pronunciation rules for one language.
+     *
+     *     BOUNDED, and the bound is not decoration. Both runtimes compile every rule of a language into
+     *     a SINGLE alternating regular expression, so the cost is the pattern's total size: measured
+     *     against the real escaping and matching logic, 1,000 rules cost ~0.9 s of CPU per synthesized
+     *     sentence, 5,000 cost ~4.9 s, and around 10,000 `new RegExp` throws V8's pattern-size error.
+     *
+     *     200 is far above any real use — a product glossary is a handful of names — and far below where
+     *     either cost begins. Found by a security review.
+     *     NO LOWER BOUND on `phrase` or `as`, deliberately. Both consoles add an EMPTY rule row the
+     *     moment someone clicks 'Add pronunciation', so a `min: 1` would make saving an agent with a
+     *     half-typed row fail entirely — and the runtime already ignores a rule with no phrase. Dropping
+     *     blank rows belongs in the consoles' save filters, not in a refusal here.
+     * @public
+     */
+    rules: VoicePronunciation[];
+    /**
+     * Precondition: the `updatedAt` of the dictionary this edit was made against, echoed back
+     *         from the PronunciationDictionary the caller read. When it does not match the stored value
+     *         the write is refused with RevisionConflictException and the caller re-reads rather than
+     *         overwriting an edit it never saw.
+     *
+     *         A TIMESTAMP RATHER THAN AN INTEGER REVISION, unlike UpdateAgent: the dictionary already
+     *         carries `updatedAt` on every read, so the round trip exists today and no stored record
+     *         needs a new field to take part. The meaning is UpdateAgent's meaning — 'based on the
+     *         version I read' — and the error is the same one.
+     *
+     *         OPTIONAL, and ABSENCE MEANS LAST-WRITE-WINS: this operation shipped without a precondition,
+     *         so making it mandatory would break every existing caller for a guarantee they can opt into.
+     *         RevisionConflictException carries no `currentRevision` here — this resource is versioned by
+     *         its timestamp, and the current one is on the dictionary a re-read returns.
+     * @public
+     */
+    expectedUpdatedAt?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface PutPronunciationDictionaryOutput {
+    /**
+     * Every pronunciation rule a company has written for one language.
+     * @public
+     */
+    dictionary: PronunciationDictionary;
+}
 /**
  * @public
  */
@@ -3232,8 +4095,9 @@ export interface UpdateAgentInput {
     /**
      * Who is allowed to use the agent. There is no view/edit dimension — access solely grants the ability to use the agent.
      *     Per channel: on `chat` and `assistant` agents `grants` govern which colleagues can use the agent; on `voice` agents `grants`
-     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`); on `workflow` agents agent-level
-     *     access is not used — invocation access is configured per reference on the calling agent (see AgentCallCapability.access).
+     *     are ignored (inbound calls are routed by the PBX dialplan, and data ACL is the agent-level `settings.pbxGroupId`). When an agent is
+     *     invoked as a background task its agent-level access is not used — invocation access is configured per reference on the calling agent
+     *     (see AgentCallCapability.access).
      * @public
      */
     access?: AgentAccess | undefined;