@dialgem/sdk 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/index.d.cts

@@ -138,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.
      */
@@ -160,7 +160,7 @@ 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;
@@ -175,6 +175,7 @@ declare class HttpClient {
      * 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 }: {
@@ -190,6 +191,11 @@ interface components {
     schemas: {
         /** AgentCreate */
         AgentCreate: {
+            /**
+             * Adaptive Response Wait
+             * @default false
+             */
+            adaptive_response_wait?: boolean;
             /**
              * Agent Type
              * @default llm
@@ -224,6 +230,16 @@ 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;
             /**
@@ -241,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
@@ -266,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;
             /**
@@ -319,6 +359,7 @@ 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 */
@@ -347,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}
@@ -368,6 +415,12 @@ interface components {
              */
             tts_engine?: string;
             user_dtmf_options?: components["schemas"]["UserDtmfOptions"];
+            /**
+             * Vocab Specialization
+             * @default general
+             * @enum {string}
+             */
+            vocab_specialization?: "general" | "medical";
             /**
              * Voice Id
              * @default
@@ -399,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;
         };
@@ -450,6 +513,8 @@ interface components {
         };
         /** AgentUpdate */
         AgentUpdate: {
+            /** Adaptive Response Wait */
+            adaptive_response_wait?: boolean | null;
             /** Agent Type */
             agent_type?: ("llm" | "multi_prompt" | "flow") | null;
             /** Allow User Dtmf */
@@ -464,6 +529,10 @@ 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 */
@@ -473,7 +542,11 @@ interface components {
                 [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 */
@@ -489,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 */
@@ -515,6 +598,7 @@ interface components {
             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 */
@@ -531,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 */
@@ -540,6 +626,8 @@ interface components {
             /** 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 */
@@ -552,10 +640,14 @@ 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;
         };
@@ -623,6 +715,36 @@ 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;
+        };
+        /** BuyNumberRequest */
+        BuyNumberRequest: {
+            /** Nickname */
+            nickname?: string | null;
+            /** Phone Number */
+            phone_number: string;
+            /**
+             * Type
+             * @default local
+             */
+            type?: string;
+        };
         /** CallPatch */
         CallPatch: {
             /** Amd Result */
@@ -633,6 +755,8 @@ interface components {
             call_sid?: string | null;
             /** Disconnection Reason */
             disconnection_reason?: string | null;
+            /** Disconnection Reason Default */
+            disconnection_reason_default?: string | null;
             /** Duration S */
             duration_s?: number | null;
             /** Ended At */
@@ -656,6 +780,204 @@ interface components {
             /** 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 */
@@ -850,7 +1172,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 */
@@ -866,6 +1188,17 @@ interface components {
         } & {
             [key: string]: unknown;
         };
+        /** FlowCreate */
+        FlowCreate: {
+            flow_config: components["schemas"]["FlowConfig"];
+            /**
+             * Language
+             * @default en
+             */
+            language?: string;
+            /** Name */
+            name: string;
+        };
         /** FlowTool */
         FlowTool: {
             /** Description */
@@ -897,6 +1230,14 @@ interface components {
         } & {
             [key: string]: unknown;
         };
+        /** FlowUpdate */
+        FlowUpdate: {
+            flow_config?: components["schemas"]["FlowConfig"] | null;
+            /** Language */
+            language?: string | null;
+            /** Name */
+            name?: string | null;
+        };
         /** FunctionCreate */
         FunctionCreate: {
             /**
@@ -920,7 +1261,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
@@ -981,7 +1322,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
@@ -1158,6 +1499,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;
@@ -1318,6 +1709,8 @@ interface components {
             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 */
@@ -1359,6 +1752,8 @@ interface components {
             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 */
@@ -1529,13 +1924,20 @@ interface components {
         };
         /** PronunciationEntry */
         PronunciationEntry: {
-            /** Alias */
-            alias: string;
+            /**
+             * Alias
+             * @default
+             */
+            alias?: string;
+            /** Alphabet */
+            alphabet?: ("ipa" | "cmu") | null;
             /**
              * Case Sensitive
              * @default false
              */
             case_sensitive?: boolean;
+            /** Phoneme */
+            phoneme?: string | null;
             /** Word */
             word: string;
         };
@@ -1577,6 +1979,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 */
@@ -1676,6 +2112,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 */
@@ -1758,7 +2217,7 @@ interface components {
             /** Digit Limit */
             digit_limit?: number | null;
             /** Termination Key */
-            termination_key?: ("#" | "*") | null;
+            termination_key?: ("0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "#" | "*") | null;
             /**
              * Timeout Ms
              * @default 2500
@@ -1778,21 +2237,44 @@ interface components {
             /** Error Type */
             type: string;
         };
-    };
-    responses: never;
-    parameters: never;
-    requestBodies: never;
-    headers: never;
-    pathItems: never;
-}
-
-/**
- * Request-body types, aliased from the generated OpenAPI types so they track the
- * API's own schema exactly. Field names are the API's own
+        /** 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;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+
+/**
+ * Request-body types, aliased from the generated OpenAPI types so they track the
+ * API's own schema exactly. Field names are the API's own
  * (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
@@ -1802,34 +2284,50 @@ 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"]>;
+type PhoneNumberBuyParams = RequestBody<Schemas$5["BuyNumberRequest"]>;
+/** Filters for `phoneNumbers.search`. */
+interface PhoneNumberSearchParams {
+    /** Two-letter country code. Default `"US"`. */
+    country?: string;
+    /** `"local"` (default) or `"toll_free"`. */
+    type?: string;
+    /** Three digits. Local numbers only. */
+    area_code?: string;
+    /** Digits (and `*`) the number must contain. */
+    contains?: string;
+    /** 1 to 50. Default 20. */
+    limit?: number;
+}
 /**
  * `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.
@@ -1857,6 +2355,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;
@@ -1870,7 +2373,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;
@@ -1878,8 +2396,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;
@@ -1895,6 +2432,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;
@@ -1969,6 +2508,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. */
@@ -2116,6 +2667,11 @@ 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>;
 }
 
@@ -2333,6 +2889,18 @@ declare class Calls extends APIResource {
      * 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
@@ -2381,6 +2949,23 @@ interface Voice {
     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;
@@ -2496,6 +3081,10 @@ declare class Voices extends APIResource {
      */
     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`). */
     list(params?: TemplateListParams, options?: RequestOptions): Promise<FlowTemplateSummary[]>;
@@ -2507,6 +3096,667 @@ declare class PromptTemplates extends APIResource {
     retrieve(templateId: string, options?: RequestOptions): Promise<PromptTemplate>;
 }
 
+/** What an API key was granted. The secret is never returned. */
+interface ApiKeyDetails {
+    id: string;
+    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 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;
+}
+
+/**
+ * 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;
+}
+
+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 {
+    /**
+     * 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.
+     *
+     * ```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.
  *
@@ -2547,6 +3797,59 @@ interface PhoneNumber {
     /** 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;
+}
+/** A number that can be bought, from `phoneNumbers.search`. */
+interface AvailablePhoneNumber {
+    /** E.164. Pass it to `phoneNumbers.buy`. */
+    phone_number: string;
+    friendly_name: string;
+    type: string;
+    locality: string | null;
+    region: string | null;
+    country: string;
+    voice: boolean;
+    sms: boolean;
+    mms: boolean;
+}
+interface AvailablePhoneNumbers {
+    numbers: AvailablePhoneNumber[];
+    /** The monthly rental, in 0.0001-dollar units (`monthly_price_usd * 10000`). */
+    monthly_price_units: number;
+    monthly_price_usd: number;
+}
+/** What `phoneNumbers.buy` returns: the new number, plus its monthly price. */
+type PurchasedPhoneNumber = PhoneNumber & {
+    monthly_price_units: number;
+    monthly_price_usd: number;
+};
+/** 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;
@@ -2563,6 +3866,17 @@ interface SipOutboundTrunkConfig {
 declare class PhoneNumbers extends APIResource {
     /** Register a number you own (`phone_number` in E.164) with Dialgem. */
     create(body: PhoneNumberCreateParams, options?: RequestOptions): Promise<PhoneNumber>;
+    /**
+     * Numbers that can be bought, with the monthly price. Throws `NotFoundError` (`number_purchase_disabled`) when the
+     * deployment has not switched buying on.
+     */
+    search(params?: PhoneNumberSearchParams, options?: RequestOptions): Promise<AvailablePhoneNumbers>;
+    /**
+     * Buy one of the numbers `search` returned. **Spends the organization's credit**: the first month is debited now and
+     * the rental renews monthly until the number is released. Throws on insufficient credit, or if the carrier no longer
+     * has the number; nothing is charged in either case.
+     */
+    buy(body: PhoneNumberBuyParams, options?: RequestOptions): Promise<PurchasedPhoneNumber>;
     /** Every active (not released) number in the organization, newest first. */
     list(options?: RequestOptions): Promise<PhoneNumber[]>;
     /**
@@ -2584,10 +3898,262 @@ declare class PhoneNumbers extends APIResource {
     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>;
 }
 
+/**
+ * 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)
+ *
+ * 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.
+ */
+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"
@@ -2596,7 +4162,7 @@ declare class PhoneNumbers extends APIResource {
  * 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;
+type WebhookEvent = CallStartedEvent | CallEndedEvent | CallAnalyzedEvent | TranscriptUpdatedEvent | TransferStartedEvent | TransferBridgedEvent | TransferCancelledEvent | TransferEndedEvent | ChatStartedEvent | ChatEndedEvent | ChatAnalyzedEvent;
 interface CallEventBase {
     call_id: string;
     agent_id: string;
@@ -2614,6 +4180,77 @@ interface CallEndedEvent extends CallEventBase {
 interface CallAnalyzedEvent extends CallEventBase {
     event: "call_analyzed";
 }
+interface ChatEventBase {
+    chat_id: string;
+    agent_id: string;
+    /** 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.
@@ -2640,6 +4277,12 @@ interface FunctionCallContext {
 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. */
@@ -2731,14 +4374,36 @@ declare class Dialgem {
     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.1";
+declare const VERSION = "0.1.0-beta.3";
 
-export { APIConnectionError, APIConnectionTimeoutError, APIError, APIUserAbortError, type Agent, type AgentCreateParams, type AgentDeleteResponse, type AgentFunction, AgentFunctions, AgentKnowledge, AgentMCPServers, type AgentType, type AgentUpdateParams, type AgentVersion, type AgentVersionConfig, type AgentVersionListParams, type AgentVersionListResponse, type AgentVersionMCPServer, type AgentVersionPublishParams, type AgentVersionRef, type AgentVersionSummary, AgentVersions, type AgentWeight, Agents, 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 ClientOptions, ConflictError, DEFAULT_SIGNATURE_TOLERANCE_MS, Dialgem, DialgemError, type DisconnectionReason, type ErrorBody, type ErrorIssue, type Fetch, type FetchInit, type FetchResponse, type FlowConfig, type FlowTemplate, type FlowTemplateSummary, FlowTemplates, type FunctionCallContext, type FunctionCallRequest, type FunctionCreateParams, type FunctionKind, type FunctionReorderParams, type FunctionUpdateParams, type HeadersLike, InternalServerError, type KeyValuePair, type KnowledgeDocument, type KnowledgeDocumentCreateParams, type LatencyStats, 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 VerifyOptions, type Voice, type VoiceCloneFile, type VoiceCloneParams, type VoiceDeleteResponse, type VoiceListParams, Voices, WEBHOOK_DELIVERY_HEADER, 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, type AvailablePhoneNumber, type AvailablePhoneNumbers, 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 PhoneNumberBuyParams, type PhoneNumberCreateParams, type PhoneNumberSearchParams, type PhoneNumberUpdateParams, PhoneNumbers, type PostCallAnalysisVariable, type PostCallBuiltinFields, type PromptState, type PromptTemplate, type PromptTemplateSummary, PromptTemplates, type PurchasedPhoneNumber, 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 };