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

package/dist/index.cjs

@@ -106,10 +106,10 @@ function isErrorBody(body) {
 }
 
 // src/version.ts
-var VERSION = "0.1.0-beta.1";
+var VERSION = "0.1.0-beta.3";
 
 // src/core/http.ts
-var RETRYABLE_METHODS = /* @__PURE__ */ new Set(["GET", "PATCH", "DELETE"]);
+var RETRYABLE_METHODS = /* @__PURE__ */ new Set(["GET", "PUT", "PATCH", "DELETE"]);
 var MAX_RETRY_DELAY_MS = 6e4;
 var HttpClient = class {
   baseURL;
@@ -142,6 +142,9 @@ var HttpClient = class {
   postForm(path2, form, options) {
     return this.request("POST", path2, { body: form, options });
   }
+  put(path2, body, options) {
+    return this.request("PUT", path2, { body, options });
+  }
   patch(path2, body, options) {
     return this.request("PATCH", path2, { body, options });
   }
@@ -444,6 +447,13 @@ var AgentMCPServers = class extends APIResource {
     return this._client.delete(path`/v1/agents/${agentId}/mcp-servers/${serverId}`, options);
   }
   /** 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, serverId, options) {
+    return this._client.get(path`/v1/agents/${agentId}/mcp-servers/${serverId}/tools`, void 0, options);
+  }
   test(agentId, serverId, options) {
     return this._client.post(path`/v1/agents/${agentId}/mcp-servers/${serverId}/test`, void 0, options);
   }
@@ -535,6 +545,20 @@ var Calls = class extends APIResource {
   delete(callId, options) {
     return this._client.delete(path`/v1/calls/${callId}`, options);
   }
+  /**
+   * 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, options) {
+    return this._client.post(path`/v1/calls/${callId}/rerun-analysis`, void 0, options);
+  }
   /**
    * 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
@@ -631,6 +655,12 @@ var Voices = class extends APIResource {
     return this._client.delete(path`/v1/voices/${voiceId}`, options);
   }
 };
+var ExtractionModels = class extends APIResource {
+  /** Models an agent may use for post-call analysis, with an estimated cost per session. */
+  list(options) {
+    return this._client.get("/v1/models/extraction", void 0, options);
+  }
+};
 var FlowTemplates = class extends APIResource {
   /** Built-in conversation-flow templates (summaries, without `flow_config`). */
   list(params = {}, options) {
@@ -650,12 +680,308 @@ var PromptTemplates = class extends APIResource {
   }
 };
 
+// src/resources/account.ts
+var ApiKey = class 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) {
+    return this._client.get("/v1/api-key-info", void 0, options);
+  }
+};
+var Sessions = class 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) {
+    return this._client.get("/v1/agent/sessions", void 0, options);
+  }
+  /**
+   * 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, body, options) {
+    return this._client.patch(path`/v1/agent/sessions/${sessionId}`, body, options);
+  }
+  /**
+   * 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, body, options) {
+    return this._client.post(path`/v1/agent/sessions/${sessionId}/say`, body, options);
+  }
+  /**
+   * 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, options) {
+    return this._client.post(path`/v1/agent/sessions/${sessionId}/release`, void 0, options);
+  }
+};
+
+// src/resources/simulations.ts
+var Simulations = class extends APIResource {
+  /** Make a suite for one of your agents. */
+  createSuite(body, options) {
+    return this._client.post("/v1/simulations/suites", body, options);
+  }
+  /** Your suites, newest first, each with its latest run. Pass `agent_id` for one agent's. */
+  listSuites(params = {}, options) {
+    return this._client.get("/v1/simulations/suites", params, options);
+  }
+  /** One suite with its cases. */
+  retrieveSuite(suiteId, options) {
+    return this._client.get(path`/v1/simulations/suites/${suiteId}`, void 0, options);
+  }
+  /**
+   * 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, body, options) {
+    return this._client.patch(path`/v1/simulations/suites/${suiteId}`, body, options);
+  }
+  /** Delete a suite and its cases. Past runs are deleted with it. */
+  deleteSuite(suiteId, options) {
+    return this._client.delete(path`/v1/simulations/suites/${suiteId}`, options);
+  }
+  /** Add a case (up to 50 per suite). 422 `invalid_case` says what to fix. */
+  createCase(suiteId, body, options) {
+    return this._client.post(path`/v1/simulations/suites/${suiteId}/cases`, body, options);
+  }
+  /** Change a case. Fields you leave out keep their value. */
+  updateCase(caseId, body, options) {
+    return this._client.patch(path`/v1/simulations/cases/${caseId}`, body, options);
+  }
+  deleteCase(caseId, options) {
+    return this._client.delete(path`/v1/simulations/cases/${caseId}`, options);
+  }
+  /**
+   * 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, body = {}, options) {
+    return this._client.post(path`/v1/simulations/suites/${suiteId}/runs`, body, options);
+  }
+  /** Runs, newest first. Pass `suite_id` for one suite's. */
+  listRuns(params = {}, options) {
+    return this._client.get("/v1/simulations/runs", params, options);
+  }
+  /** A run with every case's transcript, tool calls and check results. */
+  retrieveRun(runId, options) {
+    return this._client.get(path`/v1/simulations/runs/${runId}`, void 0, options);
+  }
+  /** Stop a run that has not finished. Cases already under way finish; the rest are skipped. */
+  cancelRun(runId, options) {
+    return this._client.post(path`/v1/simulations/runs/${runId}/cancel`, void 0, options);
+  }
+};
+
+// src/resources/web-calls.ts
+var WebCalls = class 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, options) {
+    return this._client.post("/v1/calls/web", body, options);
+  }
+  /** The origins browser calls may start from, and the limits that apply. */
+  retrieveSettings(options) {
+    return this._client.get("/v1/web-calls/settings", void 0, options);
+  }
+  /**
+   * 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, options) {
+    return this._client.put("/v1/web-calls/settings", body, options);
+  }
+};
+
+// src/resources/contacts.ts
+var Contacts = class extends APIResource {
+  /** Bulk import from CSV, with a dry-run preview. */
+  imports;
+  constructor(client) {
+    super(client);
+    this.imports = new ContactImports(client);
+  }
+  /**
+   * 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, options) {
+    return this._client.post("/v1/contacts", body, options);
+  }
+  /**
+   * Contacts, newest first. Await for one page, or iterate for every contact:
+   *
+   */
+  list(params = {}, options) {
+    const fetchPage = async (cursor) => {
+      const res = await this._client.get(
+        "/v1/contacts",
+        { ...params, cursor: cursor ?? void 0 },
+        options
+      );
+      return { data: res.contacts, has_more: res.next_cursor !== null, pagination_key: res.next_cursor };
+    };
+    return new PagePromise(fetchPage);
+  }
+  /**
+   * 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, params = {}, options) {
+    return this._client.get(path`/v1/contacts/by-phone/${phone}`, params, options);
+  }
+  /** One contact, with its lists and how many calls it has had. */
+  retrieve(contactId, options) {
+    return this._client.get(path`/v1/contacts/${contactId}`, void 0, options);
+  }
+  /**
+   * 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, body, options) {
+    return this._client.patch(path`/v1/contacts/${contactId}`, body, options);
+  }
+  /**
+   * 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, options) {
+    return this._client.delete(path`/v1/contacts/${contactId}`, options);
+  }
+  /** Calls to or from the contact's number, newest first. Summaries, not transcripts. */
+  calls(contactId, params = {}, options) {
+    return this._client.get(path`/v1/contacts/${contactId}/calls`, params, options);
+  }
+};
+var ContactImports = class extends APIResource {
+  /** The file's headers, a guessed column mapping and a few rows. Imports nothing. */
+  inspect(csv, options) {
+    return this._client.post("/v1/contacts/imports/inspect", { csv }, options);
+  }
+  /**
+   * 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, options) {
+    return this._client.post("/v1/contacts/imports", body, options);
+  }
+  /** Recent imports, newest first. */
+  list(options) {
+    return this._client.get("/v1/contacts/imports", void 0, options);
+  }
+  /** Progress and counts. */
+  retrieve(importId, options) {
+    return this._client.get(path`/v1/contacts/imports/${importId}`, void 0, options);
+  }
+  /** The rows that were rejected, with the line, the reason and what each held. */
+  errors(importId, params = {}, options) {
+    return this._client.get(path`/v1/contacts/imports/${importId}/errors`, params, options);
+  }
+  /** Apply a previewed import: the file is read again, so what is applied is what was previewed. */
+  commit(importId, options) {
+    return this._client.post(path`/v1/contacts/imports/${importId}/commit`, void 0, options);
+  }
+  /** Stop an import that has not finished. Contacts a running import already wrote stay. */
+  cancel(importId, options) {
+    return this._client.delete(path`/v1/contacts/imports/${importId}`, options);
+  }
+};
+var ContactLists = class extends APIResource {
+  list(options) {
+    return this._client.get("/v1/contact-lists", void 0, options);
+  }
+  /** Names are unique within your organization, ignoring case. */
+  create(body, options) {
+    return this._client.post("/v1/contact-lists", body, options);
+  }
+  retrieve(listId, options) {
+    return this._client.get(path`/v1/contact-lists/${listId}`, void 0, options);
+  }
+  update(listId, body, options) {
+    return this._client.patch(path`/v1/contact-lists/${listId}`, body, options);
+  }
+  delete(listId, options) {
+    return this._client.delete(path`/v1/contact-lists/${listId}`, options);
+  }
+  /** Add up to 1000 of your contacts. Already-members are ignored; `added` says how many were new. */
+  addContacts(listId, contactIds, options) {
+    return this._client.post(path`/v1/contact-lists/${listId}/members`, { contact_ids: contactIds }, options);
+  }
+  removeContact(listId, contactId, options) {
+    return this._client.delete(path`/v1/contact-lists/${listId}/members/${contactId}`, options);
+  }
+};
+
 // src/resources/phone-numbers.ts
 var PhoneNumbers = class extends APIResource {
   /** Register a number you own (`phone_number` in E.164) with Dialgem. */
   create(body, options) {
     return this._client.post("/v1/phone-numbers", body, options);
   }
+  /**
+   * Numbers that can be bought, with the monthly price. Throws `NotFoundError` (`number_purchase_disabled`) when the
+   * deployment has not switched buying on.
+   */
+  search(params, options) {
+    return this._client.get("/v1/phone-numbers/available", { ...params }, options);
+  }
+  /**
+   * 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, options) {
+    return this._client.post("/v1/phone-numbers/buy", body, options);
+  }
   /** Every active (not released) number in the organization, newest first. */
   list(options) {
     return this._client.get("/v1/phone-numbers", void 0, options);
@@ -689,15 +1015,159 @@ var PhoneNumbers = class extends APIResource {
   assign(phoneNumberId, body, options) {
     return this._client.patch(path`/v1/phone-numbers/${phoneNumberId}/assign`, body, options);
   }
+  /**
+   * 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, options) {
+    return this._client.post(path`/v1/phone-numbers/${phoneNumberId}/inbound-webhook/test`, void 0, options);
+  }
+  /**
+   * 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, options) {
+    return this._client.post(path`/v1/phone-numbers/${phoneNumberId}/inbound-webhook/rotate-secret`, void 0, options);
+  }
   /** Release the number from Dialgem. It stops routing calls and disappears from `list()`; your carrier account is untouched. */
   delete(phoneNumberId, options) {
     return this._client.delete(path`/v1/phone-numbers/${phoneNumberId}`, options);
   }
 };
 
+// src/resources/chats.ts
+var Chats = class 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, options) {
+    return this._client.post("/v1/chats", body, options);
+  }
+  /**
+   * Chats, newest first. Await for one page, or iterate for every chat. Entries leave out `messages`;
+   * `retrieve` a chat for them.
+   */
+  list(params = {}, options) {
+    const fetchPage = async (paginationKey) => {
+      const res = await this._client.get(
+        "/v1/chats",
+        { ...params, pagination_key: paginationKey ?? void 0 },
+        options
+      );
+      return { data: res.chats, has_more: res.has_more, pagination_key: res.pagination_key };
+    };
+    return new PagePromise(fetchPage);
+  }
+  /** One chat with all its messages. */
+  retrieve(chatId, options) {
+    return this._client.get(path`/v1/chats/${chatId}`, void 0, options);
+  }
+  /** Replace the chat's `metadata` (the whole object). */
+  update(chatId, body, options) {
+    return this._client.patch(path`/v1/chats/${chatId}`, body, options);
+  }
+  /** Delete a chat and its messages. */
+  delete(chatId, options) {
+    return this._client.delete(path`/v1/chats/${chatId}`, options);
+  }
+  /**
+   * 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, content, options) {
+    return this._client.post(path`/v1/chats/${chatId}/messages`, { content }, options);
+  }
+  /** End the chat. Ending twice is fine. The analysis arrives a moment later; read it with `retrieve`. */
+  end(chatId, options) {
+    return this._client.post(path`/v1/chats/${chatId}/end`, void 0, options);
+  }
+  /**
+   * 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, options) {
+    return this._client.post(path`/v1/chats/${chatId}/rerun-analysis`, void 0, options);
+  }
+};
+
+// src/resources/flows.ts
+var Flows = class extends APIResource {
+  /** Validate and save a flow. `UnprocessableEntityError` (`errCode` `flow_invalid`) lists every problem. Not retried by default. */
+  create(body, options) {
+    return this._client.post("/v1/flows", body, options);
+  }
+  /** Flows, newest first. Await for one page, or iterate for every flow. Entries leave out `flow_config`. */
+  list(params = {}, options) {
+    const fetchPage = async (paginationKey) => {
+      const res = await this._client.get(
+        "/v1/flows",
+        { ...params, pagination_key: paginationKey ?? void 0 },
+        options
+      );
+      return { data: res.flows, has_more: res.has_more, pagination_key: res.pagination_key };
+    };
+    return new PagePromise(fetchPage);
+  }
+  /** One flow with its `flow_config`. */
+  retrieve(flowId, options) {
+    return this._client.get(path`/v1/flows/${flowId}`, void 0, options);
+  }
+  /** Rename a flow and/or replace its `flow_config` (checked again). Agents it was attached to are not changed. */
+  update(flowId, body, options) {
+    return this._client.patch(path`/v1/flows/${flowId}`, body, options);
+  }
+  /** Delete a saved flow. Agents it was attached to keep their copy. */
+  delete(flowId, options) {
+    return this._client.delete(path`/v1/flows/${flowId}`, options);
+  }
+};
+
+// src/resources/llms.ts
+var LLMs = class extends APIResource {
+  /** Save LLM settings. Anything left out takes the default a new agent gets. Not retried by default. */
+  create(body, options) {
+    return this._client.post("/v1/llms", body, options);
+  }
+  /** Saved LLMs, newest first. Await for one page, or iterate for every one. */
+  list(params = {}, options) {
+    const fetchPage = async (paginationKey) => {
+      const res = await this._client.get(
+        "/v1/llms",
+        { ...params, pagination_key: paginationKey ?? void 0 },
+        options
+      );
+      return { data: res.llms, has_more: res.has_more, pagination_key: res.pagination_key };
+    };
+    return new PagePromise(fetchPage);
+  }
+  retrieve(llmId, options) {
+    return this._client.get(path`/v1/llms/${llmId}`, void 0, options);
+  }
+  /** Change the fields you send. Agents it was attached to are not changed. */
+  update(llmId, body, options) {
+    return this._client.patch(path`/v1/llms/${llmId}`, body, options);
+  }
+  /** Delete saved LLM settings. Agents they were attached to keep their copy. */
+  delete(llmId, options) {
+    return this._client.delete(path`/v1/llms/${llmId}`, options);
+  }
+};
+
 // src/webhooks.ts
 var WEBHOOK_SIGNATURE_HEADER = "x-dialgem-signature";
 var WEBHOOK_EVENT_HEADER = "x-dialgem-event";
+var WEBHOOK_PREVIOUS_SIGNATURE_HEADER = "x-dialgem-signature-previous";
 var WEBHOOK_DELIVERY_HEADER = "x-dialgem-delivery";
 var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1e3;
 var encoder = new TextEncoder();
@@ -816,9 +1286,31 @@ var Dialgem = class {
   calls;
   phoneNumbers;
   voices;
+  /** Models available for post-call analysis. */
+  extractionModels;
   flowTemplates;
   promptTemplates;
+  /** Calls in progress right now. */
+  sessions;
+  /** Text conversations with an agent. */
+  chats;
+  flows;
+  llms;
+  /** What this API key is and may do. */
+  apiKey;
+  /**
+   * Verify what Dialgem sends you: `dialgem.webhooks.constructEvent(rawBody, signatureHeader, secret)`.
+   */
   webhooks = webhooks;
+  /** The organization's webhook destinations: create, update, rotate the signing secret, test. */
+  /** The people you call, with CSV import under `contacts.imports`. */
+  contacts;
+  /** Named groups of contacts. */
+  contactLists;
+  /** Browser calls: tokens for `@dialgem/client`, and the origins allowed to start them. */
+  webCalls;
+  /** Saved test conversations for an agent, run in text, with an optional publish gate. */
+  simulations;
   /** Always `https://api.dialgem.com`. */
   baseURL = BASE_URL;
   constructor(options = {}) {
@@ -855,8 +1347,18 @@ var Dialgem = class {
     this.calls = new Calls(http);
     this.phoneNumbers = new PhoneNumbers(http);
     this.voices = new Voices(http);
+    this.extractionModels = new ExtractionModels(http);
     this.flowTemplates = new FlowTemplates(http);
     this.promptTemplates = new PromptTemplates(http);
+    this.sessions = new Sessions(http);
+    this.chats = new Chats(http);
+    this.flows = new Flows(http);
+    this.llms = new LLMs(http);
+    this.apiKey = new ApiKey(http);
+    this.contacts = new Contacts(http);
+    this.contactLists = new ContactLists(http);
+    this.webCalls = new WebCalls(http);
+    this.simulations = new Simulations(http);
   }
 };
 function readEnv(name) {
@@ -897,6 +1399,7 @@ exports.UnprocessableEntityError = UnprocessableEntityError;
 exports.VERSION = VERSION;
 exports.WEBHOOK_DELIVERY_HEADER = WEBHOOK_DELIVERY_HEADER;
 exports.WEBHOOK_EVENT_HEADER = WEBHOOK_EVENT_HEADER;
+exports.WEBHOOK_PREVIOUS_SIGNATURE_HEADER = WEBHOOK_PREVIOUS_SIGNATURE_HEADER;
 exports.WEBHOOK_SIGNATURE_HEADER = WEBHOOK_SIGNATURE_HEADER;
 exports.WebhookVerificationError = WebhookVerificationError;
 exports.Webhooks = Webhooks;