@talqing/sdk 0.1.0

package/dist/gen/sdk.gen.js

@@ -0,0 +1,4320 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { client } from './client.gen.js';
+import { buildClientParams } from './client/index.js';
+class HeyApiClient {
+    constructor(args) {
+        this.client = args?.client ?? client;
+    }
+}
+class HeyApiRegistry {
+    constructor() {
+        this.defaultKey = 'default';
+        this.instances = new Map();
+    }
+    get(key) {
+        const instance = this.instances.get(key ?? this.defaultKey);
+        if (!instance) {
+            throw new Error(`No SDK client found. Create one with "new TalqingApi()" to fix this error.`);
+        }
+        return instance;
+    }
+    set(value, key) {
+        this.instances.set(key ?? this.defaultKey, value);
+    }
+}
+export class Versions extends HeyApiClient {
+    /**
+     * Get Agent Version
+     *
+     * Fetch what one published version of an agent actually contains.
+     *
+     * `get_agent` lists the versions and when each was published; this returns the
+     * frozen definition itself — prompt, models, turn handling and the tool
+     * versions it pinned, exactly as they were at that publish. Use it to see what
+     * changed between two versions, or between a version and the current draft.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }, { in: 'path', key: 'version' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents/{agent_id}/versions/{version}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Rollback Agent Version
+     *
+     * Put an earlier published version of an agent back into production.
+     *
+     * That version becomes live **immediately** and **replaces the current draft**,
+     * so any unpublished edits are lost. Calls already in progress finish on the
+     * version they started.
+     *
+     * No new version is created: `published_version` simply points at the older
+     * one. The restored draft tracks each tool's latest published version, not the
+     * ones this version pinned.
+     */
+    rollback(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }, { in: 'path', key: 'version' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents/{agent_id}/versions/{version}/rollback',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Agents extends HeyApiClient {
+    /**
+     * List Agents
+     *
+     * List the workspace's agents, newest edit first.
+     *
+     * Each item carries the full draft config and the published version number
+     * (null while the agent has never been published).
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Agent
+     *
+     * Create an agent from a complete config.
+     *
+     * The config is validated the same way an update is, so unknown models or
+     * unpublished tool references are rejected here. Names are unique per
+     * workspace. The agent starts unpublished.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createAgentRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Agent
+     *
+     * Delete an agent and its published versions permanently.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents/{agent_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Agent
+     *
+     * Fetch one agent's draft config, published version and publish history.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents/{agent_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Update Agent
+     *
+     * Replace the agent's draft config with the one supplied.
+     *
+     * `config` is the complete definition, not a partial patch: whatever it omits
+     * reverts to that field's default. Writes land on the draft only — live
+     * traffic keeps running the published version until you publish again.
+     *
+     * Switching `channel` normalizes the media stack: text agents drop stt, tts,
+     * realtime, greeting, turn handling and avatar.
+     *
+     * Setting `realtime` to a speech-to-speech model makes it the whole pipeline —
+     * `stt`, `llm` and `tts` are cleared and it handles turn detection itself.
+     * Realtime agents have no fallback model, cannot use the 'after each user
+     * turn' hook, and only approximate a fixed greeting.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }, { key: 'updateAgentRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents/{agent_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Publish Agent
+     *
+     * Freeze the current draft as a new immutable version and make it live.
+     *
+     * Validation must pass. Publishing pins every attached tool (and lifecycle
+     * hook) to the tool version that is live right now, so republishing a tool does
+     * not change this agent's behaviour until the agent is published again.
+     */
+    publish(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents/{agent_id}/publish',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Validate Agent
+     *
+     * Run publish-grade validation on the draft without publishing it.
+     *
+     * Covers everything a draft write checks plus the deeper checks publishing
+     * adds: a workspace API key for every provider the agent needs, and the
+     * operation trees of attached and hook tools. Returns errors (blocking) and
+     * warnings (advisory).
+     */
+    validate(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/agents/{agent_id}/validate',
+            ...options,
+            ...params
+        });
+    }
+    get versions() {
+        return this._versions ?? (this._versions = new Versions({ client: this.client }));
+    }
+}
+export class Auth extends HeyApiClient {
+    /**
+     * Logout
+     */
+    logout(options) {
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            url: '/v1/auth/logout',
+            ...options
+        });
+    }
+    /**
+     * Me
+     *
+     * Who this credential is: the signed-in user, their role, and the organization.
+     *
+     * Everything else you can reach is scoped to that organization, and `role`
+     * (`ADMIN`, `EDITOR` or `VIEWER`) decides whether writes will be accepted. A
+     * user may belong to several organizations with a different role in each; this
+     * reports the one this credential is for.
+     */
+    me(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/auth/me',
+            ...options
+        });
+    }
+}
+export class ProviderKeys extends HeyApiClient {
+    /**
+     * List Provider Keys
+     *
+     * List every AI provider and whether this workspace has an API key for it.
+     *
+     * Talqing is strict BYOK: agents run on the workspace's own provider keys.
+     * Publishing fails if the agent needs a provider with no key configured.
+     * Every key listed here was accepted by its provider when it was saved.
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/byok',
+            ...options
+        });
+    }
+    /**
+     * Delete Provider Key
+     *
+     * Remove this organization's API key for one provider. Agents that need it
+     * will stop working and can no longer be published. Organization admins only.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'provider' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/byok/{provider}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Set Provider Key
+     *
+     * Store this workspace's API key for one provider, replacing any existing key.
+     *
+     * The key is called against the provider first and only stored if accepted: a
+     * rejected key is a 400 that leaves any existing key untouched, and a provider
+     * that cannot be reached is a 502. Encrypted at rest and never returned.
+     * Organization admins only.
+     */
+    set(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'provider' }, { key: 'setProviderKeyRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/byok/{provider}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Analysis extends HeyApiClient {
+    /**
+     * Backfill Call Analysis
+     *
+     * Re-analyse past calls with each one's current agent definition.
+     *
+     * Use this after changing what an agent extracts, to fill in calls that ran
+     * under the old definition — and to retry calls whose analysis failed.
+     *
+     * Each call is analysed by a real model call and re-priced, so the tenant is
+     * charged again for every call in the list. Try the definition on one call
+     * with `preview_call_analysis` first.
+     */
+    backfill(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'backfillAnalysisRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/analysis/backfill',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Preview Call Analysis
+     *
+     * Try an analysis definition against one past call and see what it finds.
+     *
+     * Nothing is saved, which makes this the way to tune a summary prompt, a
+     * success definition or an extraction field before putting it on the agent.
+     * The call is analysed against the agent definition it actually ran. Costs one
+     * model call.
+     */
+    preview(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'session_id' }, { key: 'previewAnalysisRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/{session_id}/analysis/preview',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Recipients extends HeyApiClient {
+    /**
+     * List Call Batch Recipients
+     *
+     * One batch's recipients and how each call went, in the uploaded order.
+     *
+     * `session_id` is that person's most recent call — pass it to `get_call` for
+     * the transcript, recording and cost, and `last_close_reason` says exactly how
+     * the attempt ended. A recipient of a cancelled batch reads as `canceled` even
+     * though their row was never touched.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'batch_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'status' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches/{batch_id}/recipients',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Add Call Batch Recipients
+     *
+     * Append people to a batch, including one that is already running.
+     *
+     * Numbers the batch already holds are **skipped and reported**, not rejected —
+     * re-uploading a list exported from a CRM is the normal case, and nobody
+     * already called is called again. The new rows are dialled after the existing
+     * ones.
+     */
+    add(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'addRecipientsRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches/{batch_id}/recipients',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Batches extends HeyApiClient {
+    /**
+     * List Call Batches
+     *
+     * List outbound calling batches, newest first, with live progress.
+     *
+     * `counts` breaks the recipient list down by outcome and `next_dial_at` says
+     * when a batch that is not dialling will start again — the clock, not a fault.
+     * A `failed` batch carries `failure_reason`: the circuit breaker stopped it
+     * after ten consecutive setup failures.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'status' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Call Batch
+     *
+     * Call a list of people with a published agent, now or on a schedule.
+     *
+     * **This places real, billable PSTN calls** — one per recipient, up to 10 000
+     * of them. Only call it when the user has asked for this specific list to be
+     * dialled.
+     *
+     * `recipients[]` carries `to` (any format, normalized to E.164) and
+     * `userdata`, the session state behind `{{userdata.field}}` in the prompt and
+     * greeting. A number that appears twice is refused with both row numbers.
+     *
+     * `start_at` and `calling_window` schedule it in the timezone you give;
+     * `max_concurrency` and `max_attempts` pace it. A number that was reached is
+     * never called twice.
+     *
+     * Two things you would otherwise learn from an invoice:
+     *
+     * - **Answering machines are not detected.** Voicemail is answered and billed.
+     * - **Calls run your agent's current published version.** Republishing changes
+     * every call placed after that moment.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createCallBatchRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Get Call Batch
+     *
+     * One batch: its policy, its progress, and why it is or is not dialling.
+     *
+     * `agent_name` and `from_e164` are read live, so a renamed agent shows its
+     * current name and a deleted one shows null.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches/{batch_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Call Batch
+     *
+     * Change a batch's policy while it runs. The next pass picks it up.
+     *
+     * Everything here is policy, so nothing revisits a recipient already called,
+     * and calls in flight finish under the policy they were dispatched with. You
+     * do not need this to pick up a republished prompt — every call already runs
+     * the current published version. `start_at` moves only while the batch is
+     * still `scheduled`.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'patchCallBatchRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches/{batch_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Cancel Call Batch
+     *
+     * Stop a batch for good. There is no undo, and a batch cannot be deleted.
+     *
+     * Everyone not yet called immediately reads as `canceled`. Calls already
+     * ringing or in progress are **not** dropped — they run to their natural end,
+     * and the batch is only finished once they have.
+     */
+    cancel(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches/{batch_id}/cancel',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Pause Call Batch
+     *
+     * Stop placing new calls. Calls already in progress run to their end.
+     */
+    pause(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches/{batch_id}/pause',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Resume Call Batch
+     *
+     * Undo a pause and carry on from where the batch stopped.
+     *
+     * A batch whose `start_at` is still in the future goes back to `scheduled`
+     * rather than starting early.
+     */
+    resume(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/batches/{batch_id}/resume',
+            ...options,
+            ...params
+        });
+    }
+    get recipients() {
+        return this._recipients ?? (this._recipients = new Recipients({ client: this.client }));
+    }
+}
+export class Recording extends HeyApiClient {
+    /**
+     * Delete Call Recording
+     *
+     * Delete the call's recorded media, keeping the call itself.
+     *
+     * Both the audio and, where the agent watched one, the screen video. The
+     * transcript, cost and everything else about the call stay exactly as they are.
+     * This is immediate and cannot be undone. Deleting a recording that is already
+     * gone succeeds quietly.
+     *
+     * Deliberately synchronous, unlike `delete_call`: this destroys one or two
+     * objects and returns, where deleting a call schedules a redaction across
+     * several tables.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'session_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/{session_id}/recording',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Call Recording
+     *
+     * Redirect to the call's audio: one stereo Ogg/Opus file.
+     *
+     * The redirect goes to object storage and expires within the hour, so follow
+     * it straight away rather than storing it. It supports `Range`, which is what
+     * lets a player seek without downloading the whole call first. Pass
+     * `download=true` for a link that saves as `call-{id}.ogg`.
+     *
+     * The caller is the left channel and the agent is the right, so you can listen
+     * to either side alone by splitting the channels — one `ffmpeg -map_channel`
+     * away, and what makes the file useful both for hearing the call and for
+     * building training data. It is what the agent heard after noise cancellation,
+     * not a capture of the phone line, and it does not include background audio,
+     * which the agent publishes as its own track.
+     *
+     * A `404` here means there is nothing to play, and its message says why — the
+     * agent had recording off, the call is still running, the recording was
+     * deleted by a person or by your retention policy, the caller asked not to be
+     * recorded, or it failed to save. Check `recording.state` on the call first to
+     * know which without a round trip; `get_call` also returns ready-made
+     * `recording.url` and `recording.download_url` links.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'session_id' }, { in: 'query', key: 'download' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/{session_id}/recording',
+            ...options,
+            ...params
+        });
+    }
+}
+export class ScreenRecording extends HeyApiClient {
+    /**
+     * Get Call Screen Recording
+     *
+     * Redirect to the screen the person shared: one 1 fps H.264 file.
+     *
+     * Only agents with `vision_input.screenshare.record` produce one. It covers the
+     * whole call rather than only the shared stretches — the parts where nobody was
+     * sharing are black — so its timeline lines up with the audio and the
+     * transcript second for second, and a turn's offset into it is the same
+     * arithmetic as into the recording.
+     *
+     * Like the audio, the redirect goes to object storage, expires within the hour
+     * and supports `Range`. A `404` says why there is nothing to play, and
+     * `screen_recording.state` on the call answers the same question without a
+     * round trip — including `not_shared`, which means screen recording was on and
+     * nobody ever shared, as opposed to `none`, which means it was off.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'session_id' }, { in: 'query', key: 'download' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/{session_id}/screen-recording',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Calls extends HeyApiClient {
+    /**
+     * List Calls
+     *
+     * List voice and video calls, newest first, with status, duration and cost.
+     *
+     * The window defaults to the last 30 days. Filter by `agent_id`, by `type` to
+     * separate web calls from phone calls, by `contact_key` for one customer's
+     * whole history, or by `batch_id` for every call one outbound batch placed.
+     * Text conversations are not calls — those live under `list_conversations`.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'start' },
+                    { in: 'query', key: 'end' },
+                    { in: 'query', key: 'agent_id' },
+                    { in: 'query', key: 'type' },
+                    { in: 'query', key: 'status' },
+                    { in: 'query', key: 'outcome' },
+                    { in: 'query', key: 'contact_key' },
+                    { in: 'query', key: 'close_reason' },
+                    { in: 'query', key: 'batch_id' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Outbound Call
+     *
+     * Dial a real phone number and have a published agent take the call.
+     *
+     * **This places a live, billable PSTN call** — only call it when the user has
+     * asked for this specific call to be made. The agent must be published and on
+     * the `voice` channel, and `from_phone_number_id` an active outbound-capable
+     * number on a ready carrier account.
+     *
+     * `userdata` seeds the session state read as `{{userdata.field}}`; keys
+     * beginning with `_talqing` are reserved. Prefer `agent_id`; reach for
+     * `agent_override`, `agent` or `agent_team` only when the definition is
+     * generated per request and would never be reused.
+     *
+     * It returns when the call is placed, not when it is answered.
+     */
+    outbound(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'outboundCallRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/outbound',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Call Stats
+     *
+     * Totals for a window: call count, minutes, spend and average cost.
+     *
+     * Spend and `avg_cost_per_call` count only priced calls (`priced_calls`), so
+     * a call still being priced does not drag the average down. The window
+     * defaults to the last 30 days.
+     */
+    stats(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'start' },
+                    { in: 'query', key: 'end' },
+                    { in: 'query', key: 'agent_id' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/stats',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Calls Token
+     *
+     * Mint a LiveKit token for a browser to open a web call with an agent.
+     *
+     * `userdata` seeds the session state read as `{{userdata.field}}`; keys
+     * beginning with `_talqing` are reserved. Prefer `agent_id`; reach for
+     * `agent_override`, `agent` or `agent_team` only when the definition is
+     * generated per request and would never be reused.
+     *
+     * Needs the editor role — these fields run an arbitrary prompt on an arbitrary
+     * model, paid for with the workspace's own provider keys.
+     *
+     * The token only lets a browser connect. To dial a phone, use
+     * `create_outbound_call`.
+     */
+    token(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'tokenRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/token',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Call
+     *
+     * Erase this call's content. The call itself stays, with its cost.
+     *
+     * What goes: the recording, the transcript, every tool call and its output,
+     * the session's userdata, the summary, the extracted fields, and the phone
+     * numbers on the call. What stays: the call, its duration, status, outcome,
+     * per-turn timings and everything it was billed — so past invoices still
+     * resolve.
+     *
+     * Erasing a person's last remaining call also erases what your agents
+     * remember about them, so the next call from that number meets an agent that
+     * has never heard of them.
+     *
+     * Returns `202`: the work is scheduled rather than done, which is what stops a
+     * request to erase two hundred thousand calls arriving as two hundred thousand
+     * synchronous deletes. It normally completes within seconds. This cannot be
+     * undone.
+     *
+     * A call that is still in progress is refused with a `409` — it is still
+     * writing, and finalize would put the content back on a row already marked
+     * erased. Ask again once it has ended.
+     *
+     * To delete only the audio and keep the transcript, use
+     * `delete_call_recording` instead — that one is immediate.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'session_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/{session_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Call
+     *
+     * Everything about one call: health, transcript, tool calls, usage, cost.
+     *
+     * Start with `snapshot`: it answers "did this call go well?" on its own —
+     * `snapshot.issues` names every problem found and `snapshot.ok` is true when
+     * there were none.
+     *
+     * `transcript` carries what was said with every function call and its output,
+     * and `session.userdata` is the state the call ended with. `tools`,
+     * `starting_prompt` and `greeting` are the frozen version this call actually
+     * ran, not the agent's current draft.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'session_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/calls/{session_id}',
+            ...options,
+            ...params
+        });
+    }
+    get analysis() {
+        return this._analysis ?? (this._analysis = new Analysis({ client: this.client }));
+    }
+    get batches() {
+        return this._batches ?? (this._batches = new Batches({ client: this.client }));
+    }
+    get recording() {
+        return this._recording ?? (this._recording = new Recording({ client: this.client }));
+    }
+    get screenRecording() {
+        return this._screenRecording ?? (this._screenRecording = new ScreenRecording({ client: this.client }));
+    }
+}
+export class Avatars extends HeyApiClient {
+    /**
+     * Catalog Avatars
+     *
+     * The Anam avatar gallery — the faces a video agent can wear.
+     *
+     * An avatar's `id` is what a video agent's `avatar.avatar_id` refers to.
+     * `active_version` and `render_style` are gallery facets, not billing models —
+     * an agent's `avatar.model` always comes from the provider catalog.
+     *
+     * Shows your own Anam account when you have a key for it and Talqing's
+     * otherwise; `workspace_key` says which.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'active_version' },
+                    { in: 'query', key: 'render_style' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'limit' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/catalog/avatars',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Elevenlabs extends HeyApiClient {
+    /**
+     * Add Elevenlabs Voice
+     *
+     * Save a shared ElevenLabs library voice so agents can use it.
+     *
+     * Takes the `voice_id` and `owner_id` of a shared voice and returns the id to
+     * set as an agent's `tts.voice`. Saved into your workspace's own ElevenLabs
+     * account when you have a key for it. Voices already in that account come back
+     * from `catalog_voices` with no `owner_id` and need no save at all.
+     */
+    add(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'addVoiceRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/catalog/voices/elevenlabs/add',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Elevenlabs Voice Settings
+     *
+     * The `stability` and `similarity_boost` an ElevenLabs voice was tuned with.
+     *
+     * Copy these onto an agent's `tts` when you set its `voice`: ElevenLabs
+     * applies a voice's own settings only when a request carries no overrides at
+     * all, and Talqing always sends a speed — so an agent without these numbers
+     * speaks in the generic default rather than the voice its author shipped.
+     *
+     * A shared-library voice must be saved by `add_elevenlabs_voice` first; call
+     * this with the id THAT returned.
+     */
+    settings(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'voice_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/catalog/voices/elevenlabs/{voice_id}/settings',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Voices extends HeyApiClient {
+    /**
+     * Catalog Voices
+     *
+     * Browse and filter the voices available for one provider.
+     *
+     * A voice's `id` is what an agent's `tts.voice` refers to, or `realtime.voice`
+     * when `kind` is `realtime` — speech-to-speech models pick from their own
+     * roster. Use this before choosing a voice by style, accent or gender rather
+     * than assuming an id exists.
+     *
+     * With a workspace key saved for the provider the listing runs on that key and
+     * leads with your own account's voices; `workspace_key` says whether it did.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'provider' },
+                    { in: 'query', key: 'model' },
+                    { in: 'query', key: 'kind' },
+                    { in: 'query', key: 'search' },
+                    { in: 'query', key: 'language' },
+                    { in: 'query', key: 'accent' },
+                    { in: 'query', key: 'gender' },
+                    { in: 'query', key: 'page' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/catalog/voices',
+            ...options,
+            ...params
+        });
+    }
+    get elevenlabs() {
+        return this._elevenlabs ?? (this._elevenlabs = new Elevenlabs({ client: this.client }));
+    }
+}
+export class Catalog extends HeyApiClient {
+    /**
+     * Get Catalog
+     *
+     * The provider catalog: every LLM, STT, TTS, realtime and avatar model that
+     * agents may use.
+     *
+     * The authoritative source for `provider`/`model` pairs and for what each
+     * entry supports — channels, language codes, speed range, default voice. A
+     * config naming anything not listed here is rejected.
+     *
+     * `realtime` lists the speech-to-speech models. One of those replaces `stt`,
+     * `llm` and `tts` together, so an agent sets either `realtime` or the three
+     * cascade slots, never both.
+     */
+    get(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/catalog',
+            ...options
+        });
+    }
+    get avatars() {
+        return this._avatars ?? (this._avatars = new Avatars({ client: this.client }));
+    }
+    get voices() {
+        return this._voices ?? (this._voices = new Voices({ client: this.client }));
+    }
+}
+export class Messages extends HeyApiClient {
+    /**
+     * Create Text Message
+     *
+     * Send a message to a text agent — the way to actually talk to one.
+     *
+     * Addressed by `contact_key`, not by id, so the same key always reaches the
+     * same thread. `client_message_id` is a UUID you generate; re-sending with the
+     * same one is ignored rather than duplicated.
+     *
+     * Returns as soon as the message is accepted, carrying only the user's own
+     * item — poll `list_conversation_items` for the agent's reply.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'textMessageRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations/messages',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Items extends HeyApiClient {
+    /**
+     * List Conversation Items
+     *
+     * The messages in a conversation — the transcript of what was said.
+     *
+     * `order=asc` reads from the beginning; `order=desc` returns the newest
+     * window, still chronological within the page, which is what you want to see
+     * an agent's latest reply. `direction` distinguishes inbound from outbound
+     * and `delivery_status` says whether an outbound message actually landed.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'conversation_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'order' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations/{conversation_id}/items',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Sessions extends HeyApiClient {
+    /**
+     * List Conversation Sessions
+     *
+     * The agent sessions behind a conversation, newest first.
+     *
+     * A thread can be handled many times — each phone call, each text window,
+     * each trigger firing is one session, recording which agent version ran and
+     * how it finished. Use it to find out *which* version answered, and to reach
+     * the matching `session_id` for `get_call`.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'conversation_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations/{conversation_id}/sessions',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Conversations extends HeyApiClient {
+    /**
+     * List Conversations
+     *
+     * List conversations across every channel, most recently active first.
+     *
+     * One conversation is one bounded stretch of talking — a web chat, a Telegram
+     * thread, or a single phone call — with `surface` saying which. Several of them
+     * can belong to the same person: pass `contact_key` to list only theirs.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'agent_id' },
+                    { in: 'query', key: 'contact_key' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Text Conversation
+     *
+     * Open a text conversation with a published text agent.
+     *
+     * `contact_key` is your own stable id for the person you are talking to —
+     * unique in the workspace, and how you reach them again. `userdata` seeds what
+     * the agent knows about them, readable as `{{userdata.field}}` from the
+     * agent's tools.
+     *
+     * Creating the conversation does not send anything; call `create_text_message`
+     * to say something.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createTextConversationRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Get Conversation
+     *
+     * Read one conversation's header: agent, surface, summary and userdata.
+     *
+     * `userdata` is what the agent knows about the *contact* — what its tools
+     * published to the `userdata` store, across every conversation with them. For
+     * what one call ended up knowing, read a session's own `userdata` from
+     * `list_conversation_sessions`. The messages are in `list_conversation_items`.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'conversation_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations/{conversation_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Conversation
+     *
+     * Edit a conversation's summary, userdata or metadata.
+     *
+     * Writing `userdata` changes what the agent sees as `{{userdata.field}}` on the
+     * next turn — the way to correct or preload what it knows from outside a call.
+     * It belongs to the *contact*, so it reaches every conversation with them, not
+     * just this one. Each field you send replaces that whole object; omitted fields
+     * are left alone.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'conversation_id' }, { key: 'patchConversationRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations/{conversation_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Conversation Event Stream
+     *
+     * Watch one conversation happen: a snapshot, then every item and turn live.
+     *
+     * Frames: `conversation.snapshot` (the conversation and its items, sent first
+     * and on every reconnect), `item.created`, `item.delivery_updated`, `turn` and
+     * `turn.failed` (turn lifecycle), and `assistant.started` / `assistant.delta`
+     * / `assistant.completed` for the reply as it is generated.
+     *
+     * Nothing here is canonical — a dropped frame is recovered by reconnecting
+     * (the snapshot re-syncs) or by `list_conversation_items`.
+     */
+    events(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'conversation_id' }] }]);
+        return (options?.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations/{conversation_id}/events',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Conversation Snapshot
+     *
+     * Did this conversation go well? One verdict over the whole thread.
+     *
+     * `issues` names every problem found across every session in the thread —
+     * errors, failed tools, slow responses, a bad connection — and `ok` is true
+     * when there were none. Cost and duration sum across sessions; latency and
+     * tooling come from the merged timeline.
+     */
+    snapshot(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'conversation_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/conversations/{conversation_id}/snapshot',
+            ...options,
+            ...params
+        });
+    }
+    get messages() {
+        return this._messages ?? (this._messages = new Messages({ client: this.client }));
+    }
+    get items() {
+        return this._items ?? (this._items = new Items({ client: this.client }));
+    }
+    get sessions() {
+        return this._sessions ?? (this._sessions = new Sessions({ client: this.client }));
+    }
+}
+export class Agents2 extends HeyApiClient {
+    /**
+     * Agent Copilot Send Message
+     *
+     * Say something to AgentCoPilot. The reply arrives on the stream, not here.
+     *
+     * Returns as soon as the turn is queued; watch `turn` and `message` frames
+     * on the matching `/stream` for what it does.
+     */
+    send(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }, { key: 'sendMessageRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/agents/{agent_id}/messages',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Agent Copilot Stream
+     *
+     * AgentCoPilot's conversation for one agent, as its editor rail shows it.
+     *
+     * Frames: `snapshot` (the whole conversation, sent first and on every
+     * reconnect), `message` (one new message), `turn` (that turn's lifecycle —
+     * `running`, `done`, `error`, `canceled`).
+     */
+    stream(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'agent_id' }] }]);
+        return (options?.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/agents/{agent_id}/stream',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Knowledge extends HeyApiClient {
+    /**
+     * Knowledge Copilot Send Message
+     *
+     * Say something to KnowledgeCoPilot. The reply arrives on the stream, not here.
+     *
+     * Returns as soon as the turn is queued; watch `turn` and `message` frames
+     * on the matching `/stream` for what it does.
+     */
+    send(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }, { key: 'sendMessageRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/knowledge/{kb_id}/messages',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Knowledge Copilot Stream
+     *
+     * KnowledgeCoPilot's curation chat for one knowledge base.
+     *
+     * Frames: `snapshot` (the whole conversation, sent first and on every
+     * reconnect), `message` (one new message), `turn` (that turn's lifecycle —
+     * `running`, `done`, `error`, `canceled`).
+     */
+    stream(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }] }]);
+        return (options?.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/knowledge/{kb_id}/stream',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Tasks extends HeyApiClient {
+    /**
+     * Task Copilot Send Message
+     *
+     * Say something to TaskCoPilot. The reply arrives on the stream, not here.
+     *
+     * Returns as soon as the turn is queued; watch `turn` and `message` frames
+     * on the matching `/stream` for what it does.
+     */
+    send(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { key: 'sendMessageRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/tasks/{task_id}/messages',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Task Copilot Stream
+     *
+     * TaskCoPilot's conversation for one agent task, as its editor rail shows it.
+     *
+     * Frames: `snapshot` (the whole conversation, sent first and on every
+     * reconnect), `message` (one new message), `turn` (that turn's lifecycle —
+     * `running`, `done`, `error`, `canceled`).
+     */
+    stream(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        return (options?.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/tasks/{task_id}/stream',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Tools extends HeyApiClient {
+    /**
+     * Tool Copilot Send Message
+     *
+     * Say something to ToolCoPilot. The reply arrives on the stream, not here.
+     *
+     * Returns as soon as the turn is queued; watch `turn` and `message` frames
+     * on the matching `/stream` for what it does.
+     */
+    send(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }, { key: 'sendMessageRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/tools/{tool_id}/messages',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Tool Copilot Stream
+     *
+     * ToolCoPilot's conversation for one tool, as its editor rail shows it.
+     *
+     * Frames: `snapshot` (the whole conversation, sent first and on every
+     * reconnect), `message` (one new message), `turn` (that turn's lifecycle —
+     * `running`, `done`, `error`, `canceled`).
+     */
+    stream(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }] }]);
+        return (options?.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/copilot/tools/{tool_id}/stream',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Copilot extends HeyApiClient {
+    get agents() {
+        return this._agents ?? (this._agents = new Agents2({ client: this.client }));
+    }
+    get knowledge() {
+        return this._knowledge ?? (this._knowledge = new Knowledge({ client: this.client }));
+    }
+    get tasks() {
+        return this._tasks ?? (this._tasks = new Tasks({ client: this.client }));
+    }
+    get tools() {
+        return this._tools ?? (this._tools = new Tools({ client: this.client }));
+    }
+}
+export class Recipients2 extends HeyApiClient {
+    /**
+     * List Email Batch Recipients
+     *
+     * One batch's rows, in the order they were uploaded.
+     *
+     * Each row carries `columns` — the merged space of what you uploaded, what the
+     * task produced and what a person edited, in that precedence — plus the three
+     * halves separately, so an edited cell can be told from the model's own value.
+     * `not_ready_reason` is why this row cannot be sent yet, and is null when it
+     * can be.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'batch_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'status' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/recipients',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Email Batch Recipient
+     *
+     * Edit cells on one row before it is sent.
+     *
+     * `overrides` is merged over the uploaded and generated values at send time and
+     * stored apart from both, so what the model wrote stays readable underneath.
+     * Sending an empty value clears that edit rather than sending an empty field —
+     * the way to send nothing is to skip the row. A row that has already been
+     * queued or sent can no longer be edited.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'batch_id' },
+                    { in: 'path', key: 'recipient_id' },
+                    { key: 'patchEmailRecipientRequest', map: 'body' }
+                ] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/recipients/{recipient_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Restore Email Batch Recipients
+     *
+     * Put skipped rows back. `selection: "all_eligible"` means every skipped row.
+     */
+    restore(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'selectRecipientsRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/restore',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Retry Email Batch Recipients
+     *
+     * Draft rows whose first attempt failed, again.
+     *
+     * `selection: "all_eligible"` means every row whose drafting failed. This is
+     * the one action that revives a batch that has already finished drafting: it
+     * goes back to `drafting` and picks up exactly the rows you retried — the
+     * alternative would be telling you that twelve failed rows are unrecoverable
+     * because the other 4 988 finished first.
+     */
+    retry(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'selectRecipientsRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/retry',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Send Email Batch Recipients
+     *
+     * Send the rows you name. **This mails real people and cannot be undone.**
+     *
+     * At most 50 rows per call, named one by one — there is no "select all" and no
+     * bulk form of this. A row whose `to`, `subject` or `body` does not resolve
+     * comes back in `rejected` and stays a draft; fix it with
+     * `patch_email_batch_recipient` and try again.
+     *
+     * `from_email`, `from_name` and `reply_to` override the sender for this call
+     * only, and must be on a domain verified on the same Resend account.
+     */
+    send(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'sendEmailBatchRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/send',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Skip Email Batch Recipients
+     *
+     * Take drafted rows out of consideration. Reversible with `restore`.
+     *
+     * Takes either `recipient_ids` or `selection: "all_eligible"`, which here means
+     * every row that has a draft. The reversible verbs keep that shorthand while
+     * `send` does not, because the rule is about irreversibility rather than bulk.
+     */
+    skip(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'selectRecipientsRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/skip',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Batches2 extends HeyApiClient {
+    /**
+     * List Email Batches
+     *
+     * List email batches, newest first.
+     *
+     * `status` is about **drafting** and nothing else: `scheduled`, `drafting`,
+     * `paused`, `drafted`, `canceled`, `failed`. A `drafted` batch is one whose
+     * drafts are ready to review — it says nothing about how many have been sent,
+     * which is what `counts` is for.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' },
+                    { in: 'query', key: 'status' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Email Batch
+     *
+     * Create an email batch: a list, an agent task that drafts each row, and a
+     * connected Resend account to send from.
+     *
+     * **Read your provider's terms first.** Resend's Acceptable Use Policy
+     * prohibits unsolicited mail of any kind — cold outreach, purchased lists,
+     * scraped contacts — and this runs on your account under your agreement.
+     *
+     * **Nothing is sent that a person has not selected.** Creating a batch only
+     * starts drafting; sending is a separate call over at most 50 named rows.
+     *
+     * **Every row runs your task as it stands right now** — a task has no
+     * versions, so editing it mid-batch changes every row drafted after that.
+     *
+     * `field_map` points `to`, `subject` and `body` at a column of your list or at
+     * a field the task produces. An invalid batch is a 400 listing every problem.
+     *
+     * There is no spend cap: every row runs the task and is billed, so a 5 000-row
+     * batch doing research costs 5 000 task runs whether or not anything is sent.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createEmailBatchRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Get Email Batch
+     *
+     * One batch: its policy, its per-status counts, what drafting has cost so
+     * far, and — while it is waiting on a start time or a closed window —
+     * `next_draft_at`.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Email Batch
+     *
+     * Edit a batch's policy. The next drafting pass reads the new row.
+     *
+     * Pacing and the calling window are editable at any time. The sender, the body
+     * format and the field map freeze once the batch has sent anything — changing
+     * them then would make the rows already delivered no longer describe what they
+     * were sent as. `start_at` moves only while the batch is still scheduled.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }, { key: 'patchEmailBatchRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Cancel Email Batch
+     *
+     * Stop drafting for good. This is the only terminal action — a batch cannot
+     * be deleted, because it is the record of what was sent to whom.
+     *
+     * Rows already drafted are **not** touched: cancelling stops drafting, and
+     * drafts already produced are still worth reviewing and sending. Rows never
+     * reached report as `canceled`.
+     */
+    cancel(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/cancel',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Pause Email Batch
+     *
+     * Stop drafting new rows. Runs already in flight finish.
+     *
+     * A paused batch has nothing scheduled at all until you resume it. Drafts
+     * already produced stay reviewable and sendable.
+     */
+    pause(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/pause',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Resume Email Batch
+     *
+     * Undo a pause and start drafting again from where it stopped.
+     */
+    resume(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'batch_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/batches/{batch_id}/resume',
+            ...options,
+            ...params
+        });
+    }
+    get recipients() {
+        return this._recipients ?? (this._recipients = new Recipients2({ client: this.client }));
+    }
+}
+export class Senders extends HeyApiClient {
+    /**
+     * List Email Senders
+     *
+     * The domains a connected email account may send from, right now.
+     *
+     * Domains rather than addresses, because that is what Resend verifies: any
+     * local part on a verified domain sends. Read live off the account, and this
+     * is what a `from_email` is checked against — both the batch's default and a
+     * per-send override.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'integration_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/email/senders',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Email extends HeyApiClient {
+    get batches() {
+        return this._batches ?? (this._batches = new Batches2({ client: this.client }));
+    }
+    get senders() {
+        return this._senders ?? (this._senders = new Senders({ client: this.client }));
+    }
+}
+export class McpTools extends HeyApiClient {
+    /**
+     * List Integration Mcp Tools
+     *
+     * Connect to the integration's MCP server and list every tool it offers.
+     *
+     * A live call to the provider, so it also proves the connection works. The
+     * list is unfiltered — it is what tool approval is chosen from. Which of these
+     * an attached agent can actually call is the integration's `allowed_tools`
+     * (null there means all of them). Fails if the integration is not active or
+     * the server is unreachable.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'integration_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}/mcp-tools',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Triggers extends HeyApiClient {
+    /**
+     * List Integration Triggers
+     *
+     * List the trigger deployments under an integration.
+     *
+     * A trigger binds an inbound provider event — a Telegram message — to a
+     * published agent version.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'integration_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}/triggers',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Integration Trigger
+     *
+     * Deploy an agent to an inbound provider event.
+     *
+     * `reply_mode` decides what happens with the agent's answer: `public_reply`
+     * sends it to the customer, `internal_note` posts it privately where the
+     * provider supports that, `none` generates without sending.
+     *
+     * Enabling validates that the integration is active and the assigned agent is
+     * a published text agent, so create disabled while still wiring things up.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'integration_id' }, { key: 'createIntegrationTriggerRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}/triggers',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Integration Trigger
+     *
+     * Delete a trigger permanently. The agent stops receiving that event.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'integration_id' }, { in: 'path', key: 'trigger_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}/triggers/{trigger_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Integration Trigger
+     *
+     * Update a trigger: reassign the agent, change reply mode, enable or
+     * disable it. Omitted fields are left unchanged. The same checks as creation
+     * run when enabling.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'integration_id' },
+                    { in: 'path', key: 'trigger_id' },
+                    { key: 'patchIntegrationTriggerRequest', map: 'body' }
+                ] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}/triggers/{trigger_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Integrations extends HeyApiClient {
+    /**
+     * List Integrations
+     *
+     * List the workspace's integrations with their provider, status and config.
+     *
+     * Secret values are never returned — credential fields come back as
+     * `{{secrets.NAME}}` references.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Integration
+     *
+     * Create a manual integration, fully configured.
+     *
+     * Which of `credentials_ref`, `provider_account_info`, `mcp_config` and
+     * `webhook_config` a provider needs is described by its `setup_fields` in the
+     * integration catalog. Secret-bearing fields take a plaintext value — stored
+     * as a workspace secret — or an existing `{{secrets.NAME}}` reference.
+     *
+     * Leave `allowed_tools` unset to expose every tool the server lists. OAuth
+     * providers are connected from the dashboard instead.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createIntegrationRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Integration Catalog
+     *
+     * List the providers that can be integrated, and how to connect each one.
+     *
+     * `auth_type` says which path a provider takes: `manual` through this API,
+     * `oauth` from the dashboard. `setup_fields` is the authoritative list of what
+     * each manual provider requires — read it rather than guessing. `capabilities`
+     * says whether it serves tools (MCP) or a messaging channel (triggers).
+     */
+    catalog(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/catalog',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Delete Integration
+     *
+     * Delete an integration and its triggers permanently.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'integration_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Integration
+     *
+     * Fetch one integration: provider, status, structured config, trigger
+     * capabilities and inbound webhook setup state.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'integration_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Integration
+     *
+     * Update an integration. Omitted fields are left unchanged.
+     *
+     * Sending `credentials_ref` rotates the credential. Only `active` integrations
+     * can be attached to agents or serve triggers.
+     *
+     * `allowed_tools` replaces the approved list wholesale: exactly those tools
+     * become callable by every agent this integration is attached to. It cannot be
+     * emptied — an agent that should call nothing is an integration that should be
+     * disabled.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'integration_id' }, { key: 'patchIntegrationRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/integrations/{integration_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    get mcpTools() {
+        return this._mcpTools ?? (this._mcpTools = new McpTools({ client: this.client }));
+    }
+    get triggers() {
+        return this._triggers ?? (this._triggers = new Triggers({ client: this.client }));
+    }
+}
+export class Nodes extends HeyApiClient {
+    /**
+     * Delete Node
+     *
+     * Drop one entry from the table of contents, permanently.
+     *
+     * Its children go with it, and agents can no longer retrieve any of it.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }, { in: 'path', key: 'node_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/nodes/{node_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Node
+     *
+     * Read one entry of the table of contents, with its full content.
+     *
+     * This is the text an agent retrieves when it fetches this node. `version` is
+     * what `patch_node` needs for a safe edit.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }, { in: 'path', key: 'node_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/nodes/{node_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Node
+     *
+     * Correct one entry's title, summary or content by hand — the way to fix a
+     * fact the crawl got wrong without rebuilding.
+     *
+     * `title` and `summary` are what the agent sees in the table of contents and
+     * decide whether it ever fetches this node, so keep them accurate.
+     *
+     * Send the `version` you read from `get_node`; a mismatch is rejected rather
+     * than overwriting someone else's edit.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'kb_id' },
+                    { in: 'path', key: 'node_id' },
+                    { key: 'patchNodeRequest', map: 'body' }
+                ] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/nodes/{node_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Pages extends HeyApiClient {
+    /**
+     * List Pages
+     *
+     * List the crawled pages and how each one transcribed.
+     *
+     * Where you look when a knowledge base is missing something: a page with a
+     * non-`done` status and an `error` never made it in, and `content_len` of 0
+     * means the URL yielded nothing worth indexing.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'kb_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/pages',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Knowledge2 extends HeyApiClient {
+    /**
+     * List Kbs
+     *
+     * List the workspace's knowledge bases with their build status.
+     *
+     * A knowledge base gives an agent grounded answers over crawled content. Only
+     * one with status `ready` can be attached to an agent, through the agent
+     * config's `kb_ids`.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Kb
+     *
+     * Start a knowledge base by crawling one or more websites.
+     *
+     * Returns immediately with `status: discovering` — crawling takes minutes.
+     * Poll `get_kb` until `review`, then pass the URLs worth indexing to
+     * `build_kb`. `max_pages` caps how many discovery may find (default 1000) and
+     * `notes` guides how the content is transcribed and organized.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createKbRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Kb
+     *
+     * Delete a knowledge base and everything crawled into it, permanently.
+     *
+     * Rebuilding means crawling the site again. Agents that list it in `kb_ids`
+     * lose those grounded answers, so detach it there first.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Kb
+     *
+     * Read one knowledge base: build status, progress and content tree.
+     *
+     * `status` walks `discovering` -> `review` -> `transcribing` -> `generating`
+     * -> `ready`, with `error` set if it stopped. At `review`, `discovered` holds
+     * the crawled URLs awaiting your selection; once ready, `tree` is the table of
+     * contents. This is the endpoint to poll while a build runs.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Build Kb
+     *
+     * Index the chosen pages, then write the table of contents.
+     *
+     * Call this once the knowledge base reaches `review`, passing the subset of
+     * `discovered` URLs worth indexing — the KB is only as good as that choice.
+     * Returns as soon as the work is queued; poll `get_kb` until `ready`, which is
+     * when it can be attached to an agent.
+     */
+    build(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }, { key: 'buildKbRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/build',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Events
+     *
+     * Watch one knowledge base build: `snapshot` first, then `progress` and `status`.
+     *
+     * `progress` carries the per-stage counts, `status` the terminal verdict
+     * (`ready`, or an `error`). The same state is readable at any time with
+     * `get_kb`; this is the live view of it.
+     */
+    events(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }] }]);
+        return (options?.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/events',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Kb Prompt
+     *
+     * The table of contents exactly as an agent using this KB is given it.
+     *
+     * Read it to judge what the agent can actually find — if a topic reads
+     * vaguely here, the agent will not know to fetch it. `chars` is how much of
+     * the agent's context this KB occupies.
+     */
+    prompt(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/prompt',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Regenerate Toc
+     *
+     * Rewrite the table of contents from the pages already indexed.
+     *
+     * The repair for a knowledge base whose structure came out wrong, or whose
+     * build failed at the last stage: it re-runs only that stage, so the site is
+     * not crawled or transcribed again.
+     */
+    regenerateToc(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'kb_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/knowledge/{kb_id}/toc',
+            ...options,
+            ...params
+        });
+    }
+    get nodes() {
+        return this._nodes ?? (this._nodes = new Nodes({ client: this.client }));
+    }
+    get pages() {
+        return this._pages ?? (this._pages = new Pages({ client: this.client }));
+    }
+}
+export class Tokens extends HeyApiClient {
+    /**
+     * Mcp Token
+     *
+     * This user's MCP token, in plaintext, with the API URL to pair it with.
+     *
+     * Unlike a token created by hand, this one can be read whenever it is needed:
+     * the dashboard renders it into ready-to-paste MCP configuration for Claude
+     * Code, Codex and Grok. The value is re-derived from the token's row, not
+     * stored, and is the same string every time — so a configuration a user
+     * already saved keeps working.
+     *
+     * It is always the caller's own token, never anyone else's, and is created on
+     * the spot for a user who somehow has none. Delete it from the tokens list to
+     * revoke it; the next call issues a new one, which rotates the credential.
+     */
+    mcp(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/mcp-token',
+            ...options
+        });
+    }
+    /**
+     * List Tokens
+     *
+     * List personal access tokens: your own, or every one in the organization
+     * if you are an admin.
+     *
+     * Who holds which credential is organization-admin information, so an EDITOR
+     * or VIEWER sees only what they created. Plaintext token values are never
+     * returned. A token with `kind: mcp` was issued automatically for the
+     * dashboard's MCP setup; the rest were created by hand.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tokens',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Token
+     *
+     * Create a personal access token for driving this API without the dashboard.
+     *
+     * The token authenticates as its creator and acts with that user's live role,
+     * so it can never do more than they can. It does not expire; deleting it is
+     * the revocation. The plaintext value is returned once here and never again —
+     * treat it like a password and do not echo it back into a conversation.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createTokenRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tokens',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Token
+     *
+     * Revoke a token immediately and permanently.
+     *
+     * Owners can delete their own; organization admins can delete any in the
+     * organization. Deleting an `mcp` token rotates it: the owner's next dashboard
+     * visit issues a replacement, and anything still configured with the old one
+     * stops working.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'token_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tokens/{token_id}',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Observability extends HeyApiClient {
+    /**
+     * Get Observability
+     *
+     * Workspace analytics: volume, endings, recordings, response time and spend.
+     * One snapshot of a date range, up to 7 days.
+     *
+     * `summary` is the range total, `daily` one row per day, and `volume` the same
+     * days cut by dimension (agent, phone number, type, status, close reason,
+     * recording, analysis, transfer) — each capped at eight series with the tail
+     * rolled into `Other`. `latency` reports response time per model stage and
+     * `cost` breaks the bill down by stage, provider and model.
+     *
+     * Narrow it with `agent_id` and `channel`; `timezone` decides day boundaries.
+     *
+     * Two traps. `latency.basis` is `per_turn` for voice and video and `per_call`
+     * for text, so the two are never averaged into one number. And every rate is
+     * over a subset — `success_rate` over `judged_sessions`, `cost` over
+     * `priced_sessions`, latency over `measured_sessions`.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'start_date' },
+                    { in: 'query', key: 'end_date' },
+                    { in: 'query', key: 'timezone' },
+                    { in: 'query', key: 'agent_id' },
+                    { in: 'query', key: 'channel' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/observability',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Invites extends HeyApiClient {
+    /**
+     * List Invites
+     *
+     * Invites waiting on a first login. Accepted and revoked ones drop off the
+     * list — an accepted invite is a member, and belongs on the roster instead.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org/invites',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Invite
+     *
+     * Invite an email address into this organization with a role.
+     *
+     * There is no invite link and no accept step: the invite is keyed to a Google
+     * identity, so signing in with that address *is* the check. Someone who
+     * already has an account joins immediately; anyone else joins the first time
+     * they sign in.
+     *
+     * No email is sent at MVP, so an existing user finds out by seeing the
+     * organization appear in their switcher — tell them yourself.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'inviteRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org/invites',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Revoke Invite
+     *
+     * Withdraw a pending invite, so signing in with that address no longer
+     * joins this organization.
+     */
+    revoke(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'invite_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org/invites/{invite_id}',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Members extends HeyApiClient {
+    /**
+     * List Members
+     *
+     * Every member sees the roster; only an ADMIN can change it.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org/members',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Remove Member
+     *
+     * Remove someone from this organization.
+     *
+     * They lose access on their next request, and their access tokens for this
+     * organization stop working with them. Nothing they created is deleted.
+     *
+     * Allowed even when this is the only organization they belong to — whether
+     * they have somewhere else to go is not this organization's problem, and their
+     * next sign-in gives them one of their own.
+     */
+    remove(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'user_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org/members/{user_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Set Member Role
+     *
+     * Change a member's role. Takes effect on their very next request.
+     */
+    setRole(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'user_id' }, { key: 'roleRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org/members/{user_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+}
+export class Orgs extends HeyApiClient {
+    /**
+     * Patch Org
+     *
+     * Change this organization's name or its data retention policy.
+     *
+     * The name is display only — nothing keys on it.
+     *
+     * `retention_days` is how long call and conversation *content* is kept:
+     * recordings, transcripts, summaries, extracted fields and the phone numbers
+     * on a call. When it passes, all of that is deleted and the call itself
+     * remains, with its duration, outcome and cost, so past invoices still
+     * resolve. `null` keeps everything forever, which is the default.
+     *
+     * It applies to calls from now on: a call already in the system keeps the
+     * deadline it was given when it ended, so shortening the policy never
+     * retroactively destroys anything. Erasing a contact's last call also resets
+     * what your agents remember about that person.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'patchOrgRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Leave Org
+     *
+     * Leave this organization. Any member may, including an admin who has
+     * promoted a successor. Nothing they created is deleted.
+     */
+    leave(options) {
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/org/leave',
+            ...options
+        });
+    }
+    /**
+     * List Orgs
+     *
+     * Every organization the signed-in user belongs to, with their role in each.
+     *
+     * Newest membership first, deliberately: an admin can add you to their
+     * organization without you being asked or emailed, so the one you did not know
+     * about is the one that needs to be visible.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/orgs',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Org
+     *
+     * Create a new, empty organization with the caller as its ADMIN.
+     *
+     * Any member can do this — it grants nothing in the organization they are
+     * currently in. Switch into it to start working there.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'orgNameRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/orgs',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Switch Org
+     *
+     * Point the dashboard session at another of the caller's organizations.
+     *
+     * The session cookie carries the organization, so switching re-issues it — the
+     * caller's role, resources and billing all move with it. Reload after this.
+     */
+    switch(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'org_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/orgs/{org_id}/switch',
+            ...options,
+            ...params
+        });
+    }
+    get invites() {
+        return this._invites ?? (this._invites = new Invites({ client: this.client }));
+    }
+    get members() {
+        return this._members ?? (this._members = new Members({ client: this.client }));
+    }
+}
+export class Schemas extends HeyApiClient {
+    /**
+     * Describe Schema
+     *
+     * The full JSON Schema of one of the five large request types.
+     *
+     * An argument whose description ends in `describe_schema('X')` carries only a
+     * placeholder for its shape — fetch the real one here before writing it.
+     *
+     * - `AgentConfig` — a whole agent definition; what `create_agent` takes.
+     * - `AgentOverride` — the same tree, every field optional, for one call.
+     * - `AgentTeam` — several agents on one call, handing off to each other.
+     * - `TaskConfig` — an agent task: inputs, output shape, model stack.
+     * - `ToolOperations` — the operation tree a custom tool runs.
+     *
+     * These compose, so a document you fetch may itself defer to another.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'name' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/schemas/{name}',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Secrets extends HeyApiClient {
+    /**
+     * List Secrets
+     *
+     * List the workspace's secrets by name, with a masked hint of each value.
+     *
+     * Values are write-only: once stored, a secret can only be read by the runtime
+     * through a `{{secrets.NAME}}` reference.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/secrets',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Secret
+     *
+     * Store a secret, replacing any existing one with the same name.
+     *
+     * `name` must be a valid identifier and is how tool operations and integration
+     * config refer to the value, as `{{secrets.NAME}}`. Organization admins only.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createSecretRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/secrets',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Secret
+     *
+     * Delete a secret permanently. Anything still referencing it will fail to
+     * resolve at runtime. Organization admins only.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'secret_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/secrets/{secret_id}',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Runs extends HeyApiClient {
+    /**
+     * List Task Runs
+     *
+     * This task's runs, newest first, each with its output, trace and cost.
+     *
+     * A run records the task's *name* and nothing else about the definition it ran
+     * under, so two runs either side of an edit are indistinguishable here.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'task_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/runs',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Run Task
+     *
+     * Run the task once with the variables you supply, and wait for the result.
+     *
+     * **This executes for real**: the tools call your endpoints with your secrets,
+     * the MCP servers spend your credits, and the model spends your tokens. A task
+     * that books a slot, charges a card or sends a message will do so.
+     *
+     * `vars` must match what the task declares — an unknown name is refused rather
+     * than dropped. The response is the whole run: the structured `output`, a
+     * `trace` of every tool call, the steps used and what the tokens cost. On
+     * failure `error.type` says whose problem it is. Secrets are redacted.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { key: 'runTaskRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/runs',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Get Task Run
+     *
+     * One run in full: what it produced, every tool it called on the way, and
+     * what it cost.
+     *
+     * This is what answers "why did it write that" for a caller holding one run id
+     * — an email batch's review table links each drafted row here. Secret values
+     * are redacted from the trace, and a trace that was cut reports it.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { in: 'path', key: 'run_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}/runs/{run_id}',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Tasks2 extends HeyApiClient {
+    /**
+     * List Tasks
+     *
+     * List the workspace's agent tasks.
+     *
+     * A task is an agent nobody talks to: a prompt, one LLM, tools and MCP
+     * servers, the variables it takes as input, and the typed result it must
+     * produce. `last_run` says how the most recent run of each one went, so a
+     * task whose prompt stopped calling `submit_result` is visible here rather
+     * than only in its own history.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Task
+     *
+     * Create an agent task.
+     *
+     * A task has no draft and no publish step: it is valid the moment it saves and
+     * callable immediately. An invalid config is a 400 listing every problem and
+     * nothing is stored.
+     *
+     * `output` is what makes this a task rather than a chat agent — declare the
+     * fields the model must produce and it is given a `submit_result` tool built
+     * from them. `vars` are its inputs, read as `{{vars.name}}`.
+     *
+     * `warnings` reports the non-fatal problems. There is no publish screen to
+     * show them on, so read them here.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createTaskRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Task
+     *
+     * Delete a task. Its run history survives, still named after it.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Task
+     *
+     * Fetch one task's config and how its last run went.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Update Task
+     *
+     * Replace a task's config.
+     *
+     * The whole config is sent, so include every field you mean to keep, and it is
+     * validated exactly as `create_task` is. The edit takes effect on the next run
+     * — a task has no versions, so there is no old wording to go back to and no
+     * record of which definition produced an earlier run.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'task_id' }, { key: 'patchTaskRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tasks/{task_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    get runs() {
+        return this._runs ?? (this._runs = new Runs({ client: this.client }));
+    }
+}
+export class Accounts extends HeyApiClient {
+    /**
+     * List Telephony Accounts
+     *
+     * List the workspace's connected carrier accounts.
+     *
+     * A carrier account is the credential Talqing uses to reach a phone network;
+     * phone numbers hang off one. `setup_complete` and `setup_steps` say whether
+     * it is finished — including the steps that can only be done in the carrier's
+     * own console.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/accounts',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Telephony Account
+     *
+     * Connect a carrier account so the workspace can own phone numbers.
+     *
+     * `account_info` and `credentials` must carry exactly the keys that carrier's
+     * `list_telephony_providers` entry declares. A credential may be plaintext —
+     * stored as a workspace secret — or an existing reference.
+     *
+     * Creating only records the credential; call `provision_telephony_account`
+     * next to build the SIP trunk.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createTelephonyAccountRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/accounts',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Telephony Account
+     *
+     * Disconnect a carrier account permanently.
+     *
+     * Every phone number on it must be disabled first, so this can never silently
+     * take live numbers off the air. Deleting also tears down the SIP trunk.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'account_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/accounts/{account_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Telephony Account
+     *
+     * Read one carrier account, including what its setup still needs.
+     *
+     * `setup_steps` is the authoritative checklist — read it rather than trying
+     * to re-derive setup state from `provider_state`. A step marked
+     * `user_confirmable` cannot be checked over any API; it is done in the
+     * carrier's console and confirmed with `patch_telephony_account`.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'account_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/accounts/{account_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Telephony Account
+     *
+     * Update a carrier account: rename it, replace credentials, or disable it.
+     *
+     * Only the fields you send change. `status` accepts `disabled` to stop the
+     * account and `connected` to re-enable it. Set `console_setup_confirmed` when
+     * the user says they have finished the carrier-console steps — no API can
+     * verify that work, and inbound calling on this account's numbers stays
+     * blocked until they confirm.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'account_id' }, { key: 'patchTelephonyAccountRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/accounts/{account_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Provision Telephony Account
+     *
+     * Build (or repair) the SIP trunk between Talqing and the carrier.
+     *
+     * Run this after connecting an account, and again after replacing its
+     * credentials. It is safe to repeat: it converges the carrier side to what
+     * the account should have rather than creating a second trunk. The response's
+     * `status` and `setup_steps` say what is working and what is left.
+     */
+    provision(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'account_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/accounts/{account_id}/provision',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * List Remote Numbers
+     *
+     * List the numbers this account owns at the carrier, ready to import.
+     *
+     * Read live from the carrier, so it also proves the credentials work.
+     * `already_imported` marks the ones Talqing already has — pass the rest to
+     * `import_phone_numbers`. Buying a number is done at the carrier, not here.
+     */
+    remoteNumbers(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'account_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/accounts/{account_id}/remote-numbers',
+            ...options,
+            ...params
+        });
+    }
+}
+export class PhoneNumbers extends HeyApiClient {
+    /**
+     * List Phone Numbers
+     *
+     * List the workspace's phone numbers, optionally for one carrier account.
+     *
+     * `readiness` is the field to report to a user — it collapses status,
+     * capability and routing into the one answer they want: `live` (answering
+     * inbound), `needs_agent`, `needs_carrier_setup`, `setting_up`, `error` or
+     * `disabled`.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'query', key: 'account_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/phone-numbers',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Import Phone Numbers
+     *
+     * Bring carrier-owned numbers into the workspace, provisioning each one.
+     *
+     * Per number, not all-or-nothing: `items` carries one result per requested
+     * E.164, so check every `ok` rather than assuming a 200 means all of them
+     * landed. `provision` defaults to true, which is what makes a number usable.
+     */
+    import(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'importPhoneNumbersRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/phone-numbers/import',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Get Phone Number
+     *
+     * Read one phone number: its carrier, capabilities, agent and readiness.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'number_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/phone-numbers/{number_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Phone Number
+     *
+     * Relabel a number, change what it may do, or take it out of service.
+     *
+     * `can_inbound` and `can_outbound` gate the directions it will carry.
+     * `status` accepts `disabled`, which tears down its LiveKit routing, and
+     * `pending`, which re-opens a disabled number so it can be provisioned again.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'number_id' }, { key: 'patchPhoneNumberRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/phone-numbers/{number_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Assign Phone Number
+     *
+     * Put an agent on a number so it answers incoming calls.
+     *
+     * The agent must be **published** and on the `voice` or `video` channel, and
+     * the number active, inbound-capable and on a ready carrier account — each is
+     * refused with the reason. One agent per number; assigning again replaces the
+     * previous one. Republishing the agent later needs no reassignment.
+     */
+    assign(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'number_id' }, { key: 'assignPhoneNumberRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/phone-numbers/{number_id}/assign',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Provision Phone Number
+     *
+     * Wire a number up at the carrier and in LiveKit so it can carry calls.
+     *
+     * `import_phone_numbers` already does this unless it was called with
+     * `provision: false`; use this to retry a number left in `error`, or to bring
+     * one back after re-enabling it.
+     */
+    provision(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'number_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/phone-numbers/{number_id}/provision',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Unassign Phone Number
+     *
+     * Take the agent off a number, so incoming calls are no longer answered.
+     *
+     * The number stays provisioned and can still place outbound calls; its
+     * readiness drops to `needs_agent`.
+     */
+    unassign(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'number_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/phone-numbers/{number_id}/unassign',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Providers extends HeyApiClient {
+    /**
+     * List Telephony Providers
+     *
+     * List the telephony carriers an account can be connected to.
+     *
+     * `account_info_keys`, `credential_keys` and `setup_fields` state exactly what
+     * connecting each carrier needs — read this before `create_telephony_account`
+     * rather than guessing field names. Entries with `implemented: false` have no
+     * adapter yet and cannot be used.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/telephony/providers',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Telephony extends HeyApiClient {
+    get accounts() {
+        return this._accounts ?? (this._accounts = new Accounts({ client: this.client }));
+    }
+    get phoneNumbers() {
+        return this._phoneNumbers ?? (this._phoneNumbers = new PhoneNumbers({ client: this.client }));
+    }
+    get providers() {
+        return this._providers ?? (this._providers = new Providers({ client: this.client }));
+    }
+}
+export class Versions2 extends HeyApiClient {
+    /**
+     * Get Tool Version
+     *
+     * Fetch what one published version of a tool actually contains.
+     *
+     * `get_tool` lists the versions and when each was published; this returns the
+     * frozen definition itself — the arguments, behaviour flags and operation tree
+     * exactly as they were at that publish. Use it to see what changed between two
+     * versions, or between a version and the current draft.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }, { in: 'path', key: 'version' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}/versions/{version}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Rollback Tool Version
+     *
+     * Put an earlier published version of a tool back into production.
+     *
+     * That version becomes live immediately and **replaces the current draft**, so
+     * any unpublished edits are lost. No new version is created.
+     *
+     * Agents already published keep the tool definition they were published with,
+     * so republish them for the rollback to reach live calls.
+     */
+    rollback(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }, { in: 'path', key: 'version' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}/versions/{version}/rollback',
+            ...options,
+            ...params
+        });
+    }
+}
+export class Tools2 extends HeyApiClient {
+    /**
+     * List Tools
+     *
+     * List the workspace's tools with their draft operation trees.
+     *
+     * `published_version` is null for a tool that has never been published; only
+     * published tools can be attached to an agent or used as a lifecycle hook.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Tool
+     *
+     * Create a draft tool.
+     *
+     * `name` is the function name the agent's LLM sees, so it must be a valid
+     * identifier and describe the capability. `json_schema` declares the arguments
+     * that LLM supplies. `operations` may be sent here or added later with a
+     * patch. The tool is a draft until published.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createToolRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Delete Tool
+     *
+     * Delete a tool and its published versions permanently.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Get Tool
+     *
+     * Fetch one tool: behaviour flags, argument schema, draft operation tree
+     * and the list of published versions.
+     */
+    get(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Tool
+     *
+     * Update a draft tool. Omitted fields are left unchanged.
+     *
+     * `operations` is the one exception: sending it replaces the entire tree, so
+     * include every node you want to keep. Changes land on the draft; publish to
+     * make them live.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }, { key: 'patchToolRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Publish Tool
+     *
+     * Validate the draft and freeze it as a new immutable tool version.
+     *
+     * Required before the tool can be attached to an agent or used as a lifecycle
+     * hook. Agents already published keep the definition they were published with
+     * until they are republished.
+     */
+    publish(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }, { key: 'publishToolRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}/publish',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Run Tool
+     *
+     * Run the draft tool once with arguments you supply and see every step.
+     *
+     * This executes for real: HTTP operations call your endpoints with your
+     * secrets, so a tool that books a slot or charges a card will do so.
+     * Conversational operations (`say`, `generate_reply`, `add_message`,
+     * `handoff`, `end_call`, `frontend_rpc`) are recorded with their resolved text
+     * rather than performed.
+     *
+     * Each step reports the resolved request and response, the branch an `if`
+     * took, and everything published into `tooldata` or `userdata`. Secrets are
+     * redacted. Nothing is saved, so there is no need to publish first.
+     */
+    run(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }, { key: 'runToolRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}/run',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Validate Tool
+     *
+     * Check the draft operation tree without publishing it.
+     *
+     * Reports unknown argument and secret references, unreachable published
+     * fields, handoff targets that are not published, code that fails to
+     * transpile, and userdata read before it is written.
+     */
+    validate(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'tool_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/tools/{tool_id}/validate',
+            ...options,
+            ...params
+        });
+    }
+    get versions() {
+        return this._versions ?? (this._versions = new Versions2({ client: this.client }));
+    }
+}
+export class Webhooks extends HeyApiClient {
+    /**
+     * List Webhooks
+     *
+     * List the workspace's webhooks with their subscriptions and last delivery
+     * result. Signing secrets are returned only as a masked hint.
+     */
+    list(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'query', key: 'limit' }, { in: 'query', key: 'offset' }] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Create Webhook
+     *
+     * Create a webhook. Webhooks are workspace-wide — they fire for every agent.
+     *
+     * An empty `subscribed_events` subscribes to all events. A signing secret is
+     * generated when none is supplied; either way the plaintext secret is returned
+     * once here and never again.
+     */
+    create(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ key: 'createWebhookRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Event Types
+     *
+     * List every event a webhook can subscribe to, and which are emitted today.
+     */
+    eventTypes(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks/event-types',
+            ...options
+        });
+    }
+    /**
+     * Delete Webhook
+     *
+     * Delete a webhook permanently.
+     */
+    delete(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'webhook_id' }] }]);
+        return (options?.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks/{webhook_id}',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Patch Webhook
+     *
+     * Update a webhook's URL, subscriptions or status. Omitted fields are left
+     * unchanged; a disabled webhook stops receiving deliveries.
+     */
+    update(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'webhook_id' }, { key: 'patchWebhookRequest', map: 'body' }] }]);
+        return (options?.client ?? this.client).patch({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks/{webhook_id}',
+            ...options,
+            ...params,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+                ...params.headers
+            }
+        });
+    }
+    /**
+     * Webhook Deliveries
+     *
+     * List recent delivery attempts for one webhook — event, response status
+     * and error — newest first. The place to look when a webhook seems silent.
+     */
+    deliveries(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [
+                    { in: 'path', key: 'webhook_id' },
+                    { in: 'query', key: 'limit' },
+                    { in: 'query', key: 'offset' }
+                ] }]);
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks/{webhook_id}/deliveries',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Rotate Webhook Secret
+     *
+     * Issue a new signing secret, invalidating the old one immediately.
+     *
+     * The new plaintext secret is returned once here; the receiver must be updated
+     * or signature checks will start failing.
+     */
+    rotateSecret(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'webhook_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks/{webhook_id}/rotate-secret',
+            ...options,
+            ...params
+        });
+    }
+    /**
+     * Test Webhook
+     *
+     * Send a signed test event and return the endpoint's response, so delivery
+     * and signature verification can be checked end to end.
+     */
+    test(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: 'path', key: 'webhook_id' }] }]);
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: 'talqing_session',
+                    type: 'apiKey'
+                }],
+            url: '/v1/webhooks/{webhook_id}/test',
+            ...options,
+            ...params
+        });
+    }
+}
+export class TalqingApi extends HeyApiClient {
+    constructor(args) {
+        super(args);
+        TalqingApi.__registry.set(this, args?.key);
+    }
+    /**
+     * Health
+     *
+     * Liveness probe: `200` once this process is serving. Unauthenticated.
+     *
+     * It answers for the API process, not its dependencies — a `200` here does not
+     * promise Postgres, Redis or LiveKit are reachable.
+     */
+    health(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            url: '/health',
+            ...options
+        });
+    }
+    get agents() {
+        return this._agents ?? (this._agents = new Agents({ client: this.client }));
+    }
+    get auth() {
+        return this._auth ?? (this._auth = new Auth({ client: this.client }));
+    }
+    get providerKeys() {
+        return this._providerKeys ?? (this._providerKeys = new ProviderKeys({ client: this.client }));
+    }
+    get calls() {
+        return this._calls ?? (this._calls = new Calls({ client: this.client }));
+    }
+    get catalog() {
+        return this._catalog ?? (this._catalog = new Catalog({ client: this.client }));
+    }
+    get conversations() {
+        return this._conversations ?? (this._conversations = new Conversations({ client: this.client }));
+    }
+    get copilot() {
+        return this._copilot ?? (this._copilot = new Copilot({ client: this.client }));
+    }
+    get email() {
+        return this._email ?? (this._email = new Email({ client: this.client }));
+    }
+    get integrations() {
+        return this._integrations ?? (this._integrations = new Integrations({ client: this.client }));
+    }
+    get knowledge() {
+        return this._knowledge ?? (this._knowledge = new Knowledge2({ client: this.client }));
+    }
+    get tokens() {
+        return this._tokens ?? (this._tokens = new Tokens({ client: this.client }));
+    }
+    get observability() {
+        return this._observability ?? (this._observability = new Observability({ client: this.client }));
+    }
+    get orgs() {
+        return this._orgs ?? (this._orgs = new Orgs({ client: this.client }));
+    }
+    get schemas() {
+        return this._schemas ?? (this._schemas = new Schemas({ client: this.client }));
+    }
+    get secrets() {
+        return this._secrets ?? (this._secrets = new Secrets({ client: this.client }));
+    }
+    get tasks() {
+        return this._tasks ?? (this._tasks = new Tasks2({ client: this.client }));
+    }
+    get telephony() {
+        return this._telephony ?? (this._telephony = new Telephony({ client: this.client }));
+    }
+    get tools() {
+        return this._tools ?? (this._tools = new Tools2({ client: this.client }));
+    }
+    get webhooks() {
+        return this._webhooks ?? (this._webhooks = new Webhooks({ client: this.client }));
+    }
+}
+TalqingApi.__registry = new HeyApiRegistry();
+//# sourceMappingURL=sdk.gen.js.map