@talqing/sdk 0.1.0 → 0.2.1

package/dist/esm/gen/sdk.gen.d.ts

@@ -0,0 +1,2330 @@
+import { type Client, type ClientMeta, type Options as Options2, type RequestResult, type ServerSentEventsResult, type TDataShape } from './client/index.js';
+import type { AddRecipientsRequest, AddVoiceRequest, AgentsCreateErrors, AgentsCreateResults, AgentsDeleteErrors, AgentsDeleteResults, AgentsGetErrors, AgentsGetResults, AgentsListErrors, AgentsListResults, AgentsPublishErrors, AgentsPublishResults, AgentsUpdateErrors, AgentsUpdateResults, AgentsValidateErrors, AgentsValidateResults, AgentsVersionsGetErrors, AgentsVersionsGetResults, AgentsVersionsRollbackErrors, AgentsVersionsRollbackResults, AssignPhoneNumberRequest, AuthLogoutErrors, AuthLogoutResults, AuthMeErrors, AuthMeResults, BackfillAnalysisRequest, BuildKBRequest, CallsAnalysisBackfillErrors, CallsAnalysisBackfillResults, CallsAnalysisPreviewErrors, CallsAnalysisPreviewResults, CallsBatchesCancelErrors, CallsBatchesCancelResults, CallsBatchesCreateErrors, CallsBatchesCreateResults, CallsBatchesGetErrors, CallsBatchesGetResults, CallsBatchesListErrors, CallsBatchesListResults, CallsBatchesPauseErrors, CallsBatchesPauseResults, CallsBatchesRecipientsAddErrors, CallsBatchesRecipientsAddResults, CallsBatchesRecipientsListErrors, CallsBatchesRecipientsListResults, CallsBatchesResumeErrors, CallsBatchesResumeResults, CallsBatchesUpdateErrors, CallsBatchesUpdateResults, CallsDeleteErrors, CallsDeleteResults, CallsGetErrors, CallsGetResults, CallsListErrors, CallsListResults, CallsOutboundErrors, CallsOutboundResults, CallsRecordingDeleteErrors, CallsRecordingDeleteResults, CallsRecordingGetErrors, CallsRecordingGetResults, CallsScreenRecordingGetErrors, CallsScreenRecordingGetResults, CallsStatsErrors, CallsStatsResults, CallsTokenErrors, CallsTokenResults, CatalogAvatarsListErrors, CatalogAvatarsListResults, CatalogGetErrors, CatalogGetResults, CatalogVoicesElevenlabsAddErrors, CatalogVoicesElevenlabsAddResults, CatalogVoicesElevenlabsSettingsErrors, CatalogVoicesElevenlabsSettingsResults, CatalogVoicesListErrors, CatalogVoicesListResults, ConversationsCreateErrors, ConversationsCreateResults, ConversationsEventsResult, ConversationsEventsResults, ConversationsGetErrors, ConversationsGetResults, ConversationsItemsListErrors, ConversationsItemsListResults, ConversationsListErrors, ConversationsListResults, ConversationsMessagesCreateErrors, ConversationsMessagesCreateResults, ConversationsSessionsListErrors, ConversationsSessionsListResults, ConversationsSnapshotErrors, ConversationsSnapshotResults, ConversationsUpdateErrors, ConversationsUpdateResults, CopilotAgentsSendErrors, CopilotAgentsSendResults, CopilotAgentsStreamResult, CopilotAgentsStreamResults, CopilotKnowledgeSendErrors, CopilotKnowledgeSendResults, CopilotKnowledgeStreamResult, CopilotKnowledgeStreamResults, CopilotTasksSendErrors, CopilotTasksSendResults, CopilotTasksStreamResult, CopilotTasksStreamResults, CopilotToolsSendErrors, CopilotToolsSendResults, CopilotToolsStreamResult, CopilotToolsStreamResults, CreateAgentRequest, CreateCallBatchRequest, CreateEmailBatchRequest, CreateIntegrationRequest, CreateIntegrationTriggerRequest, CreateKBRequest, CreateSecretRequest, CreateTaskRequest, CreateTelephonyAccountRequest, CreateTextConversationRequest, CreateTokenRequest, CreateToolRequest, CreateWebhookRequest, EmailBatchesCancelErrors, EmailBatchesCancelResults, EmailBatchesCreateErrors, EmailBatchesCreateResults, EmailBatchesGetErrors, EmailBatchesGetResults, EmailBatchesListErrors, EmailBatchesListResults, EmailBatchesPauseErrors, EmailBatchesPauseResults, EmailBatchesRecipientsListErrors, EmailBatchesRecipientsListResults, EmailBatchesRecipientsRestoreErrors, EmailBatchesRecipientsRestoreResults, EmailBatchesRecipientsRetryErrors, EmailBatchesRecipientsRetryResults, EmailBatchesRecipientsSendErrors, EmailBatchesRecipientsSendResults, EmailBatchesRecipientsSkipErrors, EmailBatchesRecipientsSkipResults, EmailBatchesRecipientsUpdateErrors, EmailBatchesRecipientsUpdateResults, EmailBatchesResumeErrors, EmailBatchesResumeResults, EmailBatchesUpdateErrors, EmailBatchesUpdateResults, EmailSendersListErrors, EmailSendersListResults, HealthErrors, HealthResults, ImportPhoneNumbersRequest, IntegrationsCatalogErrors, IntegrationsCatalogResults, IntegrationsCreateErrors, IntegrationsCreateResults, IntegrationsDeleteErrors, IntegrationsDeleteResults, IntegrationsGetErrors, IntegrationsGetResults, IntegrationsListErrors, IntegrationsListResults, IntegrationsMcpToolsListErrors, IntegrationsMcpToolsListResults, IntegrationsTriggersCreateErrors, IntegrationsTriggersCreateResults, IntegrationsTriggersDeleteErrors, IntegrationsTriggersDeleteResults, IntegrationsTriggersListErrors, IntegrationsTriggersListResults, IntegrationsTriggersUpdateErrors, IntegrationsTriggersUpdateResults, IntegrationsUpdateErrors, IntegrationsUpdateResults, InviteRequest, KnowledgeBuildErrors, KnowledgeBuildResults, KnowledgeCreateErrors, KnowledgeCreateResults, KnowledgeDeleteErrors, KnowledgeDeleteResults, KnowledgeEventsResult, KnowledgeEventsResults, KnowledgeGetErrors, KnowledgeGetResults, KnowledgeListErrors, KnowledgeListResults, KnowledgeNodesDeleteErrors, KnowledgeNodesDeleteResults, KnowledgeNodesGetErrors, KnowledgeNodesGetResults, KnowledgeNodesUpdateErrors, KnowledgeNodesUpdateResults, KnowledgePagesListErrors, KnowledgePagesListResults, KnowledgePromptErrors, KnowledgePromptResults, KnowledgeRegenerateTocErrors, KnowledgeRegenerateTocResults, ObservabilityGetErrors, ObservabilityGetResults, OrgNameRequest, OrgsCreateErrors, OrgsCreateResults, OrgsInvitesCreateErrors, OrgsInvitesCreateResults, OrgsInvitesListErrors, OrgsInvitesListResults, OrgsInvitesRevokeErrors, OrgsInvitesRevokeResults, OrgsLeaveErrors, OrgsLeaveResults, OrgsListErrors, OrgsListResults, OrgsMembersListErrors, OrgsMembersListResults, OrgsMembersRemoveErrors, OrgsMembersRemoveResults, OrgsMembersSetRoleErrors, OrgsMembersSetRoleResults, OrgsSwitchErrors, OrgsSwitchResults, OrgsUpdateErrors, OrgsUpdateResults, OutboundCallRequest, PatchCallBatchRequest, PatchConversationRequest, PatchEmailBatchRequest, PatchEmailRecipientRequest, PatchIntegrationRequest, PatchIntegrationTriggerRequest, PatchNodeRequest, PatchOrgRequest, PatchPhoneNumberRequest, PatchTaskRequest, PatchTelephonyAccountRequest, PatchToolRequest, PatchWebhookRequest, PreviewAnalysisRequest, ProviderKeysDeleteErrors, ProviderKeysDeleteResults, ProviderKeysListErrors, ProviderKeysListResults, ProviderKeysSetErrors, ProviderKeysSetResults, PublishToolRequest, RoleRequest, RunTaskRequest, RunToolRequest, SchemasGetErrors, SchemasGetResults, SecretsCreateErrors, SecretsCreateResults, SecretsDeleteErrors, SecretsDeleteResults, SecretsListErrors, SecretsListResults, SelectRecipientsRequest, SendEmailBatchRequest, SendMessageRequest, SetProviderKeyRequest, TasksCreateErrors, TasksCreateResults, TasksDeleteErrors, TasksDeleteResults, TasksGetErrors, TasksGetResults, TasksListErrors, TasksListResults, TasksRunsCreateErrors, TasksRunsCreateResults, TasksRunsGetErrors, TasksRunsGetResults, TasksRunsListErrors, TasksRunsListResults, TasksUpdateErrors, TasksUpdateResults, TelephonyAccountsCreateErrors, TelephonyAccountsCreateResults, TelephonyAccountsDeleteErrors, TelephonyAccountsDeleteResults, TelephonyAccountsGetErrors, TelephonyAccountsGetResults, TelephonyAccountsListErrors, TelephonyAccountsListResults, TelephonyAccountsProvisionErrors, TelephonyAccountsProvisionResults, TelephonyAccountsRemoteNumbersErrors, TelephonyAccountsRemoteNumbersResults, TelephonyAccountsUpdateErrors, TelephonyAccountsUpdateResults, TelephonyPhoneNumbersAssignErrors, TelephonyPhoneNumbersAssignResults, TelephonyPhoneNumbersGetErrors, TelephonyPhoneNumbersGetResults, TelephonyPhoneNumbersImportErrors, TelephonyPhoneNumbersImportResults, TelephonyPhoneNumbersListErrors, TelephonyPhoneNumbersListResults, TelephonyPhoneNumbersProvisionErrors, TelephonyPhoneNumbersProvisionResults, TelephonyPhoneNumbersUnassignErrors, TelephonyPhoneNumbersUnassignResults, TelephonyPhoneNumbersUpdateErrors, TelephonyPhoneNumbersUpdateResults, TelephonyProvidersListErrors, TelephonyProvidersListResults, TextMessageRequest, TokenRequest, TokensCreateErrors, TokensCreateResults, TokensDeleteErrors, TokensDeleteResults, TokensListErrors, TokensListResults, TokensMcpErrors, TokensMcpResults, ToolsCreateErrors, ToolsCreateResults, ToolsDeleteErrors, ToolsDeleteResults, ToolsGetErrors, ToolsGetResults, ToolsListErrors, ToolsListResults, ToolsPublishErrors, ToolsPublishResults, ToolsRunErrors, ToolsRunResults, ToolsUpdateErrors, ToolsUpdateResults, ToolsValidateErrors, ToolsValidateResults, ToolsVersionsGetErrors, ToolsVersionsGetResults, ToolsVersionsRollbackErrors, ToolsVersionsRollbackResults, UpdateAgentRequest, WebhooksCreateErrors, WebhooksCreateResults, WebhooksDeleteErrors, WebhooksDeleteResults, WebhooksDeliveriesErrors, WebhooksDeliveriesResults, WebhooksEventTypesErrors, WebhooksEventTypesResults, WebhooksListErrors, WebhooksListResults, WebhooksRotateSecretErrors, WebhooksRotateSecretResults, WebhooksTestErrors, WebhooksTestResults, WebhooksUpdateErrors, WebhooksUpdateResults } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+declare class HeyApiClient {
+    protected client: Client;
+    constructor(args?: {
+        client?: Client;
+    });
+}
+declare class HeyApiRegistry<T> {
+    private readonly defaultKey;
+    private readonly instances;
+    get(key?: string): T;
+    set(value: T, key?: string): void;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+        version: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsVersionsGetResults, AgentsVersionsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+        version: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsVersionsRollbackResults, AgentsVersionsRollbackErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsListResults, AgentsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createAgentRequest: CreateAgentRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsCreateResults, AgentsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete Agent
+     *
+     * Delete an agent and its published versions permanently.
+     */
+    delete<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsDeleteResults, AgentsDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * Get Agent
+     *
+     * Fetch one agent's draft config, published version and publish history.
+     */
+    get<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsGetResults, AgentsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+        updateAgentRequest: UpdateAgentRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsUpdateResults, AgentsUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsPublishResults, AgentsPublishErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<AgentsValidateResults, AgentsValidateErrors, ThrowOnError, 'data'>;
+    private _versions?;
+    get versions(): Versions;
+}
+export declare class Auth extends HeyApiClient {
+    /**
+     * Logout
+     */
+    logout<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<AuthLogoutResults, AuthLogoutErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<AuthMeResults, AuthMeErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<ProviderKeysListResults, ProviderKeysListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        provider: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ProviderKeysDeleteResults, ProviderKeysDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        provider: string;
+        setProviderKeyRequest: SetProviderKeyRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ProviderKeysSetResults, ProviderKeysSetErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        backfillAnalysisRequest: BackfillAnalysisRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsAnalysisBackfillResults, CallsAnalysisBackfillErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        session_id: string;
+        previewAnalysisRequest: PreviewAnalysisRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsAnalysisPreviewResults, CallsAnalysisPreviewErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        limit?: number;
+        offset?: number;
+        status?: string | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesRecipientsListResults, CallsBatchesRecipientsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        addRecipientsRequest: AddRecipientsRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesRecipientsAddResults, CallsBatchesRecipientsAddErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+        status?: string | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesListResults, CallsBatchesListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createCallBatchRequest: CreateCallBatchRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesCreateResults, CallsBatchesCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesGetResults, CallsBatchesGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        patchCallBatchRequest: PatchCallBatchRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesUpdateResults, CallsBatchesUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesCancelResults, CallsBatchesCancelErrors, ThrowOnError, 'data'>;
+    /**
+     * Pause Call Batch
+     *
+     * Stop placing new calls. Calls already in progress run to their end.
+     */
+    pause<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesPauseResults, CallsBatchesPauseErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsBatchesResumeResults, CallsBatchesResumeErrors, ThrowOnError, 'data'>;
+    private _recipients?;
+    get recipients(): Recipients;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        session_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsRecordingDeleteResults, CallsRecordingDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        session_id: string;
+        download?: boolean;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsRecordingGetResults, CallsRecordingGetErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        session_id: string;
+        download?: boolean;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsScreenRecordingGetResults, CallsScreenRecordingGetErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+        start?: string | null;
+        end?: string | null;
+        agent_id?: string | null;
+        type?: 'WEB' | 'SIP_INBOUND' | 'SIP_OUTBOUND' | null;
+        status?: string | null;
+        outcome?: string | null;
+        contact_key?: string | null;
+        close_reason?: string | null;
+        batch_id?: string | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsListResults, CallsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        outboundCallRequest: OutboundCallRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsOutboundResults, CallsOutboundErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters?: {
+        start?: string | null;
+        end?: string | null;
+        agent_id?: string | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsStatsResults, CallsStatsErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        tokenRequest: TokenRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsTokenResults, CallsTokenErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        session_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsDeleteResults, CallsDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        session_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CallsGetResults, CallsGetErrors, ThrowOnError, 'data'>;
+    private _analysis?;
+    get analysis(): Analysis;
+    private _batches?;
+    get batches(): Batches;
+    private _recording?;
+    get recording(): Recording;
+    private _screenRecording?;
+    get screenRecording(): ScreenRecording;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        active_version?: string | null;
+        render_style?: string | null;
+        offset?: number;
+        limit?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CatalogAvatarsListResults, CatalogAvatarsListErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        addVoiceRequest: AddVoiceRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CatalogVoicesElevenlabsAddResults, CatalogVoicesElevenlabsAddErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        voice_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CatalogVoicesElevenlabsSettingsResults, CatalogVoicesElevenlabsSettingsErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        provider: string;
+        model?: string | null;
+        kind?: 'tts' | 'realtime';
+        search?: string;
+        language?: string;
+        accent?: string;
+        gender?: string;
+        page?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CatalogVoicesListResults, CatalogVoicesListErrors, ThrowOnError, 'data'>;
+    private _elevenlabs?;
+    get elevenlabs(): Elevenlabs;
+}
+export declare 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<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<CatalogGetResults, CatalogGetErrors, ThrowOnError, 'data'>;
+    private _avatars?;
+    get avatars(): Avatars;
+    private _voices?;
+    get voices(): Voices;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        textMessageRequest: TextMessageRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsMessagesCreateResults, ConversationsMessagesCreateErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        conversation_id: string;
+        limit?: number;
+        offset?: number;
+        order?: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsItemsListResults, ConversationsItemsListErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        conversation_id: string;
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsSessionsListResults, ConversationsSessionsListErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+        agent_id?: string | null;
+        contact_key?: string | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsListResults, ConversationsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createTextConversationRequest: CreateTextConversationRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsCreateResults, ConversationsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        conversation_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsGetResults, ConversationsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        conversation_id: string;
+        patchConversationRequest: PatchConversationRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsUpdateResults, ConversationsUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        conversation_id: string;
+    }, options?: Options<never, ThrowOnError, ConversationsEventsResult>): Promise<ServerSentEventsResult<ConversationsEventsResults>>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        conversation_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ConversationsSnapshotResults, ConversationsSnapshotErrors, ThrowOnError, 'data'>;
+    private _messages?;
+    get messages(): Messages;
+    private _items?;
+    get items(): Items;
+    private _sessions?;
+    get sessions(): Sessions;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+        sendMessageRequest: SendMessageRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CopilotAgentsSendResults, CopilotAgentsSendErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        agent_id: string;
+    }, options?: Options<never, ThrowOnError, CopilotAgentsStreamResult>): Promise<ServerSentEventsResult<CopilotAgentsStreamResults>>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+        sendMessageRequest: SendMessageRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CopilotKnowledgeSendResults, CopilotKnowledgeSendErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+    }, options?: Options<never, ThrowOnError, CopilotKnowledgeStreamResult>): Promise<ServerSentEventsResult<CopilotKnowledgeStreamResults>>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+        sendMessageRequest: SendMessageRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CopilotTasksSendResults, CopilotTasksSendErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+    }, options?: Options<never, ThrowOnError, CopilotTasksStreamResult>): Promise<ServerSentEventsResult<CopilotTasksStreamResults>>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+        sendMessageRequest: SendMessageRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<CopilotToolsSendResults, CopilotToolsSendErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+    }, options?: Options<never, ThrowOnError, CopilotToolsStreamResult>): Promise<ServerSentEventsResult<CopilotToolsStreamResults>>;
+}
+export declare class Copilot extends HeyApiClient {
+    private _agents?;
+    get agents(): Agents2;
+    private _knowledge?;
+    get knowledge(): Knowledge;
+    private _tasks?;
+    get tasks(): Tasks;
+    private _tools?;
+    get tools(): Tools;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        limit?: number;
+        offset?: number;
+        status?: string | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesRecipientsListResults, EmailBatchesRecipientsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        recipient_id: string;
+        patchEmailRecipientRequest: PatchEmailRecipientRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesRecipientsUpdateResults, EmailBatchesRecipientsUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * Restore Email Batch Recipients
+     *
+     * Put skipped rows back. `selection: "all_eligible"` means every skipped row.
+     */
+    restore<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        selectRecipientsRequest: SelectRecipientsRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesRecipientsRestoreResults, EmailBatchesRecipientsRestoreErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        selectRecipientsRequest: SelectRecipientsRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesRecipientsRetryResults, EmailBatchesRecipientsRetryErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        sendEmailBatchRequest: SendEmailBatchRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesRecipientsSendResults, EmailBatchesRecipientsSendErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        selectRecipientsRequest: SelectRecipientsRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesRecipientsSkipResults, EmailBatchesRecipientsSkipErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+        status?: string | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesListResults, EmailBatchesListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createEmailBatchRequest: CreateEmailBatchRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesCreateResults, EmailBatchesCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesGetResults, EmailBatchesGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+        patchEmailBatchRequest: PatchEmailBatchRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesUpdateResults, EmailBatchesUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesCancelResults, EmailBatchesCancelErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesPauseResults, EmailBatchesPauseErrors, ThrowOnError, 'data'>;
+    /**
+     * Resume Email Batch
+     *
+     * Undo a pause and start drafting again from where it stopped.
+     */
+    resume<ThrowOnError extends boolean = false>(parameters: {
+        batch_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailBatchesResumeResults, EmailBatchesResumeErrors, ThrowOnError, 'data'>;
+    private _recipients?;
+    get recipients(): Recipients2;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<EmailSendersListResults, EmailSendersListErrors, ThrowOnError, 'data'>;
+}
+export declare class Email extends HeyApiClient {
+    private _batches?;
+    get batches(): Batches2;
+    private _senders?;
+    get senders(): Senders;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsMcpToolsListResults, IntegrationsMcpToolsListErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsTriggersListResults, IntegrationsTriggersListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+        createIntegrationTriggerRequest: CreateIntegrationTriggerRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsTriggersCreateResults, IntegrationsTriggersCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete Integration Trigger
+     *
+     * Delete a trigger permanently. The agent stops receiving that event.
+     */
+    delete<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+        trigger_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsTriggersDeleteResults, IntegrationsTriggersDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+        trigger_id: string;
+        patchIntegrationTriggerRequest: PatchIntegrationTriggerRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsTriggersUpdateResults, IntegrationsTriggersUpdateErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsListResults, IntegrationsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createIntegrationRequest: CreateIntegrationRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsCreateResults, IntegrationsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsCatalogResults, IntegrationsCatalogErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete Integration
+     *
+     * Delete an integration and its triggers permanently.
+     */
+    delete<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsDeleteResults, IntegrationsDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * Get Integration
+     *
+     * Fetch one integration: provider, status, structured config, trigger
+     * capabilities and inbound webhook setup state.
+     */
+    get<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsGetResults, IntegrationsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        integration_id: string;
+        patchIntegrationRequest: PatchIntegrationRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<IntegrationsUpdateResults, IntegrationsUpdateErrors, ThrowOnError, 'data'>;
+    private _mcpTools?;
+    get mcpTools(): McpTools;
+    private _triggers?;
+    get triggers(): Triggers;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+        node_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeNodesDeleteResults, KnowledgeNodesDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+        node_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeNodesGetResults, KnowledgeNodesGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+        node_id: string;
+        patchNodeRequest: PatchNodeRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeNodesUpdateResults, KnowledgeNodesUpdateErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgePagesListResults, KnowledgePagesListErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeListResults, KnowledgeListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createKbRequest: CreateKBRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeCreateResults, KnowledgeCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeDeleteResults, KnowledgeDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeGetResults, KnowledgeGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+        buildKbRequest: BuildKBRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeBuildResults, KnowledgeBuildErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+    }, options?: Options<never, ThrowOnError, KnowledgeEventsResult>): Promise<ServerSentEventsResult<KnowledgeEventsResults>>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgePromptResults, KnowledgePromptErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        kb_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<KnowledgeRegenerateTocResults, KnowledgeRegenerateTocErrors, ThrowOnError, 'data'>;
+    private _nodes?;
+    get nodes(): Nodes;
+    private _pages?;
+    get pages(): Pages;
+}
+export declare 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<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<TokensMcpResults, TokensMcpErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TokensListResults, TokensListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createTokenRequest: CreateTokenRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TokensCreateResults, TokensCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        token_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TokensDeleteResults, TokensDeleteErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        start_date?: string | null;
+        end_date?: string | null;
+        timezone?: string;
+        agent_id?: string | null;
+        channel?: 'voice' | 'video' | 'text' | null;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ObservabilityGetResults, ObservabilityGetErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsInvitesListResults, OrgsInvitesListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        inviteRequest: InviteRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsInvitesCreateResults, OrgsInvitesCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Revoke Invite
+     *
+     * Withdraw a pending invite, so signing in with that address no longer
+     * joins this organization.
+     */
+    revoke<ThrowOnError extends boolean = false>(parameters: {
+        invite_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsInvitesRevokeResults, OrgsInvitesRevokeErrors, ThrowOnError, 'data'>;
+}
+export declare class Members extends HeyApiClient {
+    /**
+     * List Members
+     *
+     * Every member sees the roster; only an ADMIN can change it.
+     */
+    list<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsMembersListResults, OrgsMembersListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        user_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsMembersRemoveResults, OrgsMembersRemoveErrors, ThrowOnError, 'data'>;
+    /**
+     * Set Member Role
+     *
+     * Change a member's role. Takes effect on their very next request.
+     */
+    setRole<ThrowOnError extends boolean = false>(parameters: {
+        user_id: string;
+        roleRequest: RoleRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsMembersSetRoleResults, OrgsMembersSetRoleErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        patchOrgRequest: PatchOrgRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsUpdateResults, OrgsUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * Leave Org
+     *
+     * Leave this organization. Any member may, including an admin who has
+     * promoted a successor. Nothing they created is deleted.
+     */
+    leave<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<OrgsLeaveResults, OrgsLeaveErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsListResults, OrgsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        orgNameRequest: OrgNameRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsCreateResults, OrgsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        org_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<OrgsSwitchResults, OrgsSwitchErrors, ThrowOnError, 'data'>;
+    private _invites?;
+    get invites(): Invites;
+    private _members?;
+    get members(): Members;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        name: 'AgentConfig' | 'AgentOverride' | 'AgentTeam' | 'TaskConfig' | 'ToolOperations';
+    }, options?: Options<never, ThrowOnError>): RequestResult<SchemasGetResults, SchemasGetErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<SecretsListResults, SecretsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createSecretRequest: CreateSecretRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<SecretsCreateResults, SecretsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete Secret
+     *
+     * Delete a secret permanently. Anything still referencing it will fail to
+     * resolve at runtime. Organization admins only.
+     */
+    delete<ThrowOnError extends boolean = false>(parameters: {
+        secret_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<SecretsDeleteResults, SecretsDeleteErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksRunsListResults, TasksRunsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+        runTaskRequest: RunTaskRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksRunsCreateResults, TasksRunsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+        run_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksRunsGetResults, TasksRunsGetErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksListResults, TasksListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createTaskRequest: CreateTaskRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksCreateResults, TasksCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete Task
+     *
+     * Delete a task. Its run history survives, still named after it.
+     */
+    delete<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksDeleteResults, TasksDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * Get Task
+     *
+     * Fetch one task's config and how its last run went.
+     */
+    get<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksGetResults, TasksGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        task_id: string;
+        patchTaskRequest: PatchTaskRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TasksUpdateResults, TasksUpdateErrors, ThrowOnError, 'data'>;
+    private _runs?;
+    get runs(): Runs;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyAccountsListResults, TelephonyAccountsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createTelephonyAccountRequest: CreateTelephonyAccountRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyAccountsCreateResults, TelephonyAccountsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        account_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyAccountsDeleteResults, TelephonyAccountsDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        account_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyAccountsGetResults, TelephonyAccountsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        account_id: string;
+        patchTelephonyAccountRequest: PatchTelephonyAccountRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyAccountsUpdateResults, TelephonyAccountsUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        account_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyAccountsProvisionResults, TelephonyAccountsProvisionErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        account_id: string;
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyAccountsRemoteNumbersResults, TelephonyAccountsRemoteNumbersErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        account_id?: string | null;
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyPhoneNumbersListResults, TelephonyPhoneNumbersListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        importPhoneNumbersRequest: ImportPhoneNumbersRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyPhoneNumbersImportResults, TelephonyPhoneNumbersImportErrors, ThrowOnError, 'data'>;
+    /**
+     * Get Phone Number
+     *
+     * Read one phone number: its carrier, capabilities, agent and readiness.
+     */
+    get<ThrowOnError extends boolean = false>(parameters: {
+        number_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyPhoneNumbersGetResults, TelephonyPhoneNumbersGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        number_id: string;
+        patchPhoneNumberRequest: PatchPhoneNumberRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyPhoneNumbersUpdateResults, TelephonyPhoneNumbersUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        number_id: string;
+        assignPhoneNumberRequest: AssignPhoneNumberRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyPhoneNumbersAssignResults, TelephonyPhoneNumbersAssignErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        number_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyPhoneNumbersProvisionResults, TelephonyPhoneNumbersProvisionErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        number_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyPhoneNumbersUnassignResults, TelephonyPhoneNumbersUnassignErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<TelephonyProvidersListResults, TelephonyProvidersListErrors, ThrowOnError, 'data'>;
+}
+export declare class Telephony extends HeyApiClient {
+    private _accounts?;
+    get accounts(): Accounts;
+    private _phoneNumbers?;
+    get phoneNumbers(): PhoneNumbers;
+    private _providers?;
+    get providers(): Providers;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+        version: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsVersionsGetResults, ToolsVersionsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+        version: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsVersionsRollbackResults, ToolsVersionsRollbackErrors, ThrowOnError, 'data'>;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsListResults, ToolsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createToolRequest: CreateToolRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsCreateResults, ToolsCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete Tool
+     *
+     * Delete a tool and its published versions permanently.
+     */
+    delete<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsDeleteResults, ToolsDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * Get Tool
+     *
+     * Fetch one tool: behaviour flags, argument schema, draft operation tree
+     * and the list of published versions.
+     */
+    get<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsGetResults, ToolsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+        patchToolRequest: PatchToolRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsUpdateResults, ToolsUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+        publishToolRequest: PublishToolRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsPublishResults, ToolsPublishErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+        runToolRequest: RunToolRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsRunResults, ToolsRunErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        tool_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<ToolsValidateResults, ToolsValidateErrors, ThrowOnError, 'data'>;
+    private _versions?;
+    get versions(): Versions2;
+}
+export declare 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<ThrowOnError extends boolean = false>(parameters?: {
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<WebhooksListResults, WebhooksListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        createWebhookRequest: CreateWebhookRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<WebhooksCreateResults, WebhooksCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Event Types
+     *
+     * List every event a webhook can subscribe to, and which are emitted today.
+     */
+    eventTypes<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<WebhooksEventTypesResults, WebhooksEventTypesErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete Webhook
+     *
+     * Delete a webhook permanently.
+     */
+    delete<ThrowOnError extends boolean = false>(parameters: {
+        webhook_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<WebhooksDeleteResults, WebhooksDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * Patch Webhook
+     *
+     * Update a webhook's URL, subscriptions or status. Omitted fields are left
+     * unchanged; a disabled webhook stops receiving deliveries.
+     */
+    update<ThrowOnError extends boolean = false>(parameters: {
+        webhook_id: string;
+        patchWebhookRequest: PatchWebhookRequest;
+    }, options?: Options<never, ThrowOnError>): RequestResult<WebhooksUpdateResults, WebhooksUpdateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        webhook_id: string;
+        limit?: number;
+        offset?: number;
+    }, options?: Options<never, ThrowOnError>): RequestResult<WebhooksDeliveriesResults, WebhooksDeliveriesErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        webhook_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<WebhooksRotateSecretResults, WebhooksRotateSecretErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = false>(parameters: {
+        webhook_id: string;
+    }, options?: Options<never, ThrowOnError>): RequestResult<WebhooksTestResults, WebhooksTestErrors, ThrowOnError, 'data'>;
+}
+export declare class TalqingApi extends HeyApiClient {
+    static readonly __registry: HeyApiRegistry<TalqingApi>;
+    constructor(args?: {
+        client?: Client;
+        key?: string;
+    });
+    /**
+     * 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<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>): RequestResult<HealthResults, HealthErrors, ThrowOnError, 'data'>;
+    private _agents?;
+    get agents(): Agents;
+    private _auth?;
+    get auth(): Auth;
+    private _providerKeys?;
+    get providerKeys(): ProviderKeys;
+    private _calls?;
+    get calls(): Calls;
+    private _catalog?;
+    get catalog(): Catalog;
+    private _conversations?;
+    get conversations(): Conversations;
+    private _copilot?;
+    get copilot(): Copilot;
+    private _email?;
+    get email(): Email;
+    private _integrations?;
+    get integrations(): Integrations;
+    private _knowledge?;
+    get knowledge(): Knowledge2;
+    private _tokens?;
+    get tokens(): Tokens;
+    private _observability?;
+    get observability(): Observability;
+    private _orgs?;
+    get orgs(): Orgs;
+    private _schemas?;
+    get schemas(): Schemas;
+    private _secrets?;
+    get secrets(): Secrets;
+    private _tasks?;
+    get tasks(): Tasks2;
+    private _telephony?;
+    get telephony(): Telephony;
+    private _tools?;
+    get tools(): Tools2;
+    private _webhooks?;
+    get webhooks(): Webhooks;
+}
+export {};
+//# sourceMappingURL=sdk.gen.d.ts.map