@dialgem/sdk 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/index.d.cts

@@ -110,7 +110,12 @@ type Fetch = (url: string, init: FetchInit) => Promise<FetchResponse>;
 interface FetchInit {
     method: string;
     headers: Record<string, string>;
-    body?: string;
+    /**
+     * A JSON string, or a `FormData` for a file upload — in which case
+     * `Content-Type` is deliberately absent, since only `fetch` knows the
+     * multipart boundary it is about to generate.
+     */
+    body?: string | FormData;
     signal: AbortSignal;
     /**
      * Always `"manual"`. A followed redirect re-sends the API key to wherever the
@@ -133,7 +138,7 @@ interface RequestOptions {
     /**
      * Retries on 408/429/5xx and connection failures.
      *
-     * GET, PATCH and DELETE use the client's `maxRetries` unless overridden here.
+     * GET, PUT, PATCH and DELETE use the client's `maxRetries` unless overridden here.
      * **POST is never retried unless you set this explicitly**: most POSTs create
      * things, and an outbound call retried after an ambiguous 502 dials the person twice.
      */
@@ -143,7 +148,9 @@ interface RequestOptions {
     /** Extra headers for this request only. */
     headers?: Record<string, string> | undefined;
 }
-type QueryValue = string | number | boolean | null | undefined;
+type QueryScalar = string | number | boolean;
+/** Arrays are sent as repeated parameters: `{ status: ["a", "b"] }` → `?status=a&status=b`. */
+type QueryValue = QueryScalar | QueryScalar[] | null | undefined;
 type Query = Record<string, QueryValue>;
 interface HttpClientOptions {
     apiKey: string;
@@ -153,13 +160,22 @@ interface HttpClientOptions {
     fetch: Fetch;
     defaultHeaders: Record<string, string>;
 }
-type Method = "GET" | "POST" | "PATCH" | "DELETE";
+type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 declare class HttpClient {
     #private;
     readonly baseURL: string;
     constructor(options: HttpClientOptions);
     get<T>(path: string, query?: Query, options?: RequestOptions): Promise<T>;
     post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * POST a `FormData` body — file uploads.
+     *
+     * The body is sent as-is and `Content-Type` is left unset, because only
+     * `fetch` knows the multipart boundary it is about to generate. Setting the
+     * header ourselves produces a request no server can parse.
+     */
+    postForm<T>(path: string, form: FormData, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
     patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
     delete<T>(path: string, options?: RequestOptions): Promise<T>;
     request<T>(method: Method, path: string, { query, body, options }: {
@@ -175,12 +191,22 @@ interface components {
     schemas: {
         /** AgentCreate */
         AgentCreate: {
+            /**
+             * Adaptive Response Wait
+             * @default false
+             */
+            adaptive_response_wait?: boolean;
             /**
              * Agent Type
              * @default llm
              * @enum {string}
              */
             agent_type?: "llm" | "multi_prompt" | "flow";
+            /**
+             * Allow User Dtmf
+             * @default false
+             */
+            allow_user_dtmf?: boolean;
             /**
              * Ambient Sound
              * @default none
@@ -204,8 +230,24 @@ interface components {
             begin_message_delay_ms?: number;
             /** Boosted Keywords */
             boosted_keywords?: string[];
+            /**
+             * Call Screen Handling Enabled
+             * @default false
+             */
+            call_screen_handling_enabled?: boolean;
+            /**
+             * Call Screen Message
+             * @default
+             */
+            call_screen_message?: string;
             /** Data Retention Days */
             data_retention_days?: number | null;
+            /**
+             * Data Storage Setting
+             * @default everything
+             * @enum {string}
+             */
+            data_storage_setting?: "everything" | "everything_except_pii" | "basic_attributes_only";
             /** Default Dynamic Variables */
             default_dynamic_variables?: {
                 [key: string]: string;
@@ -215,7 +257,17 @@ interface components {
              * @default off
              * @enum {string}
              */
-            denoising_mode?: "off" | "noise-cancellation";
+            denoising_mode?: "off" | "noise-cancellation" | "noise-and-background-speech-cancellation";
+            /**
+             * Denoising Strength
+             * @default 0.5
+             */
+            denoising_strength?: number;
+            /**
+             * Dnc Detection Enabled
+             * @default false
+             */
+            dnc_detection_enabled?: boolean;
             /**
              * Enable Backchannel
              * @default false
@@ -240,16 +292,30 @@ interface components {
             /** First Message */
             first_message?: string | null;
             flow_config?: components["schemas"]["FlowConfig"] | null;
+            /** Flow Id */
+            flow_id?: string | null;
             /**
              * Interruption Sensitivity
              * @default 1
              */
             interruption_sensitivity?: number;
+            /**
+             * Ivr Hangup Enabled
+             * @default false
+             */
+            ivr_hangup_enabled?: boolean;
+            /**
+             * Ivr Prompt
+             * @default
+             */
+            ivr_prompt?: string;
             /**
              * Language
              * @default en
              */
             language?: string;
+            /** Llm Id */
+            llm_id?: string | null;
             /** Llm Model */
             llm_model?: string;
             /**
@@ -279,6 +345,8 @@ interface components {
              * @default false
              */
             opt_out_transcript_storage?: boolean;
+            /** Pii Categories */
+            pii_categories?: ("email" | "credit_card" | "ssn" | "phone_number")[];
             /**
              * Pii Redaction Enabled
              * @default false
@@ -291,6 +359,11 @@ interface components {
              * @default claude-sonnet-4-6
              */
             post_call_analysis_model?: string;
+            post_call_builtin_fields?: components["schemas"]["BuiltinAnalysisFields"];
+            /** Pronunciation Dictionary */
+            pronunciation_dictionary?: components["schemas"]["PronunciationEntry"][];
+            /** Reminder Max Count */
+            reminder_max_count?: number | null;
             /**
              * Reminder Message
              * @default
@@ -315,6 +388,12 @@ interface components {
             starting_state?: string | null;
             /** States */
             states?: components["schemas"]["PromptState"][];
+            /**
+             * Stt Mode
+             * @default fast
+             * @enum {string}
+             */
+            stt_mode?: "fast" | "accurate";
             /**
              * Stt Model
              * @enum {string}
@@ -335,6 +414,13 @@ interface components {
              * @default cartesia
              */
             tts_engine?: string;
+            user_dtmf_options?: components["schemas"]["UserDtmfOptions"];
+            /**
+             * Vocab Specialization
+             * @default general
+             * @enum {string}
+             */
+            vocab_specialization?: "general" | "medical";
             /**
              * Voice Id
              * @default
@@ -366,10 +452,20 @@ interface components {
              * @default
              */
             voicemail_message?: string;
+            /**
+             * Voicemail Prompt
+             * @default
+             */
+            voicemail_prompt?: string;
             /** Webhook Events */
-            webhook_events?: ("call_started" | "call_ended" | "call_analyzed")[];
+            webhook_events?: ("call_started" | "call_ended" | "call_analyzed" | "transcript_updated" | "transfer_started" | "transfer_bridged" | "transfer_cancelled" | "transfer_ended" | "chat_started" | "chat_ended" | "chat_analyzed")[];
             /** Webhook Signing Secret */
             webhook_signing_secret?: string | null;
+            /**
+             * Webhook Timeout Ms
+             * @default 10000
+             */
+            webhook_timeout_ms?: number;
             /** Webhook Url */
             webhook_url?: string | null;
         };
@@ -417,8 +513,12 @@ interface components {
         };
         /** AgentUpdate */
         AgentUpdate: {
+            /** Adaptive Response Wait */
+            adaptive_response_wait?: boolean | null;
             /** Agent Type */
             agent_type?: ("llm" | "multi_prompt" | "flow") | null;
+            /** Allow User Dtmf */
+            allow_user_dtmf?: boolean | null;
             /** Ambient Sound */
             ambient_sound?: ("none" | "coffee-shop" | "call-center" | "convention-hall" | "summer-outdoor" | "mountain-outdoor" | "static-noise") | null;
             /** Ambient Sound Volume */
@@ -429,14 +529,24 @@ interface components {
             begin_message_delay_ms?: number | null;
             /** Boosted Keywords */
             boosted_keywords?: string[] | null;
+            /** Call Screen Handling Enabled */
+            call_screen_handling_enabled?: boolean | null;
+            /** Call Screen Message */
+            call_screen_message?: string | null;
             /** Data Retention Days */
             data_retention_days?: number | null;
+            /** Data Storage Setting */
+            data_storage_setting?: ("everything" | "everything_except_pii" | "basic_attributes_only") | null;
             /** Default Dynamic Variables */
             default_dynamic_variables?: {
                 [key: string]: string;
             } | null;
             /** Denoising Mode */
-            denoising_mode?: ("off" | "noise-cancellation") | null;
+            denoising_mode?: ("off" | "noise-cancellation" | "noise-and-background-speech-cancellation") | null;
+            /** Denoising Strength */
+            denoising_strength?: number | null;
+            /** Dnc Detection Enabled */
+            dnc_detection_enabled?: boolean | null;
             /** Enable Backchannel */
             enable_backchannel?: boolean | null;
             /** Enable Transcription Formatting */
@@ -452,10 +562,20 @@ interface components {
             /** First Message */
             first_message?: string | null;
             flow_config?: components["schemas"]["FlowConfig"] | null;
+            /** Flow Id */
+            flow_id?: string | null;
+            /** Folder Id */
+            folder_id?: string | null;
             /** Interruption Sensitivity */
             interruption_sensitivity?: number | null;
+            /** Ivr Hangup Enabled */
+            ivr_hangup_enabled?: boolean | null;
+            /** Ivr Prompt */
+            ivr_prompt?: string | null;
             /** Language */
             language?: string | null;
+            /** Llm Id */
+            llm_id?: string | null;
             /** Llm Model */
             llm_model?: string | null;
             /** Llm Provider */
@@ -470,12 +590,19 @@ interface components {
             opt_out_call_recording?: boolean | null;
             /** Opt Out Transcript Storage */
             opt_out_transcript_storage?: boolean | null;
+            /** Pii Categories */
+            pii_categories?: ("email" | "credit_card" | "ssn" | "phone_number")[] | null;
             /** Pii Redaction Enabled */
             pii_redaction_enabled?: boolean | null;
             /** Post Call Analysis Data */
             post_call_analysis_data?: components["schemas"]["PostCallAnalysisVariable"][] | null;
             /** Post Call Analysis Model */
             post_call_analysis_model?: string | null;
+            post_call_builtin_fields?: components["schemas"]["BuiltinAnalysisFields"] | null;
+            /** Pronunciation Dictionary */
+            pronunciation_dictionary?: components["schemas"]["PronunciationEntry"][] | null;
+            /** Reminder Max Count */
+            reminder_max_count?: number | null;
             /** Reminder Message */
             reminder_message?: string | null;
             /** Reminder Trigger Ms */
@@ -488,6 +615,8 @@ interface components {
             starting_state?: string | null;
             /** States */
             states?: components["schemas"]["PromptState"][] | null;
+            /** Stt Mode */
+            stt_mode?: ("fast" | "accurate") | null;
             /** Stt Model */
             stt_model?: ("whisper" | "conformer" | "deepgram") | null;
             /** System Prompt */
@@ -496,6 +625,9 @@ interface components {
             temperature?: number | null;
             /** Tts Engine */
             tts_engine?: string | null;
+            user_dtmf_options?: components["schemas"]["UserDtmfOptions"] | null;
+            /** Vocab Specialization */
+            vocab_specialization?: ("general" | "medical") | null;
             /** Voice Id */
             voice_id?: string | null;
             /** Voice Speed */
@@ -508,13 +640,24 @@ interface components {
             voicemail_detection_enabled?: boolean | null;
             /** Voicemail Message */
             voicemail_message?: string | null;
+            /** Voicemail Prompt */
+            voicemail_prompt?: string | null;
             /** Webhook Events */
-            webhook_events?: ("call_started" | "call_ended" | "call_analyzed")[] | null;
+            webhook_events?: ("call_started" | "call_ended" | "call_analyzed" | "transcript_updated" | "transfer_started" | "transfer_bridged" | "transfer_cancelled" | "transfer_ended" | "chat_started" | "chat_ended" | "chat_analyzed")[] | null;
             /** Webhook Signing Secret */
             webhook_signing_secret?: string | null;
+            /** Webhook Timeout Ms */
+            webhook_timeout_ms?: number | null;
             /** Webhook Url */
             webhook_url?: string | null;
         };
+        /** AgentVersionCreate */
+        AgentVersionCreate: {
+            /** Description */
+            description?: string | null;
+            /** Title */
+            title?: string | null;
+        };
         /** AgentWeightIn */
         AgentWeightIn: {
             /** Agent Id */
@@ -523,13 +666,34 @@ interface components {
              * Agent Version
              * @default 0
              */
-            agent_version?: number;
+            agent_version?: number | "latest_published";
             /**
              * Weight
              * @default 1
              */
             weight?: number;
         };
+        /** Body_clone_voice_v1_voices_clone_post */
+        Body_clone_voice_v1_voices_clone_post: {
+            /** Consent Confirmed */
+            consent_confirmed: boolean;
+            /** Description */
+            description?: string | null;
+            /**
+             * Engine
+             * @default elevenlabs
+             */
+            engine?: string;
+            /** Files */
+            files: string[];
+            /**
+             * Language
+             * @default en
+             */
+            language?: string;
+            /** Name */
+            name: string;
+        };
         /** BranchNode */
         BranchNode: {
             display_position?: components["schemas"]["DisplayPosition"] | null;
@@ -551,6 +715,255 @@ interface components {
         } & {
             [key: string]: unknown;
         };
+        /** BuiltinAnalysisField */
+        BuiltinAnalysisField: {
+            /** Choices */
+            choices?: string[] | null;
+            /** Description */
+            description?: string | null;
+            /**
+             * Enabled
+             * @default true
+             */
+            enabled?: boolean;
+        };
+        /** BuiltinAnalysisFields */
+        BuiltinAnalysisFields: {
+            call_successful?: components["schemas"]["BuiltinAnalysisField"] | null;
+            call_summary?: components["schemas"]["BuiltinAnalysisField"] | null;
+            user_sentiment?: components["schemas"]["BuiltinAnalysisField"] | null;
+        };
+        /** CallPatch */
+        CallPatch: {
+            /** Amd Result */
+            amd_result?: {
+                [key: string]: unknown;
+            } | null;
+            /** Call Sid */
+            call_sid?: string | null;
+            /** Disconnection Reason */
+            disconnection_reason?: string | null;
+            /** Duration S */
+            duration_s?: number | null;
+            /** Ended At */
+            ended_at?: string | null;
+            /** Events */
+            events?: unknown[] | null;
+            /** Meta */
+            meta?: {
+                [key: string]: unknown;
+            } | null;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Origination State */
+            origination_state?: string | null;
+            /** Recording Key */
+            recording_key?: string | null;
+            /** Status */
+            status?: string | null;
+            /** Transcript */
+            transcript?: unknown[] | null;
+        };
+        /** CaseBody */
+        CaseBody: {
+            /** Caller */
+            caller: {
+                [key: string]: unknown;
+            };
+            /** Checks */
+            checks: {
+                [key: string]: unknown;
+            }[];
+            /** Dynamic Variables */
+            dynamic_variables?: {
+                [key: string]: unknown;
+            };
+            /** Name */
+            name: string;
+            /** Tool Mocks */
+            tool_mocks?: {
+                [key: string]: unknown;
+            };
+        };
+        /** CaseUpdate */
+        CaseUpdate: {
+            /** Caller */
+            caller?: {
+                [key: string]: unknown;
+            } | null;
+            /** Checks */
+            checks?: {
+                [key: string]: unknown;
+            }[] | null;
+            /** Dynamic Variables */
+            dynamic_variables?: {
+                [key: string]: unknown;
+            } | null;
+            /** Name */
+            name?: string | null;
+            /** Tool Mocks */
+            tool_mocks?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        /** ChatCreate */
+        ChatCreate: {
+            /** Agent Id */
+            agent_id: string;
+            /** Agent Version */
+            agent_version?: number | null;
+            /** Dynamic Variables */
+            dynamic_variables?: {
+                [key: string]: unknown;
+            } | null;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        /** ChatMessageCreate */
+        ChatMessageCreate: {
+            /** Content */
+            content: string;
+        };
+        /** ChatUpdate */
+        ChatUpdate: {
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        /** CodeNode */
+        CodeNode: {
+            /** Code */
+            code?: string | null;
+            display_position?: components["schemas"]["DisplayPosition"] | null;
+            /** Edges */
+            edges?: components["schemas"]["Edge"][];
+            else_edge?: components["schemas"]["Edge"] | null;
+            /** Enable Typing Sound */
+            enable_typing_sound?: boolean | null;
+            /** Execution Status Variable */
+            execution_status_variable?: string | null;
+            /** Finetune Transition Examples */
+            finetune_transition_examples?: unknown[] | null;
+            global_node_setting?: components["schemas"]["GlobalNodeSetting"] | null;
+            /** Id */
+            id: string;
+            instruction?: components["schemas"]["Instruction"] | null;
+            /** Name */
+            name?: string | null;
+            /** Response Variables */
+            response_variables?: {
+                [key: string]: string;
+            } | null;
+            /** Speak During Execution */
+            speak_during_execution?: boolean | null;
+            /** Timeout Ms */
+            timeout_ms?: number | null;
+            /**
+             * Type
+             * @constant
+             */
+            type: "code";
+            /** Wait For Result */
+            wait_for_result?: boolean | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /** ContactCreate */
+        ContactCreate: {
+            /** Attributes */
+            attributes?: {
+                [key: string]: unknown;
+            };
+            /** Default Country */
+            default_country?: string | null;
+            /** Email */
+            email?: string | null;
+            /** First Name */
+            first_name?: string | null;
+            /** Last Name */
+            last_name?: string | null;
+            /** List Ids */
+            list_ids?: string[];
+            /** Phone */
+            phone: string;
+            /** Timezone */
+            timezone?: string | null;
+        };
+        /** ContactCsvInspectRequest */
+        ContactCsvInspectRequest: {
+            /** Csv */
+            csv: string;
+        };
+        /** ContactImportCreate */
+        ContactImportCreate: {
+            /** Attribute Columns */
+            attribute_columns?: string[] | null;
+            /** Csv */
+            csv: string;
+            /** Default Country */
+            default_country?: string | null;
+            /**
+             * Dry Run
+             * @default false
+             */
+            dry_run?: boolean;
+            /** Filename */
+            filename?: string | null;
+            /** List Id */
+            list_id?: string | null;
+            /** Mapping */
+            mapping?: {
+                [key: string]: string;
+            } | null;
+            /**
+             * On Duplicate
+             * @default update
+             */
+            on_duplicate?: string;
+        };
+        /** ContactListCreate */
+        ContactListCreate: {
+            /** Description */
+            description?: string | null;
+            /** Name */
+            name: string;
+        };
+        /** ContactListMembersAdd */
+        ContactListMembersAdd: {
+            /** Contact Ids */
+            contact_ids: string[];
+        };
+        /** ContactListUpdate */
+        ContactListUpdate: {
+            /** Description */
+            description?: string | null;
+            /** Name */
+            name?: string | null;
+        };
+        /** ContactUpdate */
+        ContactUpdate: {
+            /** Attributes */
+            attributes?: {
+                [key: string]: unknown;
+            } | null;
+            /** Default Country */
+            default_country?: string | null;
+            /** Email */
+            email?: string | null;
+            /** First Name */
+            first_name?: string | null;
+            /** Last Name */
+            last_name?: string | null;
+            /** Phone */
+            phone?: string | null;
+            /** Timezone */
+            timezone?: string | null;
+        };
         /** ConversationNode */
         ConversationNode: {
             /** Allow Dtmf Interruption */
@@ -745,7 +1158,7 @@ interface components {
             /** Model Temperature */
             model_temperature?: number | null;
             /** Nodes */
-            nodes?: (components["schemas"]["ConversationNode"] | components["schemas"]["SubagentNode"] | components["schemas"]["FunctionNode"] | components["schemas"]["McpNode"] | components["schemas"]["BranchNode"] | components["schemas"]["ExtractDynamicVariablesNode"] | components["schemas"]["TransferCallNode"] | components["schemas"]["PressDigitNode"] | components["schemas"]["AgentSwapNode"] | components["schemas"]["SmsNode"] | components["schemas"]["EndNode"] | components["schemas"]["OpaqueNode"])[];
+            nodes?: (components["schemas"]["ConversationNode"] | components["schemas"]["SubagentNode"] | components["schemas"]["FunctionNode"] | components["schemas"]["McpNode"] | components["schemas"]["CodeNode"] | components["schemas"]["BranchNode"] | components["schemas"]["ExtractDynamicVariablesNode"] | components["schemas"]["TransferCallNode"] | components["schemas"]["PressDigitNode"] | components["schemas"]["AgentSwapNode"] | components["schemas"]["SmsNode"] | components["schemas"]["EndNode"] | components["schemas"]["OpaqueNode"])[];
             /** Notes */
             notes?: unknown[] | null;
             /** Start Node Id */
@@ -761,6 +1174,17 @@ interface components {
         } & {
             [key: string]: unknown;
         };
+        /** FlowCreate */
+        FlowCreate: {
+            flow_config: components["schemas"]["FlowConfig"];
+            /**
+             * Language
+             * @default en
+             */
+            language?: string;
+            /** Name */
+            name: string;
+        };
         /** FlowTool */
         FlowTool: {
             /** Description */
@@ -792,8 +1216,21 @@ interface components {
         } & {
             [key: string]: unknown;
         };
+        /** FlowUpdate */
+        FlowUpdate: {
+            flow_config?: components["schemas"]["FlowConfig"] | null;
+            /** Language */
+            language?: string | null;
+            /** Name */
+            name?: string | null;
+        };
         /** FunctionCreate */
         FunctionCreate: {
+            /**
+             * Args At Root
+             * @default false
+             */
+            args_at_root?: boolean;
             /** Config */
             config?: {
                 [key: string]: unknown;
@@ -810,7 +1247,7 @@ interface components {
              * @default custom
              * @enum {string}
              */
-            kind?: "custom" | "end_call" | "transfer_call" | "press_digit" | "agent_swap" | "check_availability_cal" | "book_appointment_cal";
+            kind?: "custom" | "end_call" | "transfer_call" | "press_digit" | "agent_swap" | "check_availability_cal" | "book_appointment_cal" | "cancel_appointment_cal" | "reschedule_appointment_cal" | "check_availability_gcal" | "book_appointment_gcal";
             /**
              * Method
              * @default POST
@@ -848,6 +1285,11 @@ interface components {
         };
         /** FunctionDef */
         FunctionDef: {
+            /**
+             * Args At Root
+             * @default false
+             */
+            args_at_root?: boolean;
             /** Config */
             config?: {
                 [key: string]: unknown;
@@ -866,7 +1308,7 @@ interface components {
              * @default custom
              * @enum {string}
              */
-            kind?: "custom" | "check_availability_cal" | "book_appointment_cal" | "end_call" | "transfer_call" | "press_digit" | "agent_swap";
+            kind?: "custom" | "check_availability_cal" | "book_appointment_cal" | "cancel_appointment_cal" | "reschedule_appointment_cal" | "check_availability_gcal" | "book_appointment_gcal" | "end_call" | "transfer_call" | "press_digit" | "agent_swap";
             /**
              * Method
              * @default POST
@@ -935,6 +1377,8 @@ interface components {
         };
         /** FunctionUpdate */
         FunctionUpdate: {
+            /** Args At Root */
+            args_at_root?: boolean | null;
             /** Config */
             config?: {
                 [key: string]: unknown;
@@ -1041,6 +1485,56 @@ interface components {
             /** Value */
             value: string;
         };
+        /** LLMCreate */
+        LLMCreate: {
+            /** Default Dynamic Variables */
+            default_dynamic_variables?: {
+                [key: string]: string;
+            } | null;
+            /** Fallback Llm Model */
+            fallback_llm_model?: string | null;
+            /** Fallback Llm Provider */
+            fallback_llm_provider?: ("anthropic" | "openai") | null;
+            /** First Message */
+            first_message?: string | null;
+            /** Llm Model */
+            llm_model?: string | null;
+            /** Llm Provider */
+            llm_provider?: ("anthropic" | "openai") | null;
+            /** Max Tokens */
+            max_tokens?: number | null;
+            /** Name */
+            name: string;
+            /** System Prompt */
+            system_prompt?: string | null;
+            /** Temperature */
+            temperature?: number | null;
+        };
+        /** LLMUpdate */
+        LLMUpdate: {
+            /** Default Dynamic Variables */
+            default_dynamic_variables?: {
+                [key: string]: string;
+            } | null;
+            /** Fallback Llm Model */
+            fallback_llm_model?: string | null;
+            /** Fallback Llm Provider */
+            fallback_llm_provider?: ("anthropic" | "openai") | null;
+            /** First Message */
+            first_message?: string | null;
+            /** Llm Model */
+            llm_model?: string | null;
+            /** Llm Provider */
+            llm_provider?: ("anthropic" | "openai") | null;
+            /** Max Tokens */
+            max_tokens?: number | null;
+            /** Name */
+            name?: string | null;
+            /** System Prompt */
+            system_prompt?: string | null;
+            /** Temperature */
+            temperature?: number | null;
+        };
         /** McpNode */
         McpNode: {
             display_position?: components["schemas"]["DisplayPosition"] | null;
@@ -1155,12 +1649,21 @@ interface components {
         OutboundCallRequest: {
             /** Agent Id */
             agent_id?: string | null;
+            /**
+             * Agent Version
+             * @default 0
+             */
+            agent_version?: number | "latest_published";
             /** Dialgem Llm Dynamic Variables */
             dialgem_llm_dynamic_variables?: {
                 [key: string]: unknown;
             } | null;
             /** From */
             from_: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
             /** To */
             to: string;
         };
@@ -1168,6 +1671,8 @@ interface components {
         PhoneNumberAssign: {
             /** Agent Id */
             agent_id?: string | null;
+            /** Agent Version */
+            agent_version?: number | "latest_published" | null;
         };
         /** PhoneNumberCreate */
         PhoneNumberCreate: {
@@ -1183,12 +1688,28 @@ interface components {
             flow_sms_sender_enabled?: boolean;
             /** Inbound Agent Id */
             inbound_agent_id?: string | null;
+            /**
+             * Inbound Agent Version
+             * @default 0
+             */
+            inbound_agent_version?: number | "latest_published";
+            /** Inbound Agents */
+            inbound_agents?: components["schemas"]["AgentWeightIn"][] | null;
+            /** Inbound Webhook Url */
+            inbound_webhook_url?: string | null;
             /** Nickname */
             nickname?: string | null;
             /** Number */
             number?: string | null;
             /** Outbound Agent Id */
             outbound_agent_id?: string | null;
+            /**
+             * Outbound Agent Version
+             * @default 0
+             */
+            outbound_agent_version?: number | "latest_published";
+            /** Outbound Agents */
+            outbound_agents?: components["schemas"]["AgentWeightIn"][] | null;
             /** Phone Number */
             phone_number?: string | null;
             /**
@@ -1213,12 +1734,18 @@ interface components {
             flow_sms_sender_enabled?: boolean | null;
             /** Inbound Agent Id */
             inbound_agent_id?: string | null;
+            /** Inbound Agent Version */
+            inbound_agent_version?: number | "latest_published" | null;
             /** Inbound Agents */
             inbound_agents?: components["schemas"]["AgentWeightIn"][] | null;
+            /** Inbound Webhook Url */
+            inbound_webhook_url?: string | null;
             /** Nickname */
             nickname?: string | null;
             /** Outbound Agent Id */
             outbound_agent_id?: string | null;
+            /** Outbound Agent Version */
+            outbound_agent_version?: number | "latest_published" | null;
             /** Outbound Agents */
             outbound_agents?: components["schemas"]["AgentWeightIn"][] | null;
             /** Phone Number Type */
@@ -1244,8 +1771,15 @@ interface components {
              * @default
              */
             description?: string;
+            /** Examples */
+            examples?: string[];
             /** Name */
             name: string;
+            /**
+             * Required
+             * @default false
+             */
+            required?: boolean;
             /**
              * Type
              * @enum {string}
@@ -1374,10 +1908,34 @@ interface components {
             /** Variable Names */
             variable_names: string[];
         };
+        /** PronunciationEntry */
+        PronunciationEntry: {
+            /**
+             * Alias
+             * @default
+             */
+            alias?: string;
+            /** Alphabet */
+            alphabet?: ("ipa" | "cmu") | null;
+            /**
+             * Case Sensitive
+             * @default false
+             */
+            case_sensitive?: boolean;
+            /** Phoneme */
+            phoneme?: string | null;
+            /** Word */
+            word: string;
+        };
         /** RegisterCallRequest */
         RegisterCallRequest: {
             /** Agent Id */
             agent_id: string;
+            /**
+             * Agent Version
+             * @default 0
+             */
+            agent_version?: number | "latest_published";
             /** Call Sid */
             call_sid?: string | null;
             /** Dialgem Llm Dynamic Variables */
@@ -1407,6 +1965,40 @@ interface components {
             /** Stream Url */
             stream_url: string;
         };
+        /** RunCreate */
+        RunCreate: {
+            /**
+             * Agent Version
+             * @default 0
+             */
+            agent_version?: unknown;
+            /**
+             * Fresh
+             * @default false
+             */
+            fresh?: boolean;
+            /** Max Model Turns */
+            max_model_turns?: number | null;
+        };
+        /** SessionSay */
+        SessionSay: {
+            /**
+             * Interrupt
+             * @default false
+             */
+            interrupt?: boolean;
+            /** Text */
+            text: string;
+        };
+        /** SessionUpdate */
+        SessionUpdate: {
+            /** Dynamic Variables */
+            dynamic_variables?: {
+                [key: string]: unknown;
+            } | null;
+            /** System Prompt */
+            system_prompt?: string | null;
+        };
         /** SipOutboundTrunkConfigIn */
         SipOutboundTrunkConfigIn: {
             /** Auth Password */
@@ -1506,6 +2098,29 @@ interface components {
         } & {
             [key: string]: unknown;
         };
+        /** SuiteCreate */
+        SuiteCreate: {
+            /** Agent Id */
+            agent_id: string;
+            /** Description */
+            description?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Publish Gate
+             * @default off
+             */
+            publish_gate?: string;
+        };
+        /** SuiteUpdate */
+        SuiteUpdate: {
+            /** Description */
+            description?: string | null;
+            /** Name */
+            name?: string | null;
+            /** Publish Gate */
+            publish_gate?: string | null;
+        };
         /** TransferAgent */
         TransferAgent: {
             /** Agent Id */
@@ -1583,6 +2198,18 @@ interface components {
         } & {
             [key: string]: unknown;
         };
+        /** UserDtmfOptions */
+        UserDtmfOptions: {
+            /** Digit Limit */
+            digit_limit?: number | null;
+            /** Termination Key */
+            termination_key?: ("0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "#" | "*") | null;
+            /**
+             * Timeout Ms
+             * @default 2500
+             */
+            timeout_ms?: number;
+        };
         /** ValidationError */
         ValidationError: {
             /** Context */
@@ -1596,6 +2223,29 @@ interface components {
             /** Error Type */
             type: string;
         };
+        /** WebCallRequest */
+        WebCallRequest: {
+            /** Agent Id */
+            agent_id: string;
+            /**
+             * Agent Version
+             * @default 0
+             */
+            agent_version?: number | "latest_published";
+            /** Dialgem Llm Dynamic Variables */
+            dialgem_llm_dynamic_variables?: {
+                [key: string]: unknown;
+            } | null;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        /** WebCallSettings */
+        WebCallSettings: {
+            /** Allowed Origins */
+            allowed_origins: string[];
+        };
     };
     responses: never;
     parameters: never;
@@ -1610,7 +2260,7 @@ interface components {
  * (snake_case); the SDK sends bodies as-is.
  */
 
-type Schemas = components["schemas"];
+type Schemas$5 = components["schemas"];
 /**
  * Adds `| undefined` to the optional top-level fields of a request body, so
  * callers compiling with `exactOptionalPropertyTypes` can write
@@ -1620,34 +2270,36 @@ type Schemas = components["schemas"];
 type RequestBody<T> = {
     [K in keyof T]: {} extends Pick<T, K> ? T[K] | undefined : T[K];
 };
-type AgentCreateParams = RequestBody<Schemas["AgentCreate"]>;
-type AgentUpdateParams = RequestBody<Schemas["AgentUpdate"]>;
-type FunctionCreateParams = RequestBody<Schemas["FunctionCreate"]>;
-type FunctionUpdateParams = RequestBody<Schemas["FunctionUpdate"]>;
-type FunctionReorderParams = RequestBody<Schemas["FunctionReorder"]>;
-type KnowledgeDocumentCreateParams = RequestBody<Schemas["DocumentCreate"]>;
-type MCPServerCreateParams = RequestBody<Schemas["MCPServerCreate"]>;
-type MCPServerUpdateParams = RequestBody<Schemas["MCPServerUpdate"]>;
-type PhoneNumberCreateParams = RequestBody<Schemas["PhoneNumberCreate"]>;
-type PhoneNumberUpdateParams = RequestBody<Schemas["PhoneNumberUpdate"]>;
-type PhoneNumberAssignParams = RequestBody<Schemas["PhoneNumberAssign"]>;
+type AgentCreateParams = RequestBody<Schemas$5["AgentCreate"]>;
+type AgentUpdateParams = RequestBody<Schemas$5["AgentUpdate"]>;
+type FunctionCreateParams = RequestBody<Schemas$5["FunctionCreate"]>;
+type FunctionUpdateParams = RequestBody<Schemas$5["FunctionUpdate"]>;
+type FunctionReorderParams = RequestBody<Schemas$5["FunctionReorder"]>;
+type KnowledgeDocumentCreateParams = RequestBody<Schemas$5["DocumentCreate"]>;
+type MCPServerCreateParams = RequestBody<Schemas$5["MCPServerCreate"]>;
+type MCPServerUpdateParams = RequestBody<Schemas$5["MCPServerUpdate"]>;
+type PhoneNumberCreateParams = RequestBody<Schemas$5["PhoneNumberCreate"]>;
+type PhoneNumberUpdateParams = RequestBody<Schemas$5["PhoneNumberUpdate"]>;
+type PhoneNumberAssignParams = RequestBody<Schemas$5["PhoneNumberAssign"]>;
 /**
  * `from_`, with the trailing underscore, is the wire name (`from` is a Python
  * keyword on the server). It must be a number registered on your organization.
  */
-type CallCreatePhoneCallParams = RequestBody<Schemas["OutboundCallRequest"]>;
-type CallRegisterParams = RequestBody<Schemas["RegisterCallRequest"]>;
+type CallCreatePhoneCallParams = RequestBody<Schemas$5["OutboundCallRequest"]>;
+type CallRegisterParams = RequestBody<Schemas$5["RegisterCallRequest"]>;
 /** A conversation-flow definition (`agent_type: "flow"`). */
-type FlowConfig = Schemas["FlowConfig"];
+type FlowConfig = Schemas$5["FlowConfig"];
 /** One state of a `multi_prompt` agent. */
-type PromptState = Schemas["PromptState"];
+type PromptState = Schemas$5["PromptState"];
 /** A field extracted from the transcript after the call ends. */
-type PostCallAnalysisVariable = Schemas["PostCallAnalysisVariable"];
-type KeyValuePair = Schemas["KVPair"];
-type AgentWeight = Schemas["AgentWeightIn"];
-type AgentType = NonNullable<Schemas["AgentCreate"]["agent_type"]>;
-type WebhookEventType = NonNullable<Schemas["AgentCreate"]["webhook_events"]>[number];
-type FunctionKind = NonNullable<Schemas["FunctionCreate"]["kind"]>;
+type PostCallAnalysisVariable = Schemas$5["PostCallAnalysisVariable"];
+/** Settings for `call_summary`, `call_successful` and `user_sentiment`. */
+type PostCallBuiltinFields = Schemas$5["BuiltinAnalysisFields"];
+type KeyValuePair = Schemas$5["KVPair"];
+type AgentWeight = Schemas$5["AgentWeightIn"];
+type AgentType = NonNullable<Schemas$5["AgentCreate"]["agent_type"]>;
+type WebhookEventType = NonNullable<Schemas$5["AgentCreate"]["webhook_events"]>[number];
+type FunctionKind = NonNullable<Schemas$5["FunctionCreate"]["kind"]>;
 
 /**
  * An agent, as returned by `GET /v1/agents/{id}` and the create/update calls.
@@ -1675,6 +2327,11 @@ interface Agent {
     /** Fallback values for `{{variables}}` not supplied by the call. */
     default_dynamic_variables: Record<string, string>;
     responsiveness: number;
+    /**
+     * Wait a little longer (up to 1.5 s) when the caller sounds unfinished: a
+     * trailing "and", a comma, a half-read number. Off by default.
+     */
+    adaptive_response_wait: boolean;
     interruption_sensitivity: number;
     enable_backchannel: boolean;
     backchannel_frequency: number;
@@ -1688,7 +2345,22 @@ interface Agent {
     language: string;
     enable_transcription_formatting: boolean;
     boosted_keywords: string[];
+    /**
+     * `noise-and-background-speech-cancellation` is a stronger setting of the same
+     * stationary-noise filter, scaled by `denoising_strength`; it does not isolate
+     * the caller from other voices.
+     */
     denoising_mode: NonNullable<AgentCreateParams["denoising_mode"]>;
+    /** 0-1. Only read by `noise-and-background-speech-cancellation`. */
+    denoising_strength: number;
+    /**
+     * `fast` uses Deepgram; `accurate` uses AssemblyAI when the server has it
+     * configured (English only) and falls back to Deepgram otherwise. Only
+     * applies when `stt_model` is `deepgram`.
+     */
+    stt_mode: NonNullable<AgentCreateParams["stt_mode"]>;
+    /** `medical` uses Deepgram's medical model (English only), in either `stt_mode`. */
+    vocab_specialization: NonNullable<AgentCreateParams["vocab_specialization"]>;
     begin_message_delay_ms: number;
     end_call_after_silence_ms: number;
     max_call_duration_ms: number;
@@ -1696,8 +2368,27 @@ interface Agent {
     voicemail_detection_enabled: boolean;
     voicemail_action: NonNullable<AgentCreateParams["voicemail_action"]>;
     voicemail_message: string;
+    /** When set, the voicemail is written by the LLM from this instruction (outbound calls). */
+    voicemail_prompt: string;
+    /** Hang up when an automated phone menu is detected (outbound calls). */
+    ivr_hangup_enabled: boolean;
+    /** How the agent should handle a menu when `ivr_hangup_enabled` is off. */
+    ivr_prompt: string;
+    /** Say `call_screen_message` once to a phone's call-screening assistant (outbound calls). */
+    call_screen_handling_enabled: boolean;
+    call_screen_message: string;
+    /**
+     * Offer the agent a do-not-call tool: a contact who asks to stop being called is
+     * added to the organization's do-not-call list and the call ends.
+     */
+    dnc_detection_enabled: boolean;
     post_call_analysis_data: PostCallAnalysisVariable[];
     post_call_analysis_model: string;
+    /**
+     * Settings for the always-on analysis fields. A missing key means defaults;
+     * `{ enabled: false }` stops that field being extracted (it is stored null).
+     */
+    post_call_builtin_fields: PostCallBuiltinFields;
     fallback_llm_provider: string | null;
     fallback_llm_model: string | null;
     fallback_voice_id: string | null;
@@ -1713,6 +2404,8 @@ interface Agent {
      */
     webhook_signing_secret: string | null;
     has_webhook_signing_secret: boolean;
+    /** How long, in ms, a receiver gets to answer one delivery attempt. 1000–30000, default 10000. */
+    webhook_timeout_ms: number;
     /** ISO 8601, no timezone suffix (UTC). */
     created_at: string | null;
     call_count: number;
@@ -1746,6 +2439,11 @@ interface AgentFunction {
     query_params: KeyValuePair[];
     speak_during_execution: string | null;
     speak_after_execution: boolean;
+    /**
+     * `false` (the default for new functions): the request body is
+     * `{ name, call, args }`. `true`: the body is the arguments object alone.
+     */
+    args_at_root: boolean;
     sort_order: number;
     kind: FunctionKind;
     /** Kind-specific settings (e.g. Cal.com credentials for the `*_cal` kinds). */
@@ -1782,6 +2480,18 @@ interface MCPServer {
     last_status: MCPServerTestResult | null;
     created_at: string | null;
 }
+/** One tool an MCP server offers. */
+interface MCPTool {
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments. */
+    input_schema: Record<string, unknown>;
+}
+/** What `mcpServers.listTools` returns. When the server is unreachable `tools` is empty and `error` says why. */
+interface MCPToolList {
+    tools: MCPTool[];
+    error: string | null;
+}
 interface MCPServerTestResult {
     ok: boolean;
     /** Tool names the server advertised. */
@@ -1791,6 +2501,77 @@ interface MCPServerTestResult {
     at: string;
 }
 
+/**
+ * A published agent version: a frozen copy of the agent's configuration, its
+ * functions and its MCP servers.
+ *
+ * The editable agent is the **draft**, version `0`, and is what a call runs
+ * unless something pins a version. Publishing never changes the draft, and a
+ * published version never changes at all — editing a function's URL afterwards
+ * does not move the copy inside a version that already shipped.
+ *
+ * Pin one on a phone number (`inbound_agent_version` / `outbound_agent_version`),
+ * on an outbound call, or on a registered call. The version a call ran is
+ * reported as `agent_version` on its call record and in every webhook.
+ */
+interface AgentVersionSummary {
+    id: string;
+    agent_id: string;
+    /** 1 for the first publish, then upwards. The draft is 0 and is not listed here. */
+    version: number;
+    /** The agent's name at publish time. */
+    name: string;
+    /** Your label for the release, if you gave one. */
+    title: string | null;
+    description: string | null;
+    /** ISO 8601, no timezone suffix (UTC). */
+    published_at: string | null;
+    /** Whoever published it, as the API identity that made the call. */
+    published_by: string | null;
+    function_count: number;
+    mcp_server_count: number;
+}
+/** A version with its snapshot, returned by `publish` and `retrieve`. */
+interface AgentVersion extends AgentVersionSummary {
+    /**
+     * The frozen configuration. Same fields as {@link Agent}, minus the ones that
+     * belong to the agent rather than to a snapshot (`id`, `created_at`,
+     * `call_count`). `webhook_signing_secret` is never included; read it from the
+     * agent itself.
+     */
+    config: AgentVersionConfig;
+    functions: AgentFunction[];
+    /** `auth_token` is stripped; `has_auth_token` says whether one is set. */
+    mcp_servers: AgentVersionMCPServer[];
+}
+type AgentVersionConfig = Partial<Omit<Agent, "id" | "agent_id" | "created_at" | "call_count">> & {
+    has_webhook_signing_secret: boolean;
+} & Record<string, unknown>;
+type AgentVersionMCPServer = Omit<MCPServer, "id"> & {
+    id: string;
+    has_auth_token: boolean;
+};
+interface AgentVersionListResponse {
+    /** Newest first. */
+    versions: AgentVersionSummary[];
+    /** Whether older versions remain below the last one returned. */
+    has_more: boolean;
+}
+interface AgentVersionListParams {
+    /** Versions per page, 1-100. Default 50. */
+    limit?: number | undefined;
+    /**
+     * Return versions below this one. Page by passing the `version` of the last
+     * entry you received.
+     */
+    before_version?: number | undefined;
+}
+interface AgentVersionPublishParams {
+    /** A label for the release, e.g. "adds the refund flow". */
+    title?: string | undefined;
+    description?: string | undefined;
+}
+
 declare abstract class APIResource {
     protected readonly _client: HttpClient;
     constructor(client: HttpClient);
@@ -1803,6 +2584,8 @@ declare class Agents extends APIResource {
     readonly knowledge: AgentKnowledge;
     /** Remote MCP servers whose tools are exposed to the agent. */
     readonly mcpServers: AgentMCPServers;
+    /** Frozen snapshots of the agent that a number or a call can pin. */
+    readonly versions: AgentVersions;
     constructor(client: HttpClient);
     /** Create an agent. Only `name` is required; everything else has a server default. */
     create(body: AgentCreateParams, options?: RequestOptions): Promise<Agent>;
@@ -1813,6 +2596,29 @@ declare class Agents extends APIResource {
     update(agentId: string, body: AgentUpdateParams, options?: RequestOptions): Promise<Agent>;
     delete(agentId: string, options?: RequestOptions): Promise<AgentDeleteResponse>;
 }
+/**
+ * Published versions of an agent.
+ *
+ * The agent itself is the draft, version 0, and every call runs it unless a
+ * number or a request pins a published version. Publishing takes a copy;
+ * editing the agent afterwards changes only the draft.
+ */
+declare class AgentVersions extends APIResource {
+    /** Freeze the agent as it is now. Returns the new version, snapshot included. */
+    publish(agentId: string, body?: AgentVersionPublishParams, options?: RequestOptions): Promise<AgentVersion>;
+    /**
+       * One page of published versions, newest first, without their snapshots.
+       *
+       * Returns the array. When you need to page — an agent published on every
+       * deploy accumulates versions, and nothing prunes them — read `has_more` from
+       * {@link listPage} instead and pass the last `version` as `before_version`.
+       */
+    list(agentId: string, params?: AgentVersionListParams, options?: RequestOptions): Promise<AgentVersionSummary[]>;
+    /** {@link list} with the `has_more` flag, for paging. */
+    listPage(agentId: string, params?: AgentVersionListParams, options?: RequestOptions): Promise<AgentVersionListResponse>;
+    /** One version with its full snapshot. Version 0 is the draft: use `agents.retrieve`. */
+    retrieve(agentId: string, version: number, options?: RequestOptions): Promise<AgentVersion>;
+}
 declare class AgentFunctions extends APIResource {
     list(agentId: string, options?: RequestOptions): Promise<AgentFunction[]>;
     create(agentId: string, body: FunctionCreateParams, options?: RequestOptions): Promise<AgentFunction>;
@@ -1833,31 +2639,33 @@ declare class AgentMCPServers extends APIResource {
     update(agentId: string, serverId: string, body: MCPServerUpdateParams, options?: RequestOptions): Promise<MCPServer>;
     delete(agentId: string, serverId: string, options?: RequestOptions): Promise<void>;
     /** Connect to the server now, list its tools, and store the result as `last_status`. */
+    /**
+     * What the server offers right now, with each tool's description and argument schema. Connects live like
+     * `test`, but stores nothing. An unreachable server is not an error: `tools` is empty and `error` says why.
+     */
+    listTools(agentId: string, serverId: string, options?: RequestOptions): Promise<MCPToolList>;
     test(agentId: string, serverId: string, options?: RequestOptions): Promise<MCPServerTestResult>;
 }
 
-interface PageFetcher<T> {
-    (page: number): Promise<PageData<T>>;
-}
 interface PageData<T> {
     data: T[];
-    total: number;
-    page: number;
-    page_size: number;
+    has_more: boolean;
+    /** Pass to the next request to continue; `null` on the last page. */
+    pagination_key: string | null;
 }
+type PageFetcher<T> = (paginationKey: string | null) => Promise<PageData<T>>;
 declare class Page<T> implements PageData<T> {
     #private;
     readonly data: T[];
-    readonly total: number;
-    readonly page: number;
-    readonly page_size: number;
+    readonly has_more: boolean;
+    readonly pagination_key: string | null;
     constructor(data: PageData<T>, fetchPage: PageFetcher<T>);
     hasNextPage(): boolean;
     getNextPage(): Promise<Page<T>>;
 }
 declare class PagePromise<T> implements PromiseLike<Page<T>>, AsyncIterable<T> {
     #private;
-    constructor(fetchPage: PageFetcher<T>, startPage: number);
+    constructor(fetchPage: PageFetcher<T>, startKey?: string | null);
     then<R1 = Page<T>, R2 = never>(onfulfilled?: ((value: Page<T>) => R1 | PromiseLike<R1>) | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
     catch<R = never>(onrejected?: ((reason: unknown) => R | PromiseLike<R>) | null): Promise<Page<T> | R>;
     finally(onfinally?: (() => void) | null): Promise<Page<T>>;
@@ -1865,46 +2673,71 @@ declare class PagePromise<T> implements PromiseLike<Page<T>>, AsyncIterable<T> {
 }
 
 /**
- * A call, as returned by `GET /v1/calls` and `GET /v1/calls/{id}`.
- * The shape is the same for both endpoints.
+ * A call, as returned by `GET /v1/calls`, `GET /v1/calls/{id}` and every call webhook.
+ * The shape is the same everywhere.
  */
 interface Call {
     id: string;
     /** Empty string when the call has no agent. */
     agent_id: string;
+    /**
+     * The published agent version this call ran. 0 is the live draft, which is
+     * what a call runs unless a number or the request that created it pinned a
+     * version.
+     */
+    agent_version: number;
     agent_name: string;
     /** Dialgem's lifecycle state. */
     status: CallStatus;
     /** The same state in session vocabulary: active→ongoing, completed→ended, failed→error, queued→registered. */
     call_status: CallSessionStatus;
-    duration_s: number;
-    /**
-     * Empty when the agent opts out of transcript storage, and once the agent's
-     * `data_retention_days` purge has run. PII-redacted when redaction is on.
-     */
-    transcript: TranscriptTurn[];
+    call_type: "phone_call" | "web_call" | (string & {});
+    direction: "inbound" | "outbound" | (string & {});
+    /** Your own data, attached when the call was created or later with `calls.update`. */
+    metadata: Record<string, unknown>;
+    /** The dynamic variables the call was started with. */
+    dynamic_variables: Record<string, string>;
     /** ISO 8601, no timezone suffix (UTC). Empty string if unknown. */
     started_at: string;
+    /** ISO 8601, no timezone suffix (UTC). `null` while the call is ongoing. */
+    ended_at: string | null;
+    /** Epoch milliseconds. */
+    start_timestamp: number | null;
+    /** Epoch milliseconds. `null` while the call is ongoing. */
+    end_timestamp: number | null;
+    duration_s: number;
+    duration_ms: number | null;
     phone_number: string;
-    direction: "inbound" | "outbound" | (string & {});
-    call_type: "phone_call" | "web_call" | (string & {});
-    /** Carrier call id (Twilio CallSid). Empty string if none. */
-    call_sid: string;
     from_number: string;
     to_number: string;
+    /** Carrier call id (Twilio CallSid). Empty string if none. */
+    call_sid: string;
     origination_state: string | null;
+    /**
+     * One entry per turn. Empty when the agent opts out of transcript storage, and
+     * once the agent's `data_retention_days` purge has run. PII-redacted when
+     * redaction is on.
+     */
+    transcript: TranscriptTurn[];
+    /** The same transcript as one string, `Agent: …` / `User: …` per line. */
+    transcript_text: string;
     /** Presigned URL that expires; download it promptly rather than storing the link. */
     recording_url: string | null;
-    amd_result: Record<string, unknown> | null;
     events: Record<string, unknown>[];
-    /** Post-call extraction. `null` until the call has ended and been analyzed, and after a retention purge. */
+    disconnection_reason: DisconnectionReason | null;
+    /** Whether the call reached voicemail or an answering machine. */
+    in_voicemail: boolean;
+    amd_result: Record<string, unknown> | null;
+    /** Post-call analysis. `null` until the call has ended and been analyzed, and after a retention purge. */
     analysis: CallAnalysis | null;
-    disconnection_reason: string | null;
     /** Set once the call is finalized. */
     call_cost: CallCost | null;
     /** Mean time from the caller's final transcript to the agent's first audio byte. */
     end_to_end_latency_ms: number | null;
+    /** Per-stage latency percentiles, recorded when the call ends. `null` if no turn completed. */
+    latency: CallLatency | null;
 }
+type DisconnectionReason = "user_hangup" | "agent_hangup" | "call_transfer" | "voicemail_reached" | "inactivity" | "max_duration_reached" | "manual_stopped" | "dial_no_answer" | "flow_dead_end" | "flow_loop_guard" | "error" | (string & {});
 /** Every amount is an integer in units of **$0.0001**: `combined_cost: 1700` is $0.17. */
 interface CallCost {
     combined_cost: number;
@@ -1925,23 +2758,76 @@ interface TranscriptTurn {
     timestamp: string;
 }
 interface CallAnalysis {
+    /** A one-to-three sentence summary of the call. */
+    call_summary: string | null;
+    user_sentiment: "Positive" | "Neutral" | "Negative" | (string & {}) | null;
+    call_successful: boolean | null;
+    in_voicemail: boolean;
     /** Values for the agent's `post_call_analysis_data` fields, keyed by name. */
     variables: Record<string, unknown>;
     model: string;
     extracted_at: string;
-    user_sentiment: "Positive" | "Neutral" | "Negative" | (string & {}) | null;
-    call_successful: boolean | null;
     /** Set when extraction failed; `variables` may then be partial or empty. */
     error: string | null;
 }
+/** Milliseconds. Each stage has at least one sample, or is omitted. */
+interface LatencyStats {
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    min: number;
+    max: number;
+    num: number;
+}
+interface CallLatency {
+    /** Caller's final transcript to the agent's first audio byte. */
+    e2e?: LatencyStats;
+    /** Time to the model's first sentence. */
+    llm?: LatencyStats;
+    /** Time to the first synthesized audio. */
+    tts?: LatencyStats;
+    /** How long end-of-speech detection waited. */
+    endpointing?: LatencyStats;
+}
 interface CallListParams {
+    agent_id?: string | string[] | undefined;
+    status?: CallStatus | CallStatus[] | undefined;
+    direction?: "inbound" | "outbound" | undefined;
+    call_type?: "phone_call" | "web_call" | undefined;
+    disconnection_reason?: DisconnectionReason | DisconnectionReason[] | undefined;
+    from_number?: string | undefined;
+    to_number?: string | undefined;
+    user_sentiment?: "Positive" | "Neutral" | "Negative" | undefined;
+    call_successful?: boolean | undefined;
+    /** Started at or after this time, epoch ms. */
+    start_after?: number | undefined;
+    /** Started before this time, epoch ms. */
+    start_before?: number | undefined;
+    /**
+     * Match calls whose metadata has these values, e.g. `{ crm_id: "42" }`.
+     * Values are compared as strings.
+     */
+    metadata?: Record<string, string | number | boolean> | undefined;
     /** Case-insensitive match on the agent's name. */
     search?: string | undefined;
-    status?: CallStatus | "all" | undefined;
-    /** 1-based. Default 1. */
-    page?: number | undefined;
-    /** 1–100. Default 10. */
-    page_size?: number | undefined;
+    /** Default `desc` (newest first). */
+    sort_order?: "asc" | "desc" | undefined;
+    /** Calls per page, 1–100. Default 10. */
+    limit?: number | undefined;
+}
+interface CallUpdateParams {
+    /** Replaces the call's metadata. A JSON object of at most 16 KB. */
+    metadata: Record<string, unknown>;
+}
+interface CallDeleteResponse {
+    deleted: true;
+    id: string;
+}
+interface CallStopResponse {
+    id: string;
+    /** The call is tearing down; it becomes `completed` with `disconnection_reason: "manual_stopped"` shortly. */
+    stopping: true;
 }
 /** Result of `calls.createPhoneCall`. The call is dialing; its outcome arrives via webhooks or `calls.retrieve`. */
 interface PhoneCallCreateResponse {
@@ -1960,16 +2846,43 @@ interface CallRegisterResponse {
 
 declare class Calls extends APIResource {
     /**
-     * Calls, newest first. Await for one page, or iterate for every call:
+     * Calls, newest first by default. Await for one page, or iterate for every call:
      *
-     *   const page = await dialgem.calls.list({ page_size: 50 })
-     *   for await (const call of dialgem.calls.list({ status: "completed" })) {
-     *     if (call.started_at < cutoff) break // newest first: everything after is older
-     *   }
+     *   const page = await dialgem.calls.list({ limit: 50 })
+     *   for await (const call of dialgem.calls.list({ status: "completed", start_after: since })) { ... }
      */
     list(params?: CallListParams, options?: RequestOptions): PagePromise<Call>;
-    /** One call, including its transcript, analysis and recording URL. */
+    /** One call, including its transcript, analysis, latency and recording URL. */
     retrieve(callId: string, options?: RequestOptions): Promise<Call>;
+    /** Replace the call's `metadata`. */
+    update(callId: string, body: CallUpdateParams, options?: RequestOptions): Promise<Call>;
+    /**
+     * Permanently delete a finished call: its record, transcript, analysis and
+     * recording. A call still in progress is refused with `ConflictError`; stop it first.
+     */
+    delete(callId: string, options?: RequestOptions): Promise<CallDeleteResponse>;
+    /**
+     * Run a finished call's post-call analysis again, with the agent's *current* analysis
+     * settings, and return the updated call. Use it after changing the fields or the model
+     * and wanting an older call read the new way.
+     *
+     * It replaces `analysis`; it does not bill the call again and does not send `call_analyzed`
+     * again, so read the result from this response or from `retrieve`. The model call can take
+     * a while. `ConflictError` with `errCode` `call_in_progress` until the call has ended,
+     * `no_transcript` when there is nothing to analyze, `agent_deleted` if the agent is gone.
+     * Not retried by default.
+     */
+    rerunAnalysis(callId: string, options?: RequestOptions): Promise<Call>;
+    /**
+     * End an ongoing call now, as if the agent had hung up. The call becomes
+     * `completed` with `disconnection_reason: "manual_stopped"` a moment later, and
+     * the usual `call_ended` webhook follows.
+     *
+     * `ConflictError` with `errCode` `call_not_ongoing` if it already ended, or
+     * `call_not_connected` if no agent is on the call yet (e.g. still ringing).
+     * Not retried by default.
+     */
+    stop(callId: string, options?: RequestOptions): Promise<CallStopResponse>;
     /**
      * Dial `to` from one of your organization's numbers, with `agent_id` (or the
      * number's outbound agent) on the line.
@@ -2001,9 +2914,68 @@ interface Voice {
     language: string[];
     preview_url: string | null;
     raw_metadata: Record<string, unknown> | null;
+    /** True for a voice your organization cloned; false for the shared catalog. */
+    is_custom: boolean;
+    /** Who uploaded the audio, for a cloned voice. */
+    created_by: string | null;
     created_at: string | null;
     updated_at: string | null;
 }
+/** A model usable for an agent's post-call analysis (`post_call_analysis_model`). */
+interface ExtractionModel {
+    /** Put this in `post_call_analysis_model`. */
+    id: string;
+    provider: "anthropic" | "openai";
+    label: string;
+    /**
+     * Estimated USD for one typical extraction, derived from list prices. For
+     * comparing models; not a metered charge.
+     */
+    est_cost_per_session: number;
+}
+interface ExtractionModelList {
+    /** The model an agent gets when none is set. */
+    default: string;
+    models: ExtractionModel[];
+}
+/** One audio sample for cloning. `Blob` and `File` both satisfy this. */
+type VoiceCloneFile = Blob | {
+    name?: string;
+    type?: string;
+};
+interface VoiceCloneParams {
+    /** Display name for the new voice. */
+    name: string;
+    /**
+     * The audio to clone from.
+     *
+     * ElevenLabs takes up to 25 files; **Cartesia takes exactly one** and refuses
+     * more rather than silently picking one, since that would make the same
+     * upload produce a noticeably different voice on the two providers.
+     */
+    files: Blob[];
+    /**
+     * You are asserting that you hold the rights to this audio and have the
+     * speaker's consent to clone their voice. Required, and recorded against
+     * your API identity — a cloned voice is built from a real person's speech.
+     */
+    consent_confirmed: true;
+    /** Which provider clones it. Defaults to `elevenlabs`. */
+    engine?: "elevenlabs" | "cartesia" | undefined;
+    description?: string | undefined;
+    /** Cartesia clones per language; ElevenLabs ignores this. Defaults to `en`. */
+    language?: string | undefined;
+    /**
+     * Filenames sent with each blob, in order. The provider infers the audio
+     * container from the extension, so a `Blob` with no name needs one here.
+     * Defaults to `clip-1.wav`, `clip-2.wav`, …
+     */
+    filenames?: string[] | undefined;
+}
+interface VoiceDeleteResponse {
+    deleted: boolean;
+    voice_id: string;
+}
 interface VoiceListParams {
     provider?: string | undefined;
     gender?: string | undefined;
@@ -2053,8 +3025,37 @@ interface FlowTemplate extends FlowTemplateSummary {
 }
 
 declare class Voices extends APIResource {
-    /** Voices available to agents, by name. Put a voice's `provider_voice_id` in an agent's `voice_id`. */
+    /**
+     * Voices available to agents: the shared catalog plus the ones your
+     * organization cloned, yours first. Put a voice's `provider_voice_id` in an
+     * agent's `voice_id`.
+     */
     list(params?: VoiceListParams, options?: RequestOptions): Promise<Voice[]>;
+    /**
+     * Clone a voice from audio you upload. The new voice is private to your
+     * organization and never appears in another one's catalog.
+     *
+     * Consent is required: you are asserting that you hold the rights to the
+     * audio and have the speaker's consent, and that assertion is recorded
+     * against your API identity.
+     *
+     * The upload is never retried, whatever `maxRetries` says — a retried
+     * multipart body can send truncated audio, and a clone built from half the
+     * recording succeeds and sounds wrong.
+     */
+    clone(params: VoiceCloneParams, options?: RequestOptions): Promise<Voice>;
+    /**
+     * Delete a voice your organization cloned, at the provider and here.
+     *
+     * Only your own cloned voices: the shared catalog is not deletable, and a
+     * voice an agent still uses is refused with a 409 rather than leaving that
+     * agent without one.
+     */
+    delete(voiceId: string, options?: RequestOptions): Promise<VoiceDeleteResponse>;
+}
+declare class ExtractionModels extends APIResource {
+    /** Models an agent may use for post-call analysis, with an estimated cost per session. */
+    list(options?: RequestOptions): Promise<ExtractionModelList>;
 }
 declare class FlowTemplates extends APIResource {
     /** Built-in conversation-flow templates (summaries, without `flow_config`). */
@@ -2067,107 +3068,1180 @@ declare class PromptTemplates extends APIResource {
     retrieve(templateId: string, options?: RequestOptions): Promise<PromptTemplate>;
 }
 
-/**
- * A phone number, as returned by `/v1/phone-numbers`.
- * The shape is the same across all phone-number endpoints.
- */
-interface PhoneNumber {
-    /** Dialgem id. Use this (not the E.164 number) for update/assign/delete. */
+/** What an API key was granted. The secret is never returned. */
+interface ApiKeyDetails {
     id: string;
-    status: string;
-    provider: string;
-    /** E.164, e.g. `+14155550123`. */
-    phone_number: string;
-    phone_number_pretty: string;
-    phone_number_type: string;
-    nickname: string;
-    inbound_agent_id: string | null;
-    inbound_agent_version: number;
-    outbound_agent_id: string | null;
-    outbound_agent_version: number;
-    /** Weighted inbound routing. `inbound_agent_id` is its primary entry. */
-    inbound_agents: PhoneNumberAgentWeight[];
-    outbound_agents: PhoneNumberAgentWeight[];
-    custom_sms_enabled: boolean;
-    flow_sms_sender_enabled: boolean;
-    /** Epoch milliseconds (0 if unknown). */
-    creation_timestamp: number;
-    /** Epoch milliseconds (0 if unknown). */
-    last_modification_timestamp: number;
-    sip_outbound_trunk_config: SipOutboundTrunkConfig | null;
+    name: string;
+    /** The start of the key, to recognise it by. */
+    prefix: string;
+    /** True when the key has no scopes and can do everything. */
+    full_access: boolean;
+    /** For example `["calls:write", "agents:read"]`; `null` for a full-access key. */
+    scopes: string[] | null;
+    /** IP addresses or CIDR ranges the key may be used from; `null` for anywhere. */
+    allowed_ips: string[] | null;
+    expires_at: string | null;
+    expired: boolean;
+    last_used_at: string | null;
+    created_at: string | null;
+    revoked_at: string | null;
 }
-interface PhoneNumberAgentWeight {
-    agent_id: string;
-    agent_version: number;
-    weight: number;
+interface ApiKeyInfo {
+    auth: "api_key" | "session" | "service" | (string & {});
+    /** Your organization's slug. */
+    organization: string;
+    role: string;
+    /** The key being used; `null` when the request was not made with an organization API key. */
+    key: ApiKeyDetails | null;
 }
-interface SipOutboundTrunkConfig {
-    termination_uri?: string | null;
-    transport?: string | null;
-    auth_username?: string | null;
+
+/**
+ * A call in progress right now, as the service holds it in memory.
+ *
+ * This is live state, not a record: a finished call is a `Call`, reachable
+ * through `calls.retrieve`. The shape of a session is not a stable contract
+ * beyond the fields below, so it is deliberately open.
+ */
+interface AgentSession {
+    session_id: string;
+    agent_id: string;
+    status: "active" | "ended" | (string & {});
+    /** ISO 8601. */
+    started_at?: string;
     [key: string]: unknown;
 }
 
-declare class PhoneNumbers extends APIResource {
-    /** Register a number you own (`phone_number` in E.164) with Dialgem. */
-    create(body: PhoneNumberCreateParams, options?: RequestOptions): Promise<PhoneNumber>;
-    /** Every active (not released) number in the organization, newest first. */
-    list(options?: RequestOptions): Promise<PhoneNumber[]>;
+type AgentSessionUpdateParams = RequestBody<components["schemas"]["SessionUpdate"]>;
+type AgentSessionSayParams = RequestBody<components["schemas"]["SessionSay"]>;
+/** What `sessions.say` returns: the line plays behind the call's audio, so this answers at once. */
+interface AgentSessionSayResult {
+    status: "speaking";
+}
+/** What `sessions.release` returns. */
+interface AgentSessionReleaseResult {
+    /** `not_taken_over` when nobody had the call. */
+    status: "handed_back" | "not_taken_over";
+    reason?: string;
+}
+/** What `sessions.update` returns. */
+interface AgentSessionUpdateResult {
+    session_id: string;
+    status: "active" | (string & {});
+    /** Which of `system_prompt` and `dynamic_variables` were changed. */
+    updated: Array<"system_prompt" | "dynamic_variables">;
+    applies_from: "next_turn";
+}
+interface AgentSessionList {
+    sessions: AgentSession[];
+    /** How many are live. This is what "how busy am I right now?" asks for. */
+    count: number;
+}
+
+declare class ApiKey extends APIResource {
     /**
-     * Partial update.
+     * Who this key is: your organization and the key's name, prefix, scopes, allowed addresses
+     * and expiry. It answers for any valid key whatever its scopes, so an integration can check
+     * what it was given. Never returns the secret.
      *
-     * `inbound_agent_id` is **ignored unless `set_inbound_agent: true`** is sent with
-     * it, both to set an agent and to clear one (`null`). Same for the outbound pair.
-     * `inbound_agents` / `outbound_agents` (weighted routing), when sent, take
+     * ```ts
+     * const { key } = await dialgem.apiKey.retrieve()
+     * if (key && !key.full_access) console.log("scoped to", key.scopes)
+     * ```
+     */
+    retrieve(options?: RequestOptions): Promise<ApiKeyInfo>;
+}
+declare class Sessions extends APIResource {
+    /**
+     * The calls your organization has in progress right now, with a `count`.
+     *
+     * Live state read from the service's own registry — use it for a
+     * concurrency check before placing a call. For finished calls use
+     * `calls.list`; a call whose teardown never arrived is not counted here.
+     */
+    list(options?: RequestOptions): Promise<AgentSessionList>;
+    /**
+     * Change a live call's prompt and/or variables. It applies from the agent's **next turn**.
+     *
+     * `sessionId` is a session's `session_id` from `list`, or the call's own `call_id`. Only this call changes:
+     * the agent, its published versions and other calls are untouched, and the change is gone when the call ends.
+     * A turn already being spoken finishes as it was. `dynamic_variables` are merged over the call's variables;
+     * `system_prompt` replaces the prompt for the rest of the call.
+     *
+     * The call may be on any service instance. `NotFoundError` if it is not live (or is another organization's),
+     * `ConflictError` with `errCode` `session_ended` once it is over, `UnprocessableEntityError` with `errCode`
+     * `flow_agent_prompt` for a flow agent's prompt (its variables can still change). Not retried by default.
+     *
+     * ```ts
+     * await dialgem.sessions.update(callId, { dynamic_variables: { plan: "pro" } })
+     * ```
+     */
+    update(sessionId: string, body: AgentSessionUpdateParams, options?: RequestOptions): Promise<AgentSessionUpdateResult>;
+    /**
+     * Make the agent say `text` on a live call, in its own voice. Answers at once; the line plays behind what the
+     * agent is saying, or now with `interrupt: true`. The agent's conversation records it as something it said.
+     *
+     * Off unless the deployment enables live control: `ForbiddenError` with `errCode` `live_control_disabled`.
+     * `ConflictError` `human_has_call` while a human has taken the call. Owners, admins and API keys only.
+     * Not retried by default.
+     *
+     * ```ts
+     * await dialgem.sessions.say(callId, { text: "One moment while I check that." })
+     * ```
+     */
+    say(sessionId: string, body: AgentSessionSayParams, options?: RequestOptions): Promise<AgentSessionSayResult>;
+    /**
+     * Hand a taken-over call back to the agent, for when the socket that took it is gone. The agent is told a
+     * human had the call and that it did not hear what was said. Same availability and limits as `say`.
+     * Listening in and taking over run over a WebSocket (`/v1/agent/sessions/{id}/live`), which this SDK does not wrap.
+     */
+    release(sessionId: string, options?: RequestOptions): Promise<AgentSessionReleaseResult>;
+}
+
+/**
+ * Agent simulations: saved conversations that a simulated caller has with your agent, in text,
+ * checked afterwards. Nothing is dialled, recorded or billed, and the agent's tools are never really called.
+ *
+ * The API accepts free-form objects for the caller, tool answers and checks, so they are typed here.
+ */
+/** What publishing a version of the agent does when the draft has not passed the suite. */
+type SimulationPublishGate = "off" | "warn" | "block";
+type SimulationCaller = {
+    mode: "script";
+    /** What the caller says, one line per turn (up to 20). */
+    turns: string[];
+} | {
+    mode: "persona";
+    /** Who the caller is. A model plays them. */
+    persona: string;
+    /** What they want from the call. */
+    goal?: string | undefined;
+    /** Longest the conversation runs, in exchanges (1 to 12, default 6). */
+    max_turns?: number | undefined;
+};
+interface CheckBase {
+    /** Names the check in the results. */
+    label?: string | undefined;
+}
+type SimulationCheck = (CheckBase & {
+    type: "contains" | "not_contains";
+    text: string;
+    who?: "agent" | "caller" | "any" | undefined;
+}) | (CheckBase & {
+    type: "tool_called";
+    name: string;
+    args?: Record<string, unknown> | undefined;
+}) | (CheckBase & {
+    type: "tool_not_called";
+    name: string;
+}) | (CheckBase & {
+    type: "variable_equals";
+    name: string;
+    value: string;
+}) | (CheckBase & {
+    type: "node_reached";
+    node_id: string;
+}) | (CheckBase & {
+    type: "ended";
+    value?: boolean | undefined;
+}) | (CheckBase & {
+    type: "rubric";
+    criteria: string;
+});
+interface SimulationCaseInput {
+    name: string;
+    caller: SimulationCaller;
+    /** Fills `{{placeholders}}` in the agent's prompt and first message. */
+    dynamic_variables?: Record<string, string | number> | undefined;
+    /** What each tool answers. A tool without an entry answers `{"status": "ok"}`. */
+    tool_mocks?: Record<string, unknown> | undefined;
+    /** At least one. The case passes when all of them hold. */
+    checks: SimulationCheck[];
+}
+interface SimulationSuiteCreateParams {
+    agent_id: string;
+    name: string;
+    description?: string | null | undefined;
+    publish_gate?: SimulationPublishGate | undefined;
+}
+interface SimulationSuiteUpdateParams {
+    name?: string | undefined;
+    description?: string | null | undefined;
+    publish_gate?: SimulationPublishGate | undefined;
+}
+interface SimulationRunCreateParams {
+    /** `0` is the draft you are editing (the default), or a published version, or `"latest_published"`. */
+    agent_version?: number | "latest_published" | undefined;
+    /** Run every case again even if an identical one already ran against this exact agent. */
+    fresh?: boolean | undefined;
+    /** Spend at most this many model turns. When used up the remaining cases are skipped. */
+    max_model_turns?: number | undefined;
+}
+interface SimulationCase extends Required<Pick<SimulationCaseInput, "name" | "caller" | "checks">> {
+    id: string;
+    suite_id: string;
+    position: number;
+    dynamic_variables: Record<string, string>;
+    tool_mocks: Record<string, unknown>;
+    created_at: string | null;
+    updated_at: string | null;
+}
+type SimulationRunStatus = "queued" | "running" | "completed" | "cancelled" | "failed";
+interface SimulationRun {
+    id: string;
+    suite_id: string;
+    agent_id: string;
+    /** The version that was tested; `0` is the draft. */
+    agent_version: number;
+    status: SimulationRunStatus;
+    trigger: string;
+    fresh: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    /** The model or the case broke; this says nothing about your agent. */
+    errored: number;
+    /** Cancelled, or the run ran out of model turns. */
+    skipped: number;
+    model_turn_budget: number;
+    model_turns_used: number;
+    budget_exhausted: boolean;
+    created_at: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+}
+type SimulationResultStatus = "pending" | "passed" | "failed" | "errored" | "skipped";
+interface SimulationCheckResult {
+    /** Position in the case's `checks`. */
+    index: number;
+    type: SimulationCheck["type"];
+    label?: string | undefined;
+    passed: boolean;
+    detail: string;
+}
+interface SimulationResult {
+    id: string;
+    case_id: string | null;
+    case_name: string;
+    position: number;
+    status: SimulationResultStatus;
+    /** Why it failed, errored or was skipped. */
+    reason: string | null;
+    /** Taken from an earlier identical run rather than run again. */
+    cached: boolean;
+    transcript: {
+        role: "caller" | "agent";
+        text: string;
+        node_id?: string | undefined;
+    }[];
+    tool_calls: {
+        name: string;
+        input: Record<string, unknown>;
+        result: string;
+    }[];
+    /** A flow agent's variables at the end. */
+    variables: Record<string, unknown>;
+    checks: SimulationCheckResult[];
+    model_turns: number;
+    duration_ms: number;
+    finished_at: string | null;
+}
+interface SimulationRunDetail extends SimulationRun {
+    results: SimulationResult[];
+}
+interface SimulationSuite {
+    id: string;
+    agent_id: string;
+    name: string;
+    description: string | null;
+    publish_gate: SimulationPublishGate;
+    case_count: number;
+    latest_run: SimulationRun | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface SimulationSuiteDetail extends SimulationSuite {
+    cases: SimulationCase[];
+}
+interface SimulationSuiteList {
+    /** Whether simulations are switched on for the platform. */
+    enabled: boolean;
+    suites: SimulationSuite[];
+}
+interface SimulationRunList {
+    runs: SimulationRun[];
+}
+
+/**
+ * Test your agent before a change reaches a caller. A **suite** holds **cases**; in each, a simulated caller
+ * talks to the agent in text and your **checks** decide whether it passed.
+ *
+ * A simulation is not a call: nothing is dialled, recorded or billed, and the agent's tools are never really
+ * called. Simulations spend model usage, so they are switched on per platform; until then every method answers
+ * 403 `simulations_disabled`.
+ *
+ *   const suite = await dialgem.simulations.createSuite({ agent_id, name: "Refunds" })
+ *   await dialgem.simulations.createCase(suite.id, {
+ *     name: "Asks for a refund",
+ *     caller: { mode: "script", turns: ["I want my money back."] },
+ *     checks: [{ type: "not_contains", text: "full refund" }],
+ *   })
+ *   const run = await dialgem.simulations.run(suite.id)
+ *   // poll retrieveRun(run.id) until status is "completed"
+ */
+declare class Simulations extends APIResource {
+    /** Make a suite for one of your agents. */
+    createSuite(body: SimulationSuiteCreateParams, options?: RequestOptions): Promise<SimulationSuite>;
+    /** Your suites, newest first, each with its latest run. Pass `agent_id` for one agent's. */
+    listSuites(params?: {
+        agent_id?: string;
+    }, options?: RequestOptions): Promise<SimulationSuiteList>;
+    /** One suite with its cases. */
+    retrieveSuite(suiteId: string, options?: RequestOptions): Promise<SimulationSuiteDetail>;
+    /**
+     * Rename a suite or set its publish gate: `off`, `warn` (publishing a version succeeds and lists the suites the draft
+     * has not passed) or `block` (publishing is refused with 409 `simulation_required` until it has).
+     */
+    updateSuite(suiteId: string, body: SimulationSuiteUpdateParams, options?: RequestOptions): Promise<SimulationSuite>;
+    /** Delete a suite and its cases. Past runs are deleted with it. */
+    deleteSuite(suiteId: string, options?: RequestOptions): Promise<void>;
+    /** Add a case (up to 50 per suite). 422 `invalid_case` says what to fix. */
+    createCase(suiteId: string, body: SimulationCaseInput, options?: RequestOptions): Promise<SimulationCase>;
+    /** Change a case. Fields you leave out keep their value. */
+    updateCase(caseId: string, body: Partial<SimulationCaseInput>, options?: RequestOptions): Promise<SimulationCase>;
+    deleteCase(caseId: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Run every case of a suite against the draft, a published version or `"latest_published"`. Answers at once
+     * (`202`); the run happens in the background, so poll `retrieveRun` until `status` is `completed`.
+     *
+     * 409 `suite_empty`, 422 `agent_type_not_supported` (multi-prompt agents), 429 `too_many_runs` or
+     * `daily_run_limit`.
+     */
+    run(suiteId: string, body?: SimulationRunCreateParams, options?: RequestOptions): Promise<SimulationRun>;
+    /** Runs, newest first. Pass `suite_id` for one suite's. */
+    listRuns(params?: {
+        suite_id?: string;
+        limit?: number;
+    }, options?: RequestOptions): Promise<SimulationRunList>;
+    /** A run with every case's transcript, tool calls and check results. */
+    retrieveRun(runId: string, options?: RequestOptions): Promise<SimulationRunDetail>;
+    /** Stop a run that has not finished. Cases already under way finish; the rest are skipped. */
+    cancelRun(runId: string, options?: RequestOptions): Promise<SimulationRun>;
+}
+
+/**
+ * Browser calls. Request bodies come from the generated OpenAPI types (see `params.ts`); the response
+ * shapes are written from the API's own serializers.
+ */
+
+type Schemas$4 = components["schemas"];
+type WebCallCreateParams = RequestBody<Schemas$4["WebCallRequest"]>;
+type WebCallSettingsUpdateParams = RequestBody<Schemas$4["WebCallSettings"]>;
+/** What `webCalls.create` returns. Hand `access_token` to the page; keep your API key on the server. */
+interface WebCall {
+    /** The call's id. The call record exists from now, with status `queued` until the browser connects. */
+    call_id: string;
+    agent_id: string;
+    /** The published version this call will run (0 is the live draft). */
+    agent_version: number;
+    /**
+     * A one-use credential for exactly this call and agent. It cannot be used for anything else, and it works
+     * from the origins you have allowed, once.
+     */
+    access_token: string;
+    /** ISO 8601, UTC. 60 seconds after creation: long enough to reach the page, not to be stockpiled. */
+    expires_at: string;
+    expires_in: number;
+}
+interface WebCallSettings {
+    /** The websites (origins, like `https://app.example.com`) browser calls may start from. Empty means none. */
+    allowed_origins: string[];
+    /** True when the list contains `*`: any website may start a call with a token it was given. */
+    any_origin: boolean;
+    limits: {
+        /** Browser calls that can be live at once, per organization. */
+        max_concurrent_calls: number;
+        /** Calls that can be created per minute, per organization. */
+        tokens_per_minute: number;
+        token_ttl_s: number;
+    };
+}
+
+/**
+ * Let a visitor talk to one of your agents from a web page, with `@dialgem/client`.
+ *
+ * Your **backend** calls `create` with your API key and gives the returned `access_token` to the page; the
+ * page connects with that token alone. The key never reaches the browser. Before the first call, allow the
+ * page's origin with `updateSettings`.
+ */
+declare class WebCalls extends APIResource {
+    /**
+     * Create a call for one visitor and get its access token.
+     *
+     *   const { access_token } = await dialgem.webCalls.create({ agent_id, metadata: { visitor: "v_123" } })
+     *
+     * `metadata` and `dialgem_llm_dynamic_variables` are fixed here, by you, and cannot be changed by the page.
+     * 409 `web_origins_not_configured` until an origin is allowed; 402 if the organization cannot pay for calls;
+     * 429 when more than `limits.tokens_per_minute` calls are created in a minute.
+     */
+    create(body: WebCallCreateParams, options?: RequestOptions): Promise<WebCall>;
+    /** The origins browser calls may start from, and the limits that apply. */
+    retrieveSettings(options?: RequestOptions): Promise<WebCallSettings>;
+    /**
+     * Replace the allowed origins. Each is `scheme://host[:port]`; `https://*.example.com` allows any subdomain
+     * (not the bare domain) and `*` allows any website. Tokens already issued keep the list they were issued with.
+     */
+    updateSettings(body: WebCallSettingsUpdateParams, options?: RequestOptions): Promise<WebCallSettings>;
+}
+
+/**
+ * Contacts, lists and CSV imports.
+ *
+ * Request bodies come from the generated OpenAPI types (see `params.ts`); the
+ * response shapes are written here, from the API's own serializers.
+ */
+
+type Schemas$3 = components["schemas"];
+type ContactCreateParams = RequestBody<Schemas$3["ContactCreate"]>;
+type ContactUpdateParams = RequestBody<Schemas$3["ContactUpdate"]>;
+type ContactListCreateParams = RequestBody<Schemas$3["ContactListCreate"]>;
+type ContactListUpdateParams = RequestBody<Schemas$3["ContactListUpdate"]>;
+type ContactImportCreateParams = RequestBody<Schemas$3["ContactImportCreate"]>;
+interface Contact {
+    id: string;
+    /** E.164, for example `+14155552671`. The number is the contact's identity: one contact per number. */
+    phone: string;
+    first_name: string | null;
+    last_name: string | null;
+    email: string | null;
+    /** IANA zone name, for example `America/Chicago`. */
+    timezone: string | null;
+    /** Your own fields, as text. */
+    attributes: Record<string, string>;
+    source: "api" | "dashboard" | "import" | (string & {});
+    /**
+     * Whether the number is on your organization's do-not-call list. Read from that list
+     * each time, never stored on the contact.
+     */
+    do_not_call: boolean;
+    /** ISO 8601, no timezone suffix (UTC). */
+    created_at: string | null;
+    updated_at: string | null;
+    /** Present on `create`, `retrieve` and `update`. */
+    lists?: {
+        id: string;
+        name: string;
+    }[];
+    /** Present on `retrieve`: calls to or from the number. */
+    call_count?: number;
+    last_call_at?: string | null;
+}
+interface ContactListParams {
+    /** Matches name, email and phone digits. */
+    q?: string | undefined;
+    list_id?: string | undefined;
+    /** 1 to 200. Default 50. */
+    limit?: number | undefined;
+}
+interface ContactDeleteResponse {
+    id: string;
+    deleted: true;
+}
+interface ContactCallSummary {
+    id: string;
+    agent_id: string | null;
+    direction: "inbound" | "outbound" | (string & {});
+    status: string;
+    started_at: string | null;
+    ended_at: string | null;
+    duration_s: number | null;
+    disconnection_reason: string | null;
+    /** The call's analysis summary, when it has one. No transcript. */
+    summary: string | null;
+}
+interface ContactCallList {
+    total: number;
+    calls: ContactCallSummary[];
+}
+interface ContactListRecord {
+    id: string;
+    name: string;
+    description: string | null;
+    member_count: number;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface ContactListDeleteResponse {
+    id: string;
+    deleted: true;
+}
+interface ContactListMembersAddResponse {
+    id: string;
+    /** How many were not already in the list. */
+    added: number;
+    member_count: number;
+}
+interface ContactListMemberRemoveResponse {
+    id: string;
+    member_count: number;
+}
+type ContactImportStatus = "queued" | "running"
+/** A dry run finished; apply it with `commit`. */
+ | "previewed" | "completed" | "failed" | "cancelled"
+/** A preview nobody confirmed within a day. */
+ | "expired";
+interface ContactImport {
+    id: string;
+    status: ContactImportStatus;
+    dry_run: boolean;
+    filename: string | null;
+    total_rows: number;
+    /** For a preview, what would be created. */
+    created: number;
+    updated: number;
+    /** Rows repeating an earlier number in the file, or existing contacts when `on_duplicate` is `skip`. */
+    skipped: number;
+    /** Rows that could not be used. See `imports.errors`. */
+    errors: number;
+    /** More rows were rejected than the report keeps (5,000). */
+    errors_truncated: boolean;
+    failure: string | null;
+    mapping: Record<string, string> | null;
+    attribute_columns: string[] | null;
+    default_country: string | null;
+    on_duplicate: "update" | "skip" | null;
+    list_id: string | null;
+    created_at: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+}
+interface ContactImportList {
+    imports: ContactImport[];
+}
+interface ContactCsvInspection {
+    headers: string[];
+    row_count: number;
+    /** The guessed field-to-column mapping: `phone`, `first_name`, `last_name`, `full_name`, `email`, `timezone`. */
+    mapping: Record<string, string>;
+    /** Columns left over, offered as your own fields. */
+    attribute_columns: string[];
+    sample: Record<string, string | null>[];
+}
+interface ContactImportErrorRow {
+    /** The line of the file, counting the header as line 1. */
+    row: number;
+    error: string;
+    values: Record<string, string>;
+}
+interface ContactImportErrors {
+    errors: ContactImportErrorRow[];
+    total: number;
+    truncated: boolean;
+}
+
+/**
+ * The people your organization calls. A phone number identifies each one: it is stored
+ * in international form however you write it, and each number can be a contact once.
+ */
+declare class Contacts extends APIResource {
+    /** Bulk import from CSV, with a dry-run preview. */
+    readonly imports: ContactImports;
+    constructor(client: HttpClient);
+    /**
+     * Add a contact. `phone` is any way of writing a valid number; without a leading `+`
+     * also pass `default_country` (`"US"`). A number that is already a contact answers 409
+     * with its `contact_id`.
+     */
+    create(body: ContactCreateParams, options?: RequestOptions): Promise<Contact>;
+    /**
+     * Contacts, newest first. Await for one page, or iterate for every contact:
+     *
+     */
+    list(params?: ContactListParams, options?: RequestOptions): PagePromise<Contact>;
+    /**
+     * The contact with this phone number. The number is matched as E.164, so
+     * `("(212) 220-0001", { default_country: "US" })` finds `+12122200001`. Throws
+     * `NotFoundError` if you have no such contact, and `UnprocessableEntityError` if the text is
+     * not a phone number.
+     */
+    retrieveByPhone(phone: string, params?: {
+        default_country?: string | undefined;
+    }, options?: RequestOptions): Promise<Contact>;
+    /** One contact, with its lists and how many calls it has had. */
+    retrieve(contactId: string, options?: RequestOptions): Promise<Contact>;
+    /**
+     * Partial update: only the fields you send change, and `null` clears a field.
+     * `attributes` replaces the whole set, so send every field you want kept.
+     */
+    update(contactId: string, body: ContactUpdateParams, options?: RequestOptions): Promise<Contact>;
+    /**
+     * Erase a contact and its list memberships. Calls already made stay in the call log, and
+     * a do-not-call entry for the number stays too, so forgetting a person never makes a number
+     * that asked not to be called dialable again.
+     */
+    delete(contactId: string, options?: RequestOptions): Promise<ContactDeleteResponse>;
+    /** Calls to or from the contact's number, newest first. Summaries, not transcripts. */
+    calls(contactId: string, params?: {
+        limit?: number | undefined;
+    }, options?: RequestOptions): Promise<ContactCallList>;
+}
+/**
+ * CSV import runs in the background. Typical flow: `inspect` to see the columns, `create`
+ * with `dry_run: true`, poll `retrieve` until `previewed`, look at the counts (and `errors`),
+ * then `commit` and poll until `completed`.
+ *
+ * The CSV text is sent in the request. Downloading the rejected rows as a CSV, and exporting
+ * contacts, are available over the REST API (`GET /v1/contacts/imports/{id}/errors?format=csv`,
+ * `GET /v1/contacts/export`).
+ */
+declare class ContactImports extends APIResource {
+    /** The file's headers, a guessed column mapping and a few rows. Imports nothing. */
+    inspect(csv: string, options?: RequestOptions): Promise<ContactCsvInspection>;
+    /**
+     * Start an import. Without `mapping` the columns are guessed from the headers. With
+     * `dry_run: true` nothing is written: the import only validates and reports.
+     */
+    create(body: ContactImportCreateParams, options?: RequestOptions): Promise<ContactImport>;
+    /** Recent imports, newest first. */
+    list(options?: RequestOptions): Promise<ContactImportList>;
+    /** Progress and counts. */
+    retrieve(importId: string, options?: RequestOptions): Promise<ContactImport>;
+    /** The rows that were rejected, with the line, the reason and what each held. */
+    errors(importId: string, params?: {
+        limit?: number | undefined;
+    }, options?: RequestOptions): Promise<ContactImportErrors>;
+    /** Apply a previewed import: the file is read again, so what is applied is what was previewed. */
+    commit(importId: string, options?: RequestOptions): Promise<ContactImport>;
+    /** Stop an import that has not finished. Contacts a running import already wrote stay. */
+    cancel(importId: string, options?: RequestOptions): Promise<ContactImport>;
+}
+/** Named groups of contacts. Deleting a list never deletes its contacts. */
+declare class ContactLists extends APIResource {
+    list(options?: RequestOptions): Promise<{
+        lists: ContactListRecord[];
+    }>;
+    /** Names are unique within your organization, ignoring case. */
+    create(body: ContactListCreateParams, options?: RequestOptions): Promise<ContactListRecord>;
+    retrieve(listId: string, options?: RequestOptions): Promise<ContactListRecord>;
+    update(listId: string, body: ContactListUpdateParams, options?: RequestOptions): Promise<ContactListRecord>;
+    delete(listId: string, options?: RequestOptions): Promise<ContactListDeleteResponse>;
+    /** Add up to 1000 of your contacts. Already-members are ignored; `added` says how many were new. */
+    addContacts(listId: string, contactIds: string[], options?: RequestOptions): Promise<ContactListMembersAddResponse>;
+    removeContact(listId: string, contactId: string, options?: RequestOptions): Promise<ContactListMemberRemoveResponse>;
+}
+
+/**
+ * Which published agent version a number answers on.
+ *
+ * A number is the frozen version with that number; `0` is the live draft, which
+ * is what a number does when nothing is pinned. `"latest_published"` is a
+ * pointer rather than a choice — it follows the newest publish, so shipping a
+ * new version moves every number set to it without touching them.
+ *
+ * A *call* never reports this type: `Call.agent_version` is always the concrete
+ * number that ran, resolved when the call was placed.
+ */
+type AgentVersionRef = number | "latest_published";
+/**
+ * A phone number, as returned by `/v1/phone-numbers`.
+ * The shape is the same across all phone-number endpoints.
+ */
+interface PhoneNumber {
+    /** Dialgem id. Use this (not the E.164 number) for update/assign/delete. */
+    id: string;
+    status: string;
+    provider: string;
+    /** E.164, e.g. `+14155550123`. */
+    phone_number: string;
+    phone_number_pretty: string;
+    phone_number_type: string;
+    nickname: string;
+    inbound_agent_id: string | null;
+    inbound_agent_version: AgentVersionRef;
+    outbound_agent_id: string | null;
+    outbound_agent_version: AgentVersionRef;
+    /** Weighted inbound routing. `inbound_agent_id` is its primary entry. */
+    inbound_agents: PhoneNumberAgentWeight[];
+    outbound_agents: PhoneNumberAgentWeight[];
+    custom_sms_enabled: boolean;
+    flow_sms_sender_enabled: boolean;
+    /** Epoch milliseconds (0 if unknown). */
+    creation_timestamp: number;
+    /** Epoch milliseconds (0 if unknown). */
+    last_modification_timestamp: number;
+    sip_outbound_trunk_config: SipOutboundTrunkConfig | null;
+    /** The inbound routing webhook, asked before an inbound call is answered. `null` when none is set. */
+    inbound_webhook_url: string | null;
+    /** The last four characters of the signing secret; `null` with no webhook. */
+    inbound_webhook_secret_hint: string | null;
+    /** The full signing secret. Present **only** in the response that created or rotated it, never again. */
+    inbound_webhook_secret?: string;
+}
+/** What `phoneNumbers.testInboundWebhook` reports. */
+interface InboundWebhookTestResult {
+    /** Your endpoint answered with a 2xx. */
+    ok: boolean;
+    status_code: number | null;
+    latency_ms: number;
+    /** The time your endpoint has for a real call (`INBOUND_ROUTING_TIMEOUT_S`). */
+    budget_ms: number;
+    error: string | null;
+    /** What a real call would have done with the answer. */
+    decision: {
+        outcome: "unchanged" | "applied" | "rejected" | "fallback";
+        note?: string;
+        reject_reason?: string;
+        agent_id?: string;
+        agent_version?: number | null;
+        /** Names of the dynamic variables that would be applied. */
+        variables?: string[];
+        metadata_keys?: string[];
+        /** Fields that would be ignored, as `field: reason`. */
+        ignored?: Record<string, string>;
+    };
+}
+interface PhoneNumberAgentWeight {
+    agent_id: string;
+    agent_version: AgentVersionRef;
+    weight: number;
+}
+interface SipOutboundTrunkConfig {
+    termination_uri?: string | null;
+    transport?: string | null;
+    auth_username?: string | null;
+    [key: string]: unknown;
+}
+
+declare class PhoneNumbers extends APIResource {
+    /** Register a number you own (`phone_number` in E.164) with Dialgem. */
+    create(body: PhoneNumberCreateParams, options?: RequestOptions): Promise<PhoneNumber>;
+    /** Every active (not released) number in the organization, newest first. */
+    list(options?: RequestOptions): Promise<PhoneNumber[]>;
+    /**
+     * One number by its E.164 value, e.g. `+14155550123`.
+     *
+     * Keyed on the number rather than on `id`, because the number is what you
+     * have when you are asking whether it is registered at all. Throws
+     * `NotFoundError` when it is not.
+     */
+    retrieve(phoneNumber: string, options?: RequestOptions): Promise<PhoneNumber>;
+    /**
+     * Partial update.
+     *
+     * `inbound_agent_id` is **ignored unless `set_inbound_agent: true`** is sent with
+     * it, both to set an agent and to clear one (`null`). Same for the outbound pair.
+     * `inbound_agents` / `outbound_agents` (weighted routing), when sent, take
      * precedence over the single-agent fields.
      */
     update(phoneNumberId: string, body: PhoneNumberUpdateParams, options?: RequestOptions): Promise<PhoneNumber>;
     /** Set the number's **inbound** agent, or pass `agent_id: null` to clear it. For outbound, use `update`. */
     assign(phoneNumberId: string, body: PhoneNumberAssignParams, options?: RequestOptions): Promise<PhoneNumber>;
+    /**
+     * Send one signed test request to the number's inbound routing webhook and report what a real call would have done
+     * with your answer: the status, how long you took against the time budget, and any field that would be ignored.
+     * Throws a `ConflictError` (`inbound_webhook_not_set`) when the number has no `inbound_webhook_url`.
+     */
+    testInboundWebhook(phoneNumberId: string, options?: RequestOptions): Promise<InboundWebhookTestResult>;
+    /**
+     * Replace the inbound webhook's signing secret. The new secret is returned **once**, as `inbound_webhook_secret`
+     * on the number; the old one stops working at once.
+     */
+    rotateInboundWebhookSecret(phoneNumberId: string, options?: RequestOptions): Promise<PhoneNumber>;
     /** Release the number from Dialgem. It stops routing calls and disappears from `list()`; your carrier account is untouched. */
     delete(phoneNumberId: string, options?: RequestOptions): Promise<void>;
 }
 
 /**
- * Payloads Dialgem POSTs to an agent's `webhook_url`, subscribed per agent via
- * `webhook_events`. Flat objects with an `event` discriminator; see
- * the "Verify webhooks" section of the README.
+ * Chats. Request bodies come from the generated OpenAPI types; the response shapes are written from the
+ * API's own serializer (`chat_to_dict`).
+ */
+
+type Schemas$2 = components["schemas"];
+type ChatCreateParams = RequestBody<Schemas$2["ChatCreate"]>;
+type ChatUpdateParams = RequestBody<Schemas$2["ChatUpdate"]>;
+interface ChatListParams {
+    agent_id?: string | undefined;
+    status?: "ongoing" | "ended" | undefined;
+    /** 1 to 100. Default 50. */
+    limit?: number | undefined;
+}
+/** One entry in a chat. Tool use is shown between the user's message and the agent's reply. */
+interface ChatMessage {
+    message_id: string;
+    role: "user" | "agent" | "tool_call_invocation" | "tool_call_result" | (string & {});
+    /** The text. Empty on a `tool_call_invocation`; the tool's answer on a `tool_call_result`. */
+    content: string;
+    /** Epoch milliseconds. */
+    created_timestamp: number;
+    /** On the two tool roles: ties an invocation to its result. */
+    tool_call_id?: string;
+    /** On `tool_call_invocation`. */
+    name?: string;
+    arguments?: Record<string, unknown>;
+}
+interface Chat {
+    id: string;
+    /** Same as `id`. */
+    chat_id: string;
+    chat_type: "api_chat" | (string & {});
+    chat_status: "ongoing" | "ended" | (string & {});
+    agent_id: string;
+    /** The version the chat answers with; 0 is the live draft. */
+    agent_version: number;
+    metadata: Record<string, unknown>;
+    dynamic_variables: Record<string, string>;
+    /** Epoch milliseconds. */
+    start_timestamp: number | null;
+    end_timestamp: number | null;
+    /** `user_ended`, `agent_ended`, ... `null` while ongoing. */
+    end_reason: string | null;
+    /** User and agent messages, not counting tool entries. */
+    message_count: number;
+    /** `User: ...` / `Agent: ...` lines. */
+    transcript: string;
+    /** Same shape as a call's `analysis`; `null` until it has run (a moment after the chat ends). */
+    analysis: Record<string, unknown> | null;
+    /**
+     * What the chat has cost so far, in $0.0001 units (50 = $0.005), and how many agent messages it holds
+     * (the greeting is one, and is not billed). `null` for a team-member session, as for a call's cost.
+     * Estimates until the price list is published.
+     */
+    chat_cost: {
+        combined_cost: number;
+        reply_count: number;
+    } | null;
+    /** Left out of `list` entries; fetch one chat for them. */
+    messages?: ChatMessage[];
+}
+/** What `chats.sendMessage` returns: only the new entries, in order. */
+interface ChatReply {
+    chat_id: string;
+    chat_status: "ongoing" | "ended" | (string & {});
+    messages: ChatMessage[];
+}
+interface ChatDeleteResponse {
+    deleted: true;
+    id: string;
+}
+
+/**
+ * Text conversations with one of your agents, from your backend.
+ *
+ *   const chat = await dialgem.chats.create({ agent_id, dynamic_variables: { customer: "Ada" } })
+ *   const { messages } = await dialgem.chats.sendMessage(chat.id, "Can I come in on Tuesday?")
+ *   await dialgem.chats.end(chat.id)
  *
- * Delivery is at-least-once in practice: a failed POST is retried once after a
- * second, so a slow 2xx can arrive twice. Make handlers idempotent on
- * `(event, call_id)`.
+ * The agent is the one that answers your phone: same prompt, model and functions. Prompt agents only; an agent
+ * that keeps no transcript cannot chat. Your API key stays on your server; to put a chat box on a web page,
+ * have your backend call `sendMessage` for the visitor.
  */
-type WebhookEvent = CallStartedEvent | CallEndedEvent | CallAnalyzedEvent;
-interface CallStartedEvent {
-    event: "call_started";
+declare class Chats extends APIResource {
+    /**
+     * Start a chat. If the agent has a first message it is already in `messages`.
+     *
+     * `UnprocessableEntityError` with `errCode` `agent_type_not_supported` (flow agents) or `chat_requires_storage`.
+     * Not retried by default.
+     */
+    create(body: ChatCreateParams, options?: RequestOptions): Promise<Chat>;
+    /**
+     * Chats, newest first. Await for one page, or iterate for every chat. Entries leave out `messages`;
+     * `retrieve` a chat for them.
+     */
+    list(params?: ChatListParams, options?: RequestOptions): PagePromise<Chat>;
+    /** One chat with all its messages. */
+    retrieve(chatId: string, options?: RequestOptions): Promise<Chat>;
+    /** Replace the chat's `metadata` (the whole object). */
+    update(chatId: string, body: ChatUpdateParams, options?: RequestOptions): Promise<Chat>;
+    /** Delete a chat and its messages. */
+    delete(chatId: string, options?: RequestOptions): Promise<ChatDeleteResponse>;
+    /**
+     * Send the user's message and wait for the agent's reply. Returns only the new entries, in order: the user's
+     * message, any tool use, the agent's reply.
+     *
+     * If the agent's model fails (`ServerError`, `errCode` `model_error`) nothing is stored and the same message
+     * can be sent again. `ConflictError` with `errCode` `chat_busy` while another reply is in progress,
+     * `chat_ended` after the end, `message_limit` at the cap. If the agent calls its end-call tool, the reply's
+     * `chat_status` is `ended`.
+     *
+     * Not retried by default: a retry after an ambiguous failure could send the message twice.
+     */
+    sendMessage(chatId: string, content: string, options?: RequestOptions): Promise<ChatReply>;
+    /** End the chat. Ending twice is fine. The analysis arrives a moment later; read it with `retrieve`. */
+    end(chatId: string, options?: RequestOptions): Promise<Chat>;
+    /**
+     * Analyse an ended chat again with the agent's current analysis settings and return it. `ConflictError` with
+     * `errCode` `chat_in_progress` until it has ended, `no_transcript` when it has no messages.
+     */
+    rerunAnalysis(chatId: string, options?: RequestOptions): Promise<Chat>;
+}
+
+/**
+ * Saved flows. Request bodies come from the generated OpenAPI types; the response shape is written from the
+ * API's own serializer (`flow_to_dict`).
+ */
+
+type Schemas$1 = components["schemas"];
+type FlowCreateParams = RequestBody<Schemas$1["FlowCreate"]>;
+type FlowUpdateParams = RequestBody<Schemas$1["FlowUpdate"]>;
+interface FlowListParams {
+    /** 1 to 100. Default 50. */
+    limit?: number | undefined;
+}
+interface Flow {
+    id: string;
+    /** Same as `id`. */
+    flow_id: string;
+    name: string;
+    language: string;
+    /** Bumped by the server when the flow's content changes. */
+    version: number | null;
+    node_count: number;
+    /** Epoch milliseconds. */
+    created_timestamp: number | null;
+    last_modification_timestamp: number | null;
+    /** Left out of `list` entries; `retrieve` a flow for it. */
+    flow_config?: FlowConfig;
+    /** Present on `create` / `update` when the flow saved with warnings. */
+    flow_validation?: {
+        issues: ErrorIssue[];
+    };
+}
+interface FlowDeleteResponse {
+    deleted: true;
+    id: string;
+}
+
+/**
+ * Conversation flows you save once and attach to agents.
+ *
+ *   const flow = await dialgem.flows.create({ name: "Intake", flow_config })
+ *   await dialgem.agents.create({ name: "Front desk", agent_type: "flow", flow_id: flow.id })
+ *
+ * A flow is checked the way an agent's `flow_config` is, so a saved flow is one that would have saved on an
+ * agent. **Attaching copies it**: `agents.create` / `agents.update` with `flow_id` takes a snapshot, and editing
+ * or deleting the flow afterwards changes no agent, no published version and no call.
+ */
+declare class Flows extends APIResource {
+    /** Validate and save a flow. `UnprocessableEntityError` (`errCode` `flow_invalid`) lists every problem. Not retried by default. */
+    create(body: FlowCreateParams, options?: RequestOptions): Promise<Flow>;
+    /** Flows, newest first. Await for one page, or iterate for every flow. Entries leave out `flow_config`. */
+    list(params?: FlowListParams, options?: RequestOptions): PagePromise<Flow>;
+    /** One flow with its `flow_config`. */
+    retrieve(flowId: string, options?: RequestOptions): Promise<Flow>;
+    /** Rename a flow and/or replace its `flow_config` (checked again). Agents it was attached to are not changed. */
+    update(flowId: string, body: FlowUpdateParams, options?: RequestOptions): Promise<Flow>;
+    /** Delete a saved flow. Agents it was attached to keep their copy. */
+    delete(flowId: string, options?: RequestOptions): Promise<FlowDeleteResponse>;
+}
+
+/**
+ * Saved LLM settings. Request bodies come from the generated OpenAPI types; the response shape is written from
+ * the API's own serializer (`llm_to_dict`).
+ */
+
+type Schemas = components["schemas"];
+type LLMCreateParams = RequestBody<Schemas["LLMCreate"]>;
+type LLMUpdateParams = RequestBody<Schemas["LLMUpdate"]>;
+interface LLMListParams {
+    /** 1 to 100. Default 50. */
+    limit?: number | undefined;
+}
+interface LLM {
+    id: string;
+    /** Same as `id`. */
+    llm_id: string;
+    name: string;
+    /** Epoch milliseconds. */
+    created_timestamp: number | null;
+    last_modification_timestamp: number | null;
+    system_prompt: string;
+    first_message: string | null;
+    llm_provider: "anthropic" | "openai" | (string & {});
+    llm_model: string;
+    temperature: number;
+    max_tokens: number;
+    fallback_llm_provider: "anthropic" | "openai" | (string & {}) | null;
+    fallback_llm_model: string | null;
+    default_dynamic_variables: Record<string, string>;
+}
+interface LLMDeleteResponse {
+    deleted: true;
+    id: string;
+}
+
+/**
+ * A prompt and model you set up once and attach to agents.
+ *
+ *   const llm = await dialgem.llms.create({ name: "Booking", system_prompt, llm_model: "gpt-4o-mini" })
+ *   await dialgem.agents.create({ name: "Front desk", llm_id: llm.id })
+ *
+ * It holds `system_prompt`, `first_message`, `llm_provider`, `llm_model`, `temperature`, `max_tokens`, the
+ * fallback pair and `default_dynamic_variables`. **Attaching copies it**: `agents.create` / `agents.update` with
+ * `llm_id` writes those values into the agent, and editing or deleting the saved LLM afterwards changes no
+ * agent, no published version and no call. Sending `llm_id` together with any of those fields is refused.
+ */
+declare class LLMs extends APIResource {
+    /** Save LLM settings. Anything left out takes the default a new agent gets. Not retried by default. */
+    create(body: LLMCreateParams, options?: RequestOptions): Promise<LLM>;
+    /** Saved LLMs, newest first. Await for one page, or iterate for every one. */
+    list(params?: LLMListParams, options?: RequestOptions): PagePromise<LLM>;
+    retrieve(llmId: string, options?: RequestOptions): Promise<LLM>;
+    /** Change the fields you send. Agents it was attached to are not changed. */
+    update(llmId: string, body: LLMUpdateParams, options?: RequestOptions): Promise<LLM>;
+    /** Delete saved LLM settings. Agents they were attached to keep their copy. */
+    delete(llmId: string, options?: RequestOptions): Promise<LLMDeleteResponse>;
+}
+
+/**
+ * Payloads Dialgem POSTs to an agent's `webhook_url`, for the events subscribed in
+ * `webhook_events`. Each carries the full call record; see the "Verify webhooks"
+ * section of the README.
+ *
+ * A failed delivery is retried up to three times, and every attempt carries the
+ * same `x-dialgem-delivery` id. Use it (or `event` + `call_id`) to drop duplicates.
+ */
+type WebhookEvent = CallStartedEvent | CallEndedEvent | CallAnalyzedEvent | TranscriptUpdatedEvent | TransferStartedEvent | TransferBridgedEvent | TransferCancelledEvent | TransferEndedEvent | ChatStartedEvent | ChatEndedEvent | ChatAnalyzedEvent;
+interface CallEventBase {
     call_id: string;
     agent_id: string;
+    /** The full call record at the moment the event was sent. */
+    call: Call;
 }
-interface CallEndedEvent {
+interface CallStartedEvent extends CallEventBase {
+    event: "call_started";
+}
+/** Sent as soon as the call ends; post-call analysis follows in `call_analyzed`. */
+interface CallEndedEvent extends CallEventBase {
     event: "call_ended";
-    call_id: string;
-    agent_id: string;
-    status: CallStatus;
-    duration_s: number | null;
 }
-/** Sent before `call_ended`, and only for calls that produced a transcript. */
-interface CallAnalyzedEvent {
+/** Sent after `call_ended`, once analysis has run, and only for calls that produced a transcript. */
+interface CallAnalyzedEvent extends CallEventBase {
     event: "call_analyzed";
-    call_id: string;
+}
+interface ChatEventBase {
+    chat_id: string;
     agent_id: string;
-    analysis: CallAnalysis;
+    /** The full chat record, with its messages, at the moment the event was sent. */
+    chat: Chat;
+}
+/** A chat was started. Chat events carry `chat_id`, not `call_id`. */
+interface ChatStartedEvent extends ChatEventBase {
+    event: "chat_started";
+}
+/** The chat ended (by `chats.end` or by the agent). Analysis follows in `chat_analyzed`. */
+interface ChatEndedEvent extends ChatEventBase {
+    event: "chat_ended";
+}
+/** Sent once a chat's analysis has run. */
+interface ChatAnalyzedEvent extends ChatEventBase {
+    event: "chat_analyzed";
+}
+/** A transcript turn as carried by `transcript_updated`. */
+interface WebhookTranscriptTurn {
+    role: "user" | "agent";
+    text: string;
+    timestamp: string;
+    start_ms?: number;
+}
+/**
+ * Sent each time a caller or agent turn is added to the live transcript.
+ *
+ * `transcript` is the whole transcript so far, so a receiver that misses or
+ * reorders a delivery still ends up correct. `turn_index` increases by one per
+ * event within a call; keep the highest.
+ */
+interface TranscriptUpdatedEvent extends CallEventBase {
+    event: "transcript_updated";
+    /** Who spoke the turn that triggered this event. */
+    role: "user" | "agent";
+    turn_index: number;
+    transcript: WebhookTranscriptTurn[];
+}
+/** What a transfer event says about the transfer. Fields are present only when known. */
+interface WebhookTransferInfo {
+    /** The number the call is being transferred to. */
+    target?: string;
+    mode?: "cold" | "warm" | string;
+    /** Why a transfer was cancelled: a carrier dial status (`busy`, `no-answer`, ...) or a failure reason. */
+    reason?: string;
+}
+/** The agent asked for the call to be transferred. */
+interface TransferStartedEvent extends CallEventBase {
+    event: "transfer_started";
+    transfer: WebhookTransferInfo;
+}
+/**
+ * The transferee answered and was connected to the caller. For a cold transfer
+ * this is delivered when the transferred leg finishes, immediately followed by
+ * `transfer_ended`.
+ */
+interface TransferBridgedEvent extends CallEventBase {
+    event: "transfer_bridged";
+    transfer: WebhookTransferInfo;
+}
+/** The transfer did not connect: busy, no answer, failed, or could not be placed. */
+interface TransferCancelledEvent extends CallEventBase {
+    event: "transfer_cancelled";
+    transfer: WebhookTransferInfo;
+}
+/** A connected transfer finished. */
+interface TransferEndedEvent extends CallEventBase {
+    event: "transfer_ended";
+    transfer: WebhookTransferInfo;
+}
+/**
+ * The body Dialgem POSTs to a custom function's URL when the agent calls it,
+ * unless the function has `args_at_root`, in which case the body is `args` alone.
+ */
+interface FunctionCallRequest<Args = Record<string, unknown>> {
+    /** The function's name. */
+    name: string;
+    call: FunctionCallContext;
+    /** The arguments the agent supplied, per the function's `parameters` schema. */
+    args: Args;
+}
+interface FunctionCallContext {
+    call_id: string;
+    agent_id: string | null;
+    call_type: "phone_call" | "web_call";
+    direction: "inbound" | "outbound" | null;
+    from_number: string | null;
+    to_number: string | null;
+    dynamic_variables: Record<string, string>;
+    metadata: Record<string, unknown>;
 }
 
-/** Header carrying the hex HMAC-SHA256 of the raw request body. */
+/** Header carrying the request signature: `v=<timestamp_ms>,d=<hex>`. */
 declare const WEBHOOK_SIGNATURE_HEADER = "x-dialgem-signature";
 /** Header naming the event; the same value as the body's `event`. */
 declare const WEBHOOK_EVENT_HEADER = "x-dialgem-event";
+/**
+ * During a signing-secret rotation overlap, the same body signed with the PREVIOUS
+ * secret. Verify `x-dialgem-signature` with the new secret; a receiver that has not
+ * switched yet can verify this one with the old secret instead.
+ */
+declare const WEBHOOK_PREVIOUS_SIGNATURE_HEADER = "x-dialgem-signature-previous";
+/** Header with an id that stays the same across retries of one delivery. */
+declare const WEBHOOK_DELIVERY_HEADER = "x-dialgem-delivery";
+/** Signatures older or newer than this are rejected, so a captured request cannot be replayed. */
+declare const DEFAULT_SIGNATURE_TOLERANCE_MS: number;
 /** The raw request body, byte-for-byte as received. Node `Buffer` is a `Uint8Array`. */
 type WebhookPayload = string | Uint8Array | ArrayBuffer;
 /** A header value as Node's `IncomingHttpHeaders`, `Headers.get()` or a framework hands it over. */
 type SignatureHeader = string | string[] | null | undefined;
+interface VerifyOptions {
+    /** Maximum age (and clock skew) of a signature, in ms. Default 5 minutes. */
+    toleranceMs?: number | undefined;
+    /** The current time in epoch ms. For tests; defaults to `Date.now()`. */
+    now?: number | undefined;
+}
 /**
- * Verifies and parses Dialgem webhooks.
+ * Verifies and parses what Dialgem sends to your servers: event webhooks, and
+ * requests to your custom functions. Both use one signature scheme:
+ *
+ *   x-dialgem-signature: v=<timestamp_ms>,d=<hex>
+ *   hex = HMAC-SHA256(secret, raw_body + timestamp_ms)
+ *
+ * The secret is the agent's `webhook_signing_secret`.
  *
  * **Pass the raw body.** The signature covers the exact bytes Dialgem sent. A body
  * that was parsed and re-serialized (`express.json()`, `JSON.stringify(req.body)`)
@@ -2175,27 +4249,36 @@ type SignatureHeader = string | string[] | null | undefined;
  * Fastify's raw body, or `await request.text()` in a route handler.
  */
 declare class Webhooks {
+    #private;
     /**
-     * Returns whether `signature` is the HMAC-SHA256 of `payload` under `secret`.
-     * Constant-time. Returns `false` for a missing or malformed signature; throws only
-     * if `secret` is empty, which is a configuration error rather than a bad request.
+     * Returns whether `signature` is a current, valid signature of `payload` under
+     * `secret`. Constant-time. Returns `false` for a missing, malformed, tampered or
+     * stale signature; throws only if `secret` is empty, which is a configuration
+     * error rather than a bad request.
      */
-    verify(payload: WebhookPayload, signature: SignatureHeader, secret: string): Promise<boolean>;
+    verify(payload: WebhookPayload, signature: SignatureHeader, secret: string, options?: VerifyOptions): Promise<boolean>;
     /**
-     * Verifies the signature, then parses the body.
+     * Verifies a webhook's signature, then parses its body.
      *
-     * @throws WebhookVerificationError if the signature is missing or does not match.
+     * @throws WebhookVerificationError if the signature is missing, invalid or stale.
      */
-    constructEvent(payload: WebhookPayload, signature: SignatureHeader, secret: string): Promise<WebhookEvent>;
+    constructEvent(payload: WebhookPayload, signature: SignatureHeader, secret: string, options?: VerifyOptions): Promise<WebhookEvent>;
+    /**
+     * Verifies a request Dialgem made to one of your custom functions, then parses
+     * its body. For functions with `args_at_root`, the body is the arguments object
+     * alone; use `verify` and parse it yourself.
+     *
+     * @throws WebhookVerificationError if the signature is missing, invalid or stale.
+     */
+    constructFunctionCall<Args = Record<string, unknown>>(payload: WebhookPayload, signature: SignatureHeader, secret: string, options?: VerifyOptions): Promise<FunctionCallRequest<Args>>;
 }
 declare const webhooks: Webhooks;
 
-declare const DEFAULT_BASE_URL = "https://api.dialgem.com";
+/** The Dialgem API. Fixed: the SDK talks to Dialgem and nothing else. */
+declare const BASE_URL = "https://api.dialgem.com";
 interface ClientOptions {
     /** Organization API key (`zk_…`). Defaults to `process.env.DIALGEM_API_KEY`. */
     apiKey?: string | undefined;
-    /** Defaults to `process.env.DIALGEM_BASE_URL`, then `https://api.dialgem.com`. */
-    baseURL?: string | undefined;
     /** Per-attempt timeout in milliseconds (> 0). Default 60000. */
     timeout?: number | undefined;
     /** Retries for GET/PATCH/DELETE on 408/429/5xx and connection errors. Default 2. POST is not retried. */
@@ -2221,20 +4304,43 @@ interface ClientOptions {
  * ```
  */
 declare class Dialgem {
-    static readonly DEFAULT_BASE_URL = "https://api.dialgem.com";
+    static readonly BASE_URL = "https://api.dialgem.com";
     /** Webhook verification without a client instance: `Dialgem.webhooks.constructEvent(...)`. */
     static readonly webhooks: Webhooks;
     readonly agents: Agents;
     readonly calls: Calls;
     readonly phoneNumbers: PhoneNumbers;
     readonly voices: Voices;
+    /** Models available for post-call analysis. */
+    readonly extractionModels: ExtractionModels;
     readonly flowTemplates: FlowTemplates;
     readonly promptTemplates: PromptTemplates;
+    /** Calls in progress right now. */
+    readonly sessions: Sessions;
+    /** Text conversations with an agent. */
+    readonly chats: Chats;
+    readonly flows: Flows;
+    readonly llms: LLMs;
+    /** What this API key is and may do. */
+    readonly apiKey: ApiKey;
+    /**
+     * Verify what Dialgem sends you: `dialgem.webhooks.constructEvent(rawBody, signatureHeader, secret)`.
+     */
     readonly webhooks: Webhooks;
+    /** The organization's webhook destinations: create, update, rotate the signing secret, test. */
+    /** The people you call, with CSV import under `contacts.imports`. */
+    readonly contacts: Contacts;
+    /** Named groups of contacts. */
+    readonly contactLists: ContactLists;
+    /** Browser calls: tokens for `@dialgem/client`, and the origins allowed to start them. */
+    readonly webCalls: WebCalls;
+    /** Saved test conversations for an agent, run in text, with an optional publish gate. */
+    readonly simulations: Simulations;
+    /** Always `https://api.dialgem.com`. */
     readonly baseURL: string;
     constructor(options?: ClientOptions);
 }
 
-declare const VERSION = "0.1.0-beta.0";
+declare const VERSION = "0.1.0-beta.2";
 
-export { APIConnectionError, APIConnectionTimeoutError, APIError, APIUserAbortError, type Agent, type AgentCreateParams, type AgentDeleteResponse, type AgentFunction, AgentFunctions, AgentKnowledge, AgentMCPServers, type AgentType, type AgentUpdateParams, type AgentWeight, Agents, AuthenticationError, BadRequestError, type Call, type CallAnalysis, type CallAnalyzedEvent, type CallCost, type CallCreatePhoneCallParams, type CallEndedEvent, type CallListParams, type CallRegisterParams, type CallRegisterResponse, type CallSessionStatus, type CallStartedEvent, type CallStatus, Calls, type ClientOptions, ConflictError, DEFAULT_BASE_URL, Dialgem, DialgemError, type ErrorBody, type ErrorIssue, type Fetch, type FetchInit, type FetchResponse, type FlowConfig, type FlowTemplate, type FlowTemplateSummary, FlowTemplates, type FunctionCreateParams, type FunctionKind, type FunctionReorderParams, type FunctionUpdateParams, type HeadersLike, InternalServerError, type KeyValuePair, type KnowledgeDocument, type KnowledgeDocumentCreateParams, type MCPServer, type MCPServerCreateParams, type MCPServerTestResult, type MCPServerUpdateParams, NotFoundError, Page, type PageData, PagePromise, PermissionDeniedError, type PhoneCallCreateResponse, type PhoneNumber, type PhoneNumberAgentWeight, type PhoneNumberAssignParams, type PhoneNumberCreateParams, type PhoneNumberUpdateParams, PhoneNumbers, type PostCallAnalysisVariable, type PromptState, type PromptTemplate, type PromptTemplateSummary, PromptTemplates, RateLimitError, type RequestBody, type RequestOptions, type SignatureHeader, type SipOutboundTrunkConfig, type TemplateListParams, type TranscriptTurn, UnprocessableEntityError, VERSION, type Voice, type VoiceListParams, Voices, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, type WebhookEvent, type WebhookEventType, type WebhookPayload, WebhookVerificationError, Webhooks, webhooks };
+export { APIConnectionError, APIConnectionTimeoutError, APIError, APIUserAbortError, type Agent, type AgentCreateParams, type AgentDeleteResponse, type AgentFunction, AgentFunctions, AgentKnowledge, AgentMCPServers, type AgentSession, type AgentSessionList, type AgentSessionReleaseResult, type AgentSessionSayParams, type AgentSessionSayResult, type AgentSessionUpdateParams, type AgentSessionUpdateResult, type AgentType, type AgentUpdateParams, type AgentVersion, type AgentVersionConfig, type AgentVersionListParams, type AgentVersionListResponse, type AgentVersionMCPServer, type AgentVersionPublishParams, type AgentVersionRef, type AgentVersionSummary, AgentVersions, type AgentWeight, Agents, ApiKey, type ApiKeyDetails, type ApiKeyInfo, AuthenticationError, BASE_URL, BadRequestError, type Call, type CallAnalysis, type CallAnalyzedEvent, type CallCost, type CallCreatePhoneCallParams, type CallDeleteResponse, type CallEndedEvent, type CallLatency, type CallListParams, type CallRegisterParams, type CallRegisterResponse, type CallSessionStatus, type CallStartedEvent, type CallStatus, type CallStopResponse, type CallUpdateParams, Calls, type Chat, type ChatAnalyzedEvent, type ChatCreateParams, type ChatDeleteResponse, type ChatEndedEvent, type ChatListParams, type ChatMessage, type ChatReply, type ChatStartedEvent, type ChatUpdateParams, Chats, type ClientOptions, ConflictError, type Contact, type ContactCallList, type ContactCallSummary, type ContactCreateParams, type ContactCsvInspection, type ContactDeleteResponse, type ContactImport, type ContactImportCreateParams, type ContactImportErrorRow, type ContactImportErrors, type ContactImportList, type ContactImportStatus, ContactImports, type ContactListCreateParams, type ContactListDeleteResponse, type ContactListMemberRemoveResponse, type ContactListMembersAddResponse, type ContactListParams, type ContactListRecord, type ContactListUpdateParams, ContactLists, type ContactUpdateParams, Contacts, DEFAULT_SIGNATURE_TOLERANCE_MS, Dialgem, DialgemError, type DisconnectionReason, type ErrorBody, type ErrorIssue, type ExtractionModel, type ExtractionModelList, ExtractionModels, type Fetch, type FetchInit, type FetchResponse, type Flow, type FlowConfig, type FlowCreateParams, type FlowDeleteResponse, type FlowListParams, type FlowTemplate, type FlowTemplateSummary, FlowTemplates, type FlowUpdateParams, Flows, type FunctionCallContext, type FunctionCallRequest, type FunctionCreateParams, type FunctionKind, type FunctionReorderParams, type FunctionUpdateParams, type HeadersLike, type InboundWebhookTestResult, InternalServerError, type KeyValuePair, type KnowledgeDocument, type KnowledgeDocumentCreateParams, type LLM, type LLMCreateParams, type LLMDeleteResponse, type LLMListParams, type LLMUpdateParams, LLMs, type LatencyStats, type MCPServer, type MCPServerCreateParams, type MCPServerTestResult, type MCPServerUpdateParams, type MCPTool, type MCPToolList, NotFoundError, Page, type PageData, PagePromise, PermissionDeniedError, type PhoneCallCreateResponse, type PhoneNumber, type PhoneNumberAgentWeight, type PhoneNumberAssignParams, type PhoneNumberCreateParams, type PhoneNumberUpdateParams, PhoneNumbers, type PostCallAnalysisVariable, type PostCallBuiltinFields, type PromptState, type PromptTemplate, type PromptTemplateSummary, PromptTemplates, RateLimitError, type RequestBody, type RequestOptions, Sessions, type SignatureHeader, type SimulationCaller, type SimulationCase, type SimulationCaseInput, type SimulationCheck, type SimulationCheckResult, type SimulationPublishGate, type SimulationResult, type SimulationResultStatus, type SimulationRun, type SimulationRunCreateParams, type SimulationRunDetail, type SimulationRunList, type SimulationRunStatus, type SimulationSuite, type SimulationSuiteCreateParams, type SimulationSuiteDetail, type SimulationSuiteList, type SimulationSuiteUpdateParams, Simulations, type SipOutboundTrunkConfig, type TemplateListParams, type TranscriptTurn, UnprocessableEntityError, VERSION, type VerifyOptions, type Voice, type VoiceCloneFile, type VoiceCloneParams, type VoiceDeleteResponse, type VoiceListParams, Voices, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_PREVIOUS_SIGNATURE_HEADER, WEBHOOK_SIGNATURE_HEADER, type WebCall, type WebCallCreateParams, type WebCallSettings, type WebCallSettingsUpdateParams, WebCalls, type WebhookEvent, type WebhookEventType, type WebhookPayload, WebhookVerificationError, Webhooks, webhooks };