@zavudev/sdk 0.58.1 → 0.59.0

package/src/v2/resources/agents/agents.ts

@@ -0,0 +1,142 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { Cursor, PagePromise } from '../../../core/pagination';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+import type * as T from '../../types';
+import * as ChannelsAPI from './channels';
+import { Channels, type ChannelConnectParams, type ChannelConnectResponse } from './channels';
+
+export class Agents extends APIResource {
+  channels: ChannelsAPI.Channels = new ChannelsAPI.Channels(this._client);
+
+  /**
+   * List agents
+   *
+   * `GET /v2/agents`
+   */
+  list(
+    query: AgentListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<AgentsCursor, Agent> {
+    return this._client.getAPIList('/v2/agents', Cursor<Agent>, { query, ...options });
+  }
+
+  /**
+   * Create an agent
+   *
+   * Connect it to an address with `POST /v2/agents/{agentId}/channels`.
+   *
+   * `POST /v2/agents`
+   */
+  create(body: AgentCreateParams, options?: RequestOptions): APIPromise<AgentCreateResponse> {
+    return this._client.post('/v2/agents', { body, ...options });
+  }
+
+  /**
+   * Get an agent
+   *
+   * `GET /v2/agents/{agentId}`
+   */
+  retrieve(agentID: string, options?: RequestOptions): APIPromise<AgentRetrieveResponse> {
+    return this._client.get(path`/v2/agents/${agentID}`, options);
+  }
+
+  /**
+   * Update an agent
+   *
+   * `PATCH /v2/agents/{agentId}`
+   */
+  update(
+    agentID: string,
+    body: AgentUpdateParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<AgentUpdateResponse> {
+    return this._client.patch(path`/v2/agents/${agentID}`, { body, ...options });
+  }
+
+  /**
+   * Delete an agent
+   *
+   * As `DELETE /v1/agents/{agentId}`.
+   *
+   * `DELETE /v2/agents/{agentId}`
+   */
+  delete(agentID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/v2/agents/${agentID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Test an agent
+   *
+   * Run the agent's prompt, model and knowledge base against a message and return
+   * the reply instead of delivering it. Nothing is delivered and no execution is
+   * recorded.
+   *
+   * **Billed like a live reply.** On an agent with the `zavu` provider the run is
+   * charged to your balance at the same price per token, and refused with `402
+   * insufficient_balance` at a balance of zero; on a bring-your-own-key agent it
+   * costs your provider. `cost` on the response is what it charged. Runs are rate
+   * limited per project (`429`).
+   *
+   * **Tools.** By default the model is offered the agent's enabled tools but none is
+   * run: if it picks one, the reply stops there and `plannedToolCalls` says which,
+   * with what arguments. Set `executeTools` to run them. That reaches your real
+   * handlers, with whatever they cost and change; read `executedToolCalls`.
+   *
+   * `POST /v2/agents/{agentId}/test`
+   */
+  test(agentID: string, body: AgentTestParams, options?: RequestOptions): APIPromise<AgentTestResponse> {
+    return this._client.post(path`/v2/agents/${agentID}/test`, { body, ...options });
+  }
+}
+
+export type AgentListParams = T.AgentsListParams;
+
+export type Agent = T.Agent;
+
+export type AgentsCursor = Cursor<T.Agent>;
+
+export type AgentProvider = T.AgentProvider;
+
+export type AgentVoiceConfig = T.AgentVoiceConfig;
+
+export type AgentCreateParams = T.AgentsCreateParams;
+
+export type AgentCreateResponse = T.CreateAgentV2Response;
+
+export type AgentRetrieveResponse = T.GetAgentV2Response;
+
+export type AgentUpdateParams = T.AgentsUpdateParams;
+
+export type AgentUpdateResponse = T.UpdateAgentV2Response;
+
+export type AgentTestParams = T.AgentsTestParams;
+
+export type AgentTestResponse = T.AgentTestResponse;
+
+export declare namespace Agents {
+  export {
+    type Agent as Agent,
+    type AgentCreateParams as AgentCreateParams,
+    type AgentCreateResponse as AgentCreateResponse,
+    type AgentListParams as AgentListParams,
+    type AgentProvider as AgentProvider,
+    type AgentRetrieveResponse as AgentRetrieveResponse,
+    type AgentTestParams as AgentTestParams,
+    type AgentTestResponse as AgentTestResponse,
+    type AgentUpdateParams as AgentUpdateParams,
+    type AgentUpdateResponse as AgentUpdateResponse,
+    type AgentVoiceConfig as AgentVoiceConfig,
+    type AgentsCursor as AgentsCursor,
+    Channels as Channels,
+    type ChannelConnectParams as ChannelConnectParams,
+    type ChannelConnectResponse as ChannelConnectResponse,
+  };
+}

package/src/v2/resources/agents/channels.ts

@@ -0,0 +1,66 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+import type * as T from '../../types';
+import { type ChannelType } from '../messages';
+
+export class Channels extends APIResource {
+  /**
+   * Connect an address
+   *
+   * Make the agent answer on an address. Connecting `{address, type}` connects the
+   * whole channel group that entry belongs to (the entries of `GET /v2/channels`
+   * that share its `v1SenderId`): the agent then answers on each transport of that
+   * group that its `triggerOnChannels` allows, which `channels` on the agent lists.
+   * `type` is what picks the group when two groups share the address.
+   *
+   * An address answers with one agent at a time; connecting one already answered by
+   * another agent returns `400` naming that agent.
+   *
+   * `POST /v2/agents/{agentId}/channels`
+   */
+  connect(
+    agentID: string,
+    body: ChannelConnectParams,
+    options?: RequestOptions,
+  ): APIPromise<ChannelConnectResponse> {
+    return this._client.post(path`/v2/agents/${agentID}/channels`, { body, ...options });
+  }
+
+  /**
+   * Disconnect an address
+   *
+   * Stop the agent answering on the address. This disconnects the channel group
+   * behind `{address, type}`, so every transport of that group stops reaching the
+   * agent. An agent created on /v1 for a sender keeps that sender: its addresses
+   * cannot be disconnected here, and that answers `400`.
+   *
+   * `DELETE /v2/agents/{agentId}/channels/{address}/{type}`
+   */
+  disconnect(
+    agentID: string,
+    address: string,
+    type: ChannelType,
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.delete(path`/v2/agents/${agentID}/channels/${address}/${type}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export type ChannelConnectParams = T.AgentsChannelsConnectParams;
+
+export type ChannelConnectResponse = T.ConnectAgentChannelV2Response;
+
+export declare namespace Channels {
+  export {
+    type ChannelConnectParams as ChannelConnectParams,
+    type ChannelConnectResponse as ChannelConnectResponse,
+  };
+}

package/src/v2/resources/agents/index.ts

@@ -0,0 +1,18 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+export {
+  Agents,
+  type AgentListParams,
+  type Agent,
+  type AgentsCursor,
+  type AgentProvider,
+  type AgentVoiceConfig,
+  type AgentCreateParams,
+  type AgentCreateResponse,
+  type AgentRetrieveResponse,
+  type AgentUpdateParams,
+  type AgentUpdateResponse,
+  type AgentTestParams,
+  type AgentTestResponse,
+} from './agents';
+export { Channels, type ChannelConnectParams, type ChannelConnectResponse } from './channels';

package/src/v2/resources/agents.ts

@@ -0,0 +1,3 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+export * from './agents/index';

package/src/v2/resources/campaigns/campaigns.ts

@@ -0,0 +1,178 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { Cursor, PagePromise } from '../../../core/pagination';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+import type * as T from '../../types';
+import * as RecipientsAPI from './recipients';
+import {
+  Recipients,
+  type RecipientAddParams,
+  type RecipientAddResponse,
+  type BroadcastContactInput,
+  type BroadcastContactsAddResponse,
+} from './recipients';
+
+export class Campaigns extends APIResource {
+  recipients: RecipientsAPI.Recipients = new RecipientsAPI.Recipients(this._client);
+
+  /**
+   * List campaigns
+   *
+   * Campaigns of this project, newest first, as `GET /v1/broadcasts`, each with
+   * `from` instead of `senderId`. Cursor pagination: pass `nextCursor` back as
+   * `cursor`.
+   *
+   * `GET /v2/campaigns`
+   */
+  list(
+    query: CampaignListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<BroadcastsCursor, Broadcast> {
+    return this._client.getAPIList('/v2/campaigns', Cursor<Broadcast>, { query, ...options });
+  }
+
+  /**
+   * Create a campaign
+   *
+   * A campaign is a /v1 broadcast; the id works on `/v1/broadcasts/{broadcastId}`.
+   * Runs `POST /v1/broadcasts` with the sender resolved from `from`. A repeated
+   * `idempotencyKey` answers `409 conflict` with the original in `details.campaign`.
+   * A `channel` the resolved sender does not carry (`smart`: no channel at all) is
+   * refused at creation with `409 no_channel`, as on `POST /v2/messages`, rather
+   * than created and failed at send. `from` with a `channel` it does not carry (a
+   * `sms` campaign `from: "sms_oneway"`) is that same `409 no_channel`, in the words
+   * `POST /v2/messages` uses (`details.connected`, and `sms` vs `sms_oneway` told
+   * apart); `channel` only picks between senders that share an address, it never
+   * makes an existing address `404`.
+   *
+   * `POST /v2/campaigns`
+   */
+  create(body: CampaignCreateParams, options?: RequestOptions): APIPromise<CampaignCreateResponse> {
+    return this._client.post('/v2/campaigns', { body, ...options });
+  }
+
+  /**
+   * Get a campaign
+   *
+   * `GET /v2/campaigns/{campaignId}`
+   */
+  retrieve(campaignID: string, options?: RequestOptions): APIPromise<CampaignRetrieveResponse> {
+    return this._client.get(path`/v2/campaigns/${campaignID}`, options);
+  }
+
+  /**
+   * Delete a draft campaign
+   *
+   * Deletes a campaign that is still a `draft`, as `DELETE
+   * /v1/broadcasts/{broadcastId}`. Any other status is refused with `409
+   * invalid_status` (`details.status`): a campaign that was sent or cancelled is
+   * kept as the record of what went out, and one still in review, scheduled or
+   * sending is cancelled with `POST /v2/campaigns/{campaignId}/cancel`
+   * (`details.recommendation`). /v1 refuses the same with a `400`.
+   *
+   * `DELETE /v2/campaigns/{campaignId}`
+   */
+  delete(campaignID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/v2/campaigns/${campaignID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Send or schedule a campaign
+   *
+   * Same review rules as `POST /v1/broadcasts/{broadcastId}/send`: a WhatsApp
+   * campaign on an approved template starts directly, email starts once automated
+   * review passes, other channels wait for a person. Omit `scheduledAt` to send now.
+   *
+   * `POST /v2/campaigns/{campaignId}/send`
+   */
+  send(
+    campaignID: string,
+    body: CampaignSendParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<CampaignSendResponse> {
+    return this._client.post(path`/v2/campaigns/${campaignID}/send`, { body, ...options });
+  }
+
+  /**
+   * Get campaign progress
+   *
+   * `GET /v2/campaigns/{campaignId}/progress`
+   */
+  progress(campaignID: string, options?: RequestOptions): APIPromise<CampaignProgressResponse> {
+    return this._client.get(path`/v2/campaigns/${campaignID}/progress`, options);
+  }
+
+  /**
+   * Cancel a campaign
+   *
+   * As `POST /v1/broadcasts/{broadcastId}/cancel`. Recipients not yet sent are
+   * skipped; messages already queued may still be delivered.
+   *
+   * `POST /v2/campaigns/{campaignId}/cancel`
+   */
+  cancel(campaignID: string, options?: RequestOptions): APIPromise<CampaignCancelResponse> {
+    return this._client.post(path`/v2/campaigns/${campaignID}/cancel`, options);
+  }
+}
+
+export type CampaignListParams = T.CampaignsListParams;
+
+export type Broadcast = T.Broadcast;
+
+export type BroadcastsCursor = Cursor<T.Broadcast>;
+
+export type BroadcastChannel = T.BroadcastChannel;
+
+export type BroadcastContent = T.BroadcastContent;
+
+export type BroadcastMessageType = T.BroadcastMessageType;
+
+export type BroadcastStatus = T.BroadcastStatus;
+
+export type CampaignCreateParams = T.CampaignsCreateParams;
+
+export type CampaignCreateResponse = T.CreateCampaignV2Response;
+
+export type CampaignRetrieveResponse = T.GetCampaignV2Response;
+
+export type CampaignSendParams = T.CampaignsSendParams;
+
+export type CampaignSendResponse = T.SendCampaignV2Response;
+
+export type CampaignProgressResponse = T.BroadcastProgress;
+
+export type BroadcastProgress = T.BroadcastProgress;
+
+export type CampaignCancelResponse = T.CancelCampaignV2Response;
+
+export declare namespace Campaigns {
+  export {
+    type Broadcast as Broadcast,
+    type BroadcastChannel as BroadcastChannel,
+    type BroadcastContent as BroadcastContent,
+    type BroadcastMessageType as BroadcastMessageType,
+    type BroadcastProgress as BroadcastProgress,
+    type BroadcastStatus as BroadcastStatus,
+    type BroadcastsCursor as BroadcastsCursor,
+    type CampaignCancelResponse as CampaignCancelResponse,
+    type CampaignCreateParams as CampaignCreateParams,
+    type CampaignCreateResponse as CampaignCreateResponse,
+    type CampaignListParams as CampaignListParams,
+    type CampaignProgressResponse as CampaignProgressResponse,
+    type CampaignRetrieveResponse as CampaignRetrieveResponse,
+    type CampaignSendParams as CampaignSendParams,
+    type CampaignSendResponse as CampaignSendResponse,
+    Recipients as Recipients,
+    type RecipientAddParams as RecipientAddParams,
+    type RecipientAddResponse as RecipientAddResponse,
+    type BroadcastContactInput as BroadcastContactInput,
+    type BroadcastContactsAddResponse as BroadcastContactsAddResponse,
+  };
+}

package/src/v2/resources/campaigns/index.ts

@@ -0,0 +1,27 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+export {
+  Campaigns,
+  type CampaignListParams,
+  type Broadcast,
+  type BroadcastsCursor,
+  type BroadcastChannel,
+  type BroadcastContent,
+  type BroadcastMessageType,
+  type BroadcastStatus,
+  type CampaignCreateParams,
+  type CampaignCreateResponse,
+  type CampaignRetrieveResponse,
+  type CampaignSendParams,
+  type CampaignSendResponse,
+  type CampaignProgressResponse,
+  type BroadcastProgress,
+  type CampaignCancelResponse,
+} from './campaigns';
+export {
+  Recipients,
+  type RecipientAddParams,
+  type RecipientAddResponse,
+  type BroadcastContactInput,
+  type BroadcastContactsAddResponse,
+} from './recipients';

package/src/v2/resources/campaigns/recipients.ts

@@ -0,0 +1,62 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+import type * as T from '../../types';
+
+export class Recipients extends APIResource {
+  /**
+   * Add recipients
+   *
+   * Up to 1,000 per call. Recipients are held to the rules `POST /v2/messages` holds
+   * `to` to. Validation happens in two steps with different outcomes:
+   *
+   * 1. **The request as a whole.** A phone number written with spaces, dashes, dots
+   * or parentheses after its `+` is read as the E.164 number first. Then a recipient
+   * that is not a phone number, email address, BSUID or chat id makes the whole
+   * request `400`, with `details.errors[].path` naming it (`["contacts", 2,
+   * "recipient"]`); so do 8-15 bare digits on an `sms`, `sms_oneway`, `whatsapp`,
+   * `voice` or `smart` campaign, with `details.errors[].suggestion` (`+<digits>`),
+   * as a send refuses them. Nothing is added.
+   * 2. **Each recipient against the campaign.** A well-formed recipient the campaign
+   * cannot reach is skipped and reported in `invalid` and `errors[{recipient,
+   * reason, code?}]`: `code: "unreachable_by_channel"` for an email address on a
+   * phone campaign or a phone number on an email campaign; `code:
+   * "ten_dlc_required"` for a US/Canadian (+1) number on an `sms` or `sms_oneway`
+   * campaign while this project has no approved 10DLC campaign (the send would
+   * refuse it, as `POST /v2/messages` answers `403 ten_dlc_required`). Repeats of a
+   * recipient already in the campaign or in the same call are skipped as
+   * `duplicates`. The others are added, and the call answers `201`.
+   *
+   * So `201` can mean some were not added: check `invalid`. A campaign that is not a
+   * draft answers `409 invalid_status`.
+   *
+   * `POST /v2/campaigns/{campaignId}/recipients`
+   */
+  add(
+    campaignID: string,
+    body: RecipientAddParams,
+    options?: RequestOptions,
+  ): APIPromise<RecipientAddResponse> {
+    return this._client.post(path`/v2/campaigns/${campaignID}/recipients`, { body, ...options });
+  }
+}
+
+export type RecipientAddParams = T.CampaignsRecipientsAddParams;
+
+export type RecipientAddResponse = T.BroadcastContactsAddResponse;
+
+export type BroadcastContactInput = T.BroadcastContactInput;
+
+export type BroadcastContactsAddResponse = T.BroadcastContactsAddResponse;
+
+export declare namespace Recipients {
+  export {
+    type BroadcastContactInput as BroadcastContactInput,
+    type BroadcastContactsAddResponse as BroadcastContactsAddResponse,
+    type RecipientAddParams as RecipientAddParams,
+    type RecipientAddResponse as RecipientAddResponse,
+  };
+}

package/src/v2/resources/campaigns.ts

@@ -0,0 +1,3 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+export * from './campaigns/index';

package/src/v2/resources/channels.ts

@@ -0,0 +1,156 @@
+// Generated by zavu-codegen from apps/docs/api-reference/v2/openapi.json. Do not edit: run `bun run codegen`.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { Cursor, PagePromise } from '../../core/pagination';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+import type * as T from '../types';
+import { type ChannelType } from './messages';
+
+/** Where the project can send from: one entry per (address, type). */
+export class Channels extends APIResource {
+  /**
+   * List channels
+   *
+   * Every (address, type) the project can send from, and whether it can send right
+   * now. Paginated by sender: a page holds every entry of up to `limit` senders, so
+   * it can hold more than `limit` entries.
+   *
+   * `GET /v2/channels`
+   */
+  list(
+    query: ChannelListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<ChannelEntriesCursor, ChannelEntry> {
+    return this._client.getAPIList('/v2/channels', Cursor<ChannelEntry>, { query, ...options });
+  }
+
+  /**
+   * Connect a channel
+   *
+   * Connect a channel without buying anything, so a new project can send its first
+   * message from /v2. Returns every entry of the connected address (`GET
+   * /v2/channels/{address}`).
+   *
+   * **Where it lands.** Channels are grouped: the entries of `GET /v2/channels` that
+   * share a `v1SenderId` are one group, and a group holds one connection per
+   * transport. The new channel joins the project's default group when that group
+   * does not carry the transport yet; otherwise, or when the project has none, it
+   * starts a new group (the first group of a project becomes its default). So in a
+   * fresh project every channel connected here lands on the default and `POST
+   * /v2/messages` needs no `from`; a second email address or a second bot starts its
+   * own group and is used by passing its address as `from`.
+   *
+   * **Idempotent** for `sms_oneway` and `email`: an address already connected
+   * answers `200` with its entries and changes nothing.
+   *
+   * **Active or not.** One-way SMS is active at once. An email or Telegram
+   * connection the plan includes is switched on by itself; one that would cost money
+   * is listed with `active: false` and is switched on with `POST
+   * /v2/channels/{address}/{type}/activate` (same price and limits as on /v1).
+   *
+   * A Telegram token that Telegram refuses leaves nothing behind.
+   *
+   * `POST /v2/channels`
+   */
+  connect(body: ChannelConnectParams, options?: RequestOptions): APIPromise<ChannelConnectResponse> {
+    return this._client.post('/v2/channels', { body, ...options });
+  }
+
+  /**
+   * Get the entries of one address
+   *
+   * Every transport the address carries, one entry each.
+   *
+   * `GET /v2/channels/{address}`
+   */
+  retrieve(address: string, options?: RequestOptions): APIPromise<ChannelRetrieveResponse> {
+    return this._client.get(path`/v2/channels/${address}`, options);
+  }
+
+  /**
+   * Activate a transport
+   *
+   * The same switch as **Activate** on Accounts in the dashboard, with the same
+   * price and limits: on a paid plan a month is charged at once, stated in
+   * `chargedCents` and `monthlyCents`. `activated: false` means it was already on
+   * and nothing was charged.
+   *
+   * `POST /v2/channels/{address}/{type}/activate`
+   */
+  activate(
+    address: string,
+    type: ActivatableChannel,
+    options?: RequestOptions,
+  ): APIPromise<ChannelActivateResponse> {
+    return this._client.post(path`/v2/channels/${address}/${type}/activate`, options);
+  }
+
+  /**
+   * Deactivate a transport
+   *
+   * Switch the connection off. It stays connected, so activating it again needs no
+   * reconnection. The month already paid is not refunded.
+   *
+   * `POST /v2/channels/{address}/{type}/deactivate`
+   */
+  deactivate(
+    address: string,
+    type: ActivatableChannel,
+    options?: RequestOptions,
+  ): APIPromise<ChannelDeactivateResponse> {
+    return this._client.post(path`/v2/channels/${address}/${type}/deactivate`, options);
+  }
+
+  /**
+   * Disconnect a channel
+   *
+   * Disconnect one (address, type). `sms_oneway`, `telegram` and `voice` can be
+   * disconnected here. The others answer `409 disconnect_unavailable` saying what to
+   * do instead: `whatsapp`, `instagram`, `messenger` and `email` can be switched off
+   * with `.../deactivate` (they stay connected); two-way `sms` comes with the
+   * address's number.
+   *
+   * `DELETE /v2/channels/{address}/{type}`
+   */
+  disconnect(address: string, type: ChannelType, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/v2/channels/${address}/${type}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export type ChannelListParams = T.ChannelsListParams;
+
+export type ChannelEntry = T.ChannelEntry;
+
+export type ChannelEntriesCursor = Cursor<T.ChannelEntry>;
+
+export type ChannelConnectParams = T.ChannelsConnectParams;
+
+export type ChannelConnectResponse = T.ConnectChannelV2Response;
+
+export type ChannelRetrieveResponse = T.GetChannelV2Response;
+
+export type ActivatableChannel = T.ActivatableChannel;
+
+export type ChannelActivateResponse = T.ActivateChannelV2Response;
+
+export type ChannelDeactivateResponse = T.DeactivateChannelV2Response;
+
+export declare namespace Channels {
+  export {
+    type ActivatableChannel as ActivatableChannel,
+    type ChannelActivateResponse as ChannelActivateResponse,
+    type ChannelConnectParams as ChannelConnectParams,
+    type ChannelConnectResponse as ChannelConnectResponse,
+    type ChannelDeactivateResponse as ChannelDeactivateResponse,
+    type ChannelEntriesCursor as ChannelEntriesCursor,
+    type ChannelEntry as ChannelEntry,
+    type ChannelListParams as ChannelListParams,
+    type ChannelRetrieveResponse as ChannelRetrieveResponse,
+  };
+}