@deepgram/sdk 4.11.2 → 5.0.0-alpha.1

package/dist/cjs/api/resources/agent/resources/v1/types/AgentV1Settings.d.ts

@@ -0,0 +1,228 @@
+import type * as Deepgram from "../../../../../index.js";
+export interface AgentV1Settings {
+    type: "Settings";
+    /** Tags to associate with the request */
+    tags?: string[];
+    /** To enable experimental features */
+    experimental?: boolean;
+    flags?: AgentV1Settings.Flags;
+    /** To opt out of Deepgram Model Improvement Program */
+    mip_opt_out?: boolean;
+    audio: AgentV1Settings.Audio;
+    agent: AgentV1Settings.Agent;
+}
+export declare namespace AgentV1Settings {
+    interface Flags {
+        /** Enable or disable history message reporting */
+        history?: boolean;
+    }
+    interface Audio {
+        /** Audio input configuration settings. If omitted, defaults to encoding=linear16 and sample_rate=24000. Higher sample rates like 44100 Hz provide better audio quality. */
+        input?: Audio.Input;
+        /** Audio output configuration settings */
+        output?: Audio.Output;
+    }
+    namespace Audio {
+        /**
+         * Audio input configuration settings. If omitted, defaults to encoding=linear16 and sample_rate=24000. Higher sample rates like 44100 Hz provide better audio quality.
+         */
+        interface Input {
+            /** Audio encoding format */
+            encoding: Input.Encoding;
+            /** Sample rate in Hz. Common values are 16000, 24000, 44100, 48000 */
+            sample_rate: number;
+        }
+        namespace Input {
+            /** Audio encoding format */
+            const Encoding: {
+                readonly Linear16: "linear16";
+                readonly Linear32: "linear32";
+                readonly Flac: "flac";
+                readonly Alaw: "alaw";
+                readonly Mulaw: "mulaw";
+                readonly AmrNb: "amr-nb";
+                readonly AmrWb: "amr-wb";
+                readonly Opus: "opus";
+                readonly OggOpus: "ogg-opus";
+                readonly Speex: "speex";
+                readonly G729: "g729";
+            };
+            type Encoding = (typeof Encoding)[keyof typeof Encoding];
+        }
+        /**
+         * Audio output configuration settings
+         */
+        interface Output {
+            /** Audio encoding format for streaming TTS output */
+            encoding?: Output.Encoding;
+            /** Sample rate in Hz */
+            sample_rate?: number;
+            /** Audio bitrate in bits per second */
+            bitrate?: number;
+            /** Audio container format. If omitted, defaults to 'none' */
+            container?: string;
+        }
+        namespace Output {
+            /** Audio encoding format for streaming TTS output */
+            const Encoding: {
+                readonly Linear16: "linear16";
+                readonly Mulaw: "mulaw";
+                readonly Alaw: "alaw";
+            };
+            type Encoding = (typeof Encoding)[keyof typeof Encoding];
+        }
+    }
+    interface Agent {
+        /** Agent language */
+        language?: string;
+        /** Conversation context including the history of messages and function calls */
+        context?: Agent.Context;
+        listen?: Agent.Listen;
+        think?: Agent.Think;
+        speak?: Agent.Speak;
+        /** Optional message that agent will speak at the start */
+        greeting?: string;
+    }
+    namespace Agent {
+        /**
+         * Conversation context including the history of messages and function calls
+         */
+        interface Context {
+            /** Conversation history as a list of messages and function calls */
+            messages?: Context.Messages.Item[];
+        }
+        namespace Context {
+            type Messages = Messages.Item[];
+            namespace Messages {
+                /**
+                 * A message here is either a conversational message or a function call
+                 */
+                type Item = 
+                /**
+                 * Conversation text as part of the conversation history */
+                {
+                    type: "History";
+                    role: "user" | "assistant";
+                    content: string;
+                }
+                /**
+                 * Client-side or server-side function call request and response as part of the conversation history */
+                 | {
+                    type: "History";
+                    function_calls: {
+                        id: string;
+                        name: string;
+                        client_side: boolean;
+                        arguments: string;
+                        response: string;
+                    }[];
+                };
+            }
+        }
+        interface Listen {
+            provider?: Listen.Provider;
+        }
+        namespace Listen {
+            interface Provider {
+                /** Provider type for speech-to-text */
+                type: "deepgram";
+                /** Model to use for speech to text */
+                model?: string;
+                /** Prompt key-term recognition (nova-3 'en' only) */
+                keyterms?: string[];
+                /** Applies smart formatting to improve transcript readability (Deepgram providers only) */
+                smart_format?: boolean;
+            }
+        }
+        interface Think {
+            provider: Think.Provider;
+            /** Optional for non-Deepgram LLM providers. When present, must include url field and headers object */
+            endpoint?: Think.Endpoint;
+            functions?: Think.Functions.Item[];
+            prompt?: string;
+            /** Specifies the number of characters retained in context between user messages, agent responses, and function calls. This setting is only configurable when a custom think endpoint is used */
+            context_length?: Think.ContextLength;
+        }
+        namespace Think {
+            type Provider = {
+                type?: "open_ai" | undefined;
+                model?: ("gpt-5" | "gpt-5-mini" | "gpt-5-nano" | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4.1-nano" | "gpt-4o" | "gpt-4o-mini") | undefined;
+                temperature?: number | undefined;
+            } | {
+                type?: "aws_bedrock" | undefined;
+                model?: ("anthropic/claude-3-5-sonnet-20240620-v1:0" | "anthropic/claude-3-5-haiku-20240307-v1:0") | undefined;
+                temperature?: number | undefined;
+                credentials?: {
+                    type?: ("sts" | "iam") | undefined;
+                    region?: string | undefined;
+                    access_key_id?: string | undefined;
+                    secret_access_key?: string | undefined;
+                    session_token?: string | undefined;
+                } | undefined;
+            } | {
+                type?: "anthropic" | undefined;
+                model?: ("claude-3-5-haiku-latest" | "claude-sonnet-4-20250514") | undefined;
+                temperature?: number | undefined;
+            } | {
+                type?: "google" | undefined;
+                model?: ("gemini-2.0-flash" | "gemini-2.0-flash-lite" | "gemini-2.5-flash") | undefined;
+                temperature?: number | undefined;
+            } | {
+                type?: "groq" | undefined;
+                model?: "openai/gpt-oss-20b" | undefined;
+                temperature?: number | undefined;
+            };
+            /**
+             * Optional for non-Deepgram LLM providers. When present, must include url field and headers object
+             */
+            interface Endpoint {
+                /** Custom LLM endpoint URL */
+                url?: string;
+                /** Custom headers for the endpoint */
+                headers?: Record<string, string>;
+            }
+            type Functions = Functions.Item[];
+            namespace Functions {
+                interface Item {
+                    /** Function name */
+                    name?: string;
+                    /** Function description */
+                    description?: string;
+                    /** Function parameters */
+                    parameters?: Record<string, unknown>;
+                    /** The Function endpoint to call. if not passed, function is called client-side */
+                    endpoint?: Item.Endpoint;
+                }
+                namespace Item {
+                    /**
+                     * The Function endpoint to call. if not passed, function is called client-side
+                     */
+                    interface Endpoint {
+                        /** Endpoint URL */
+                        url?: string;
+                        /** HTTP method */
+                        method?: string;
+                        headers?: Record<string, string>;
+                    }
+                }
+            }
+            /**
+             * Specifies the number of characters retained in context between user messages, agent responses, and function calls. This setting is only configurable when a custom think endpoint is used
+             */
+            type ContextLength = "max" | number;
+        }
+        type Speak = {
+            provider: Deepgram.agent.AgentV1SettingsAgentSpeakEndpointProvider;
+            endpoint?: {
+                url?: string | undefined;
+                headers?: Record<string, string> | undefined;
+            } | undefined;
+        } | {
+            provider: Deepgram.agent.AgentV1SettingsAgentSpeakOneItemProvider;
+            endpoint?: {
+                url?: string | undefined;
+                headers?: Record<string, string> | undefined;
+            } | undefined;
+        }[];
+    }
+}

package/dist/cjs/api/resources/agent/resources/v1/types/AgentV1Settings.js

@@ -0,0 +1,36 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentV1Settings = void 0;
+var AgentV1Settings;
+(function (AgentV1Settings) {
+    let Audio;
+    (function (Audio) {
+        let Input;
+        (function (Input) {
+            /** Audio encoding format */
+            Input.Encoding = {
+                Linear16: "linear16",
+                Linear32: "linear32",
+                Flac: "flac",
+                Alaw: "alaw",
+                Mulaw: "mulaw",
+                AmrNb: "amr-nb",
+                AmrWb: "amr-wb",
+                Opus: "opus",
+                OggOpus: "ogg-opus",
+                Speex: "speex",
+                G729: "g729",
+            };
+        })(Input = Audio.Input || (Audio.Input = {}));
+        let Output;
+        (function (Output) {
+            /** Audio encoding format for streaming TTS output */
+            Output.Encoding = {
+                Linear16: "linear16",
+                Mulaw: "mulaw",
+                Alaw: "alaw",
+            };
+        })(Output = Audio.Output || (Audio.Output = {}));
+    })(Audio = AgentV1Settings.Audio || (AgentV1Settings.Audio = {}));
+})(AgentV1Settings || (exports.AgentV1Settings = AgentV1Settings = {}));

package/dist/cjs/api/resources/agent/resources/v1/types/AgentV1SettingsAgentSpeakEndpointProvider.d.ts

@@ -0,0 +1,186 @@
+import type * as Deepgram from "../../../../../index.js";
+export type AgentV1SettingsAgentSpeakEndpointProvider = Deepgram.agent.AgentV1SettingsAgentSpeakEndpointProvider.Deepgram | Deepgram.agent.AgentV1SettingsAgentSpeakEndpointProvider.ElevenLabs | Deepgram.agent.AgentV1SettingsAgentSpeakEndpointProvider.Cartesia | Deepgram.agent.AgentV1SettingsAgentSpeakEndpointProvider.OpenAi | Deepgram.agent.AgentV1SettingsAgentSpeakEndpointProvider.AwsPolly;
+export declare namespace AgentV1SettingsAgentSpeakEndpointProvider {
+    interface Deepgram {
+        type: "deepgram";
+        /** Deepgram TTS model */
+        model: AgentV1SettingsAgentSpeakEndpointProviderDeepgram.Model;
+    }
+    namespace AgentV1SettingsAgentSpeakEndpointProviderDeepgram {
+        /** Deepgram TTS model */
+        const Model: {
+            readonly AuraAsteriaEn: "aura-asteria-en";
+            readonly AuraLunaEn: "aura-luna-en";
+            readonly AuraStellaEn: "aura-stella-en";
+            readonly AuraAthenaEn: "aura-athena-en";
+            readonly AuraHeraEn: "aura-hera-en";
+            readonly AuraOrionEn: "aura-orion-en";
+            readonly AuraArcasEn: "aura-arcas-en";
+            readonly AuraPerseusEn: "aura-perseus-en";
+            readonly AuraAngusEn: "aura-angus-en";
+            readonly AuraOrpheusEn: "aura-orpheus-en";
+            readonly AuraHeliosEn: "aura-helios-en";
+            readonly AuraZeusEn: "aura-zeus-en";
+            readonly Aura2AmaltheaEn: "aura-2-amalthea-en";
+            readonly Aura2AndromedaEn: "aura-2-andromeda-en";
+            readonly Aura2ApolloEn: "aura-2-apollo-en";
+            readonly Aura2ArcasEn: "aura-2-arcas-en";
+            readonly Aura2AriesEn: "aura-2-aries-en";
+            readonly Aura2AsteriaEn: "aura-2-asteria-en";
+            readonly Aura2AthenaEn: "aura-2-athena-en";
+            readonly Aura2AtlasEn: "aura-2-atlas-en";
+            readonly Aura2AuroraEn: "aura-2-aurora-en";
+            readonly Aura2CallistaEn: "aura-2-callista-en";
+            readonly Aura2CoraEn: "aura-2-cora-en";
+            readonly Aura2CordeliaEn: "aura-2-cordelia-en";
+            readonly Aura2DeliaEn: "aura-2-delia-en";
+            readonly Aura2DracoEn: "aura-2-draco-en";
+            readonly Aura2ElectraEn: "aura-2-electra-en";
+            readonly Aura2HarmoniaEn: "aura-2-harmonia-en";
+            readonly Aura2HelenaEn: "aura-2-helena-en";
+            readonly Aura2HeraEn: "aura-2-hera-en";
+            readonly Aura2HermesEn: "aura-2-hermes-en";
+            readonly Aura2HyperionEn: "aura-2-hyperion-en";
+            readonly Aura2IrisEn: "aura-2-iris-en";
+            readonly Aura2JanusEn: "aura-2-janus-en";
+            readonly Aura2JunoEn: "aura-2-juno-en";
+            readonly Aura2JupiterEn: "aura-2-jupiter-en";
+            readonly Aura2LunaEn: "aura-2-luna-en";
+            readonly Aura2MarsEn: "aura-2-mars-en";
+            readonly Aura2MinervaEn: "aura-2-minerva-en";
+            readonly Aura2NeptuneEn: "aura-2-neptune-en";
+            readonly Aura2OdysseusEn: "aura-2-odysseus-en";
+            readonly Aura2OpheliaEn: "aura-2-ophelia-en";
+            readonly Aura2OrionEn: "aura-2-orion-en";
+            readonly Aura2OrpheusEn: "aura-2-orpheus-en";
+            readonly Aura2PandoraEn: "aura-2-pandora-en";
+            readonly Aura2PhoebeEn: "aura-2-phoebe-en";
+            readonly Aura2PlutoEn: "aura-2-pluto-en";
+            readonly Aura2SaturnEn: "aura-2-saturn-en";
+            readonly Aura2SeleneEn: "aura-2-selene-en";
+            readonly Aura2ThaliaEn: "aura-2-thalia-en";
+            readonly Aura2TheiaEn: "aura-2-theia-en";
+            readonly Aura2VestaEn: "aura-2-vesta-en";
+            readonly Aura2ZeusEn: "aura-2-zeus-en";
+            readonly Aura2SirioEs: "aura-2-sirio-es";
+            readonly Aura2NestorEs: "aura-2-nestor-es";
+            readonly Aura2CarinaEs: "aura-2-carina-es";
+            readonly Aura2CelesteEs: "aura-2-celeste-es";
+            readonly Aura2AlvaroEs: "aura-2-alvaro-es";
+            readonly Aura2DianaEs: "aura-2-diana-es";
+            readonly Aura2AquilaEs: "aura-2-aquila-es";
+            readonly Aura2SelenaEs: "aura-2-selena-es";
+            readonly Aura2EstrellaEs: "aura-2-estrella-es";
+            readonly Aura2JavierEs: "aura-2-javier-es";
+        };
+        type Model = (typeof Model)[keyof typeof Model];
+    }
+    interface ElevenLabs {
+        type: "eleven_labs";
+        /** Eleven Labs model ID */
+        model_id: AgentV1SettingsAgentSpeakEndpointProviderElevenLabs.ModelId;
+        /** Eleven Labs optional language code */
+        language_code?: string;
+    }
+    namespace AgentV1SettingsAgentSpeakEndpointProviderElevenLabs {
+        /** Eleven Labs model ID */
+        const ModelId: {
+            readonly ElevenTurboV25: "eleven_turbo_v2_5";
+            readonly ElevenMonolingualV1: "eleven_monolingual_v1";
+            readonly ElevenMultilingualV2: "eleven_multilingual_v2";
+        };
+        type ModelId = (typeof ModelId)[keyof typeof ModelId];
+    }
+    interface Cartesia {
+        type: "cartesia";
+        /** Cartesia model ID */
+        model_id: AgentV1SettingsAgentSpeakEndpointProviderCartesia.ModelId;
+        voice: AgentV1SettingsAgentSpeakEndpointProviderCartesia.Voice;
+        /** Cartesia language code */
+        language?: string;
+    }
+    namespace AgentV1SettingsAgentSpeakEndpointProviderCartesia {
+        /** Cartesia model ID */
+        const ModelId: {
+            readonly Sonic2: "sonic-2";
+            readonly SonicMultilingual: "sonic-multilingual";
+        };
+        type ModelId = (typeof ModelId)[keyof typeof ModelId];
+        interface Voice {
+            /** Cartesia voice mode */
+            mode: string;
+            /** Cartesia voice ID */
+            id: string;
+        }
+    }
+    interface OpenAi {
+        type: "open_ai";
+        /** OpenAI TTS model */
+        model: AgentV1SettingsAgentSpeakEndpointProviderOpenAi.Model;
+        /** OpenAI voice */
+        voice: AgentV1SettingsAgentSpeakEndpointProviderOpenAi.Voice;
+    }
+    namespace AgentV1SettingsAgentSpeakEndpointProviderOpenAi {
+        /** OpenAI TTS model */
+        const Model: {
+            readonly Tts1: "tts-1";
+            readonly Tts1Hd: "tts-1-hd";
+        };
+        type Model = (typeof Model)[keyof typeof Model];
+        /** OpenAI voice */
+        const Voice: {
+            readonly Alloy: "alloy";
+            readonly Echo: "echo";
+            readonly Fable: "fable";
+            readonly Onyx: "onyx";
+            readonly Nova: "nova";
+            readonly Shimmer: "shimmer";
+        };
+        type Voice = (typeof Voice)[keyof typeof Voice];
+    }
+    interface AwsPolly {
+        type: "aws_polly";
+        /** AWS Polly voice name */
+        voice: AgentV1SettingsAgentSpeakEndpointProviderAwsPolly.Voice;
+        /** Language code (e.g., "en-US") */
+        language_code: string;
+        engine: AgentV1SettingsAgentSpeakEndpointProviderAwsPolly.Engine;
+        credentials: AgentV1SettingsAgentSpeakEndpointProviderAwsPolly.Credentials;
+    }
+    namespace AgentV1SettingsAgentSpeakEndpointProviderAwsPolly {
+        /** AWS Polly voice name */
+        const Voice: {
+            readonly Matthew: "Matthew";
+            readonly Joanna: "Joanna";
+            readonly Amy: "Amy";
+            readonly Emma: "Emma";
+            readonly Brian: "Brian";
+            readonly Arthur: "Arthur";
+            readonly Aria: "Aria";
+            readonly Ayanda: "Ayanda";
+        };
+        type Voice = (typeof Voice)[keyof typeof Voice];
+        const Engine: {
+            readonly Generative: "generative";
+            readonly LongForm: "long-form";
+            readonly Standard: "standard";
+            readonly Neural: "neural";
+        };
+        type Engine = (typeof Engine)[keyof typeof Engine];
+        interface Credentials {
+            type: Credentials.Type;
+            region: string;
+            access_key_id: string;
+            secret_access_key: string;
+            /** Required for STS only */
+            session_token?: string;
+        }
+        namespace Credentials {
+            const Type: {
+                readonly Sts: "sts";
+                readonly Iam: "iam";
+            };
+            type Type = (typeof Type)[keyof typeof Type];
+        }
+    }
+}

package/dist/cjs/api/resources/agent/resources/v1/types/AgentV1SettingsAgentSpeakEndpointProvider.js

@@ -0,0 +1,137 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentV1SettingsAgentSpeakEndpointProvider = void 0;
+var AgentV1SettingsAgentSpeakEndpointProvider;
+(function (AgentV1SettingsAgentSpeakEndpointProvider) {
+    let AgentV1SettingsAgentSpeakEndpointProviderDeepgram;
+    (function (AgentV1SettingsAgentSpeakEndpointProviderDeepgram) {
+        /** Deepgram TTS model */
+        AgentV1SettingsAgentSpeakEndpointProviderDeepgram.Model = {
+            AuraAsteriaEn: "aura-asteria-en",
+            AuraLunaEn: "aura-luna-en",
+            AuraStellaEn: "aura-stella-en",
+            AuraAthenaEn: "aura-athena-en",
+            AuraHeraEn: "aura-hera-en",
+            AuraOrionEn: "aura-orion-en",
+            AuraArcasEn: "aura-arcas-en",
+            AuraPerseusEn: "aura-perseus-en",
+            AuraAngusEn: "aura-angus-en",
+            AuraOrpheusEn: "aura-orpheus-en",
+            AuraHeliosEn: "aura-helios-en",
+            AuraZeusEn: "aura-zeus-en",
+            Aura2AmaltheaEn: "aura-2-amalthea-en",
+            Aura2AndromedaEn: "aura-2-andromeda-en",
+            Aura2ApolloEn: "aura-2-apollo-en",
+            Aura2ArcasEn: "aura-2-arcas-en",
+            Aura2AriesEn: "aura-2-aries-en",
+            Aura2AsteriaEn: "aura-2-asteria-en",
+            Aura2AthenaEn: "aura-2-athena-en",
+            Aura2AtlasEn: "aura-2-atlas-en",
+            Aura2AuroraEn: "aura-2-aurora-en",
+            Aura2CallistaEn: "aura-2-callista-en",
+            Aura2CoraEn: "aura-2-cora-en",
+            Aura2CordeliaEn: "aura-2-cordelia-en",
+            Aura2DeliaEn: "aura-2-delia-en",
+            Aura2DracoEn: "aura-2-draco-en",
+            Aura2ElectraEn: "aura-2-electra-en",
+            Aura2HarmoniaEn: "aura-2-harmonia-en",
+            Aura2HelenaEn: "aura-2-helena-en",
+            Aura2HeraEn: "aura-2-hera-en",
+            Aura2HermesEn: "aura-2-hermes-en",
+            Aura2HyperionEn: "aura-2-hyperion-en",
+            Aura2IrisEn: "aura-2-iris-en",
+            Aura2JanusEn: "aura-2-janus-en",
+            Aura2JunoEn: "aura-2-juno-en",
+            Aura2JupiterEn: "aura-2-jupiter-en",
+            Aura2LunaEn: "aura-2-luna-en",
+            Aura2MarsEn: "aura-2-mars-en",
+            Aura2MinervaEn: "aura-2-minerva-en",
+            Aura2NeptuneEn: "aura-2-neptune-en",
+            Aura2OdysseusEn: "aura-2-odysseus-en",
+            Aura2OpheliaEn: "aura-2-ophelia-en",
+            Aura2OrionEn: "aura-2-orion-en",
+            Aura2OrpheusEn: "aura-2-orpheus-en",
+            Aura2PandoraEn: "aura-2-pandora-en",
+            Aura2PhoebeEn: "aura-2-phoebe-en",
+            Aura2PlutoEn: "aura-2-pluto-en",
+            Aura2SaturnEn: "aura-2-saturn-en",
+            Aura2SeleneEn: "aura-2-selene-en",
+            Aura2ThaliaEn: "aura-2-thalia-en",
+            Aura2TheiaEn: "aura-2-theia-en",
+            Aura2VestaEn: "aura-2-vesta-en",
+            Aura2ZeusEn: "aura-2-zeus-en",
+            Aura2SirioEs: "aura-2-sirio-es",
+            Aura2NestorEs: "aura-2-nestor-es",
+            Aura2CarinaEs: "aura-2-carina-es",
+            Aura2CelesteEs: "aura-2-celeste-es",
+            Aura2AlvaroEs: "aura-2-alvaro-es",
+            Aura2DianaEs: "aura-2-diana-es",
+            Aura2AquilaEs: "aura-2-aquila-es",
+            Aura2SelenaEs: "aura-2-selena-es",
+            Aura2EstrellaEs: "aura-2-estrella-es",
+            Aura2JavierEs: "aura-2-javier-es",
+        };
+    })(AgentV1SettingsAgentSpeakEndpointProviderDeepgram = AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderDeepgram || (AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderDeepgram = {}));
+    let AgentV1SettingsAgentSpeakEndpointProviderElevenLabs;
+    (function (AgentV1SettingsAgentSpeakEndpointProviderElevenLabs) {
+        /** Eleven Labs model ID */
+        AgentV1SettingsAgentSpeakEndpointProviderElevenLabs.ModelId = {
+            ElevenTurboV25: "eleven_turbo_v2_5",
+            ElevenMonolingualV1: "eleven_monolingual_v1",
+            ElevenMultilingualV2: "eleven_multilingual_v2",
+        };
+    })(AgentV1SettingsAgentSpeakEndpointProviderElevenLabs = AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderElevenLabs || (AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderElevenLabs = {}));
+    let AgentV1SettingsAgentSpeakEndpointProviderCartesia;
+    (function (AgentV1SettingsAgentSpeakEndpointProviderCartesia) {
+        /** Cartesia model ID */
+        AgentV1SettingsAgentSpeakEndpointProviderCartesia.ModelId = {
+            Sonic2: "sonic-2",
+            SonicMultilingual: "sonic-multilingual",
+        };
+    })(AgentV1SettingsAgentSpeakEndpointProviderCartesia = AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderCartesia || (AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderCartesia = {}));
+    let AgentV1SettingsAgentSpeakEndpointProviderOpenAi;
+    (function (AgentV1SettingsAgentSpeakEndpointProviderOpenAi) {
+        /** OpenAI TTS model */
+        AgentV1SettingsAgentSpeakEndpointProviderOpenAi.Model = {
+            Tts1: "tts-1",
+            Tts1Hd: "tts-1-hd",
+        };
+        /** OpenAI voice */
+        AgentV1SettingsAgentSpeakEndpointProviderOpenAi.Voice = {
+            Alloy: "alloy",
+            Echo: "echo",
+            Fable: "fable",
+            Onyx: "onyx",
+            Nova: "nova",
+            Shimmer: "shimmer",
+        };
+    })(AgentV1SettingsAgentSpeakEndpointProviderOpenAi = AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderOpenAi || (AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderOpenAi = {}));
+    let AgentV1SettingsAgentSpeakEndpointProviderAwsPolly;
+    (function (AgentV1SettingsAgentSpeakEndpointProviderAwsPolly) {
+        /** AWS Polly voice name */
+        AgentV1SettingsAgentSpeakEndpointProviderAwsPolly.Voice = {
+            Matthew: "Matthew",
+            Joanna: "Joanna",
+            Amy: "Amy",
+            Emma: "Emma",
+            Brian: "Brian",
+            Arthur: "Arthur",
+            Aria: "Aria",
+            Ayanda: "Ayanda",
+        };
+        AgentV1SettingsAgentSpeakEndpointProviderAwsPolly.Engine = {
+            Generative: "generative",
+            LongForm: "long-form",
+            Standard: "standard",
+            Neural: "neural",
+        };
+        let Credentials;
+        (function (Credentials) {
+            Credentials.Type = {
+                Sts: "sts",
+                Iam: "iam",
+            };
+        })(Credentials = AgentV1SettingsAgentSpeakEndpointProviderAwsPolly.Credentials || (AgentV1SettingsAgentSpeakEndpointProviderAwsPolly.Credentials = {}));
+    })(AgentV1SettingsAgentSpeakEndpointProviderAwsPolly = AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderAwsPolly || (AgentV1SettingsAgentSpeakEndpointProvider.AgentV1SettingsAgentSpeakEndpointProviderAwsPolly = {}));
+})(AgentV1SettingsAgentSpeakEndpointProvider || (exports.AgentV1SettingsAgentSpeakEndpointProvider = AgentV1SettingsAgentSpeakEndpointProvider = {}));