@atribu/node 0.1.2 → 0.2.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { H as HttpClientLike, p as paths, R as RequestOptions } from './api.d-BXINTQo6.js';
-import { A as AtribuError } from './errors-D3ApBz8J.js';
-export { a as ApiErrorBody, b as ApiErrorCode, c as AtribuApiError, d as AtribuConfigError, e as AtribuOauthError, f as AtribuTransportError, g as AtribuWebhookError, O as OauthErrorCode, R as RetryHint, W as WebhookErrorCode } from './errors-D3ApBz8J.js';
+import { H as HttpClientLike, p as paths, R as RequestOptions } from './api.d-CRypizsD.js';
+import { d as AtribuError } from './errors-BLELoojK.js';
+export { A as ApiErrorBody, a as ApiErrorCode, b as AtribuApiError, c as AtribuConfigError, e as AtribuOauthError, f as AtribuTransportError, g as AtribuWebhookError, O as OauthErrorCode, R as RetryHint, W as WebhookErrorCode } from './errors-BLELoojK.js';
 
 interface AtribuClientConfig {
     apiKey: string;
@@ -47,21 +47,46 @@ declare class CommentsResource {
     privateReply(input: CommentPrivateReplyInput, opts?: CommentReplyOptions): Promise<CommentReplyResponse>;
 }
 
-type ListResponse = paths["/api/v1/webhooks/subscriptions"]["get"]["responses"][200]["content"]["application/json"];
-type CreateBody = NonNullable<paths["/api/v1/webhooks/subscriptions"]["post"]["requestBody"]>["content"]["application/json"];
-type CreateResponse = paths["/api/v1/webhooks/subscriptions"]["post"]["responses"][201]["content"]["application/json"];
-type UpdateBody = NonNullable<paths["/api/v1/webhooks/subscriptions/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
+type ListResponse$4 = paths["/api/v1/connections"]["get"]["responses"][200]["content"]["application/json"];
+type Connection = ListResponse$4["data"][number];
+interface ListOptions$3 {
+    channel?: "whatsapp" | "instagram";
+    signal?: AbortSignal;
+}
+interface MutationOptions$3 {
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+declare class ConnectionsResource {
+    private readonly http;
+    constructor(http: HttpClientLike);
+    list(opts?: ListOptions$3): Promise<Connection[]>;
+    get(id: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<Connection>;
+    /**
+     * Revoke this OAuth app's authorization for the connection. Does NOT
+     * disconnect the underlying data_connection (other consumers + the
+     * Atribu UI still see it). Direct admin keys reject this call with 400.
+     */
+    revoke(id: string, opts?: MutationOptions$3): Promise<void>;
+}
+
+type ListResponse$3 = paths["/api/v1/webhooks/subscriptions"]["get"]["responses"][200]["content"]["application/json"];
+type CreateBody$3 = NonNullable<paths["/api/v1/webhooks/subscriptions"]["post"]["requestBody"]>["content"]["application/json"];
+type CreateResponse$1 = paths["/api/v1/webhooks/subscriptions"]["post"]["responses"][201]["content"]["application/json"];
+type UpdateBody$1 = NonNullable<paths["/api/v1/webhooks/subscriptions/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
 type RotateBody = NonNullable<NonNullable<paths["/api/v1/webhooks/subscriptions/{id}/rotate-secret"]["post"]["requestBody"]>["content"]["application/json"]>;
 type RotateResponse = paths["/api/v1/webhooks/subscriptions/{id}/rotate-secret"]["post"]["responses"][200]["content"]["application/json"];
 type TestResponse = paths["/api/v1/webhooks/test/{id}"]["post"]["responses"][200]["content"]["application/json"];
-type WebhookSubscription = ListResponse["data"][number];
-type WebhookSubscriptionWithSecret = CreateResponse["data"];
-type WebhookSubscriptionCreateInput = CreateBody;
-type WebhookSubscriptionUpdateInput = UpdateBody;
+type WebhookSubscription = ListResponse$3["data"][number];
+type WebhookSubscriptionWithSecret = CreateResponse$1["data"];
+type WebhookSubscriptionCreateInput = CreateBody$3;
+type WebhookSubscriptionUpdateInput = UpdateBody$1;
 type WebhookSubscriptionRotateOptions = RotateBody;
 type WebhookSubscriptionRotateResult = RotateResponse["data"];
 type WebhookSubscriptionTestResult = TestResponse["data"];
-interface MutationOptions {
+interface MutationOptions$2 {
     idempotencyKey?: string;
     signal?: AbortSignal;
 }
@@ -71,11 +96,11 @@ declare class WebhookSubscriptionsResource {
     list(opts?: {
         signal?: AbortSignal;
     }): Promise<WebhookSubscription[]>;
-    create(input: WebhookSubscriptionCreateInput, opts?: MutationOptions): Promise<WebhookSubscriptionWithSecret>;
-    update(id: string, input: WebhookSubscriptionUpdateInput, opts?: MutationOptions): Promise<WebhookSubscription>;
-    delete(id: string, opts?: MutationOptions): Promise<void>;
-    rotateSecret(id: string, options?: WebhookSubscriptionRotateOptions, opts?: MutationOptions): Promise<WebhookSubscriptionRotateResult>;
-    test(id: string, opts?: MutationOptions): Promise<WebhookSubscriptionTestResult>;
+    create(input: WebhookSubscriptionCreateInput, opts?: MutationOptions$2): Promise<WebhookSubscriptionWithSecret>;
+    update(id: string, input: WebhookSubscriptionUpdateInput, opts?: MutationOptions$2): Promise<WebhookSubscription>;
+    delete(id: string, opts?: MutationOptions$2): Promise<void>;
+    rotateSecret(id: string, options?: WebhookSubscriptionRotateOptions, opts?: MutationOptions$2): Promise<WebhookSubscriptionRotateResult>;
+    test(id: string, opts?: MutationOptions$2): Promise<WebhookSubscriptionTestResult>;
 }
 
 type ReplayResponse = paths["/api/v1/webhooks/deliveries/{id}/replay"]["post"]["responses"][200]["content"]["application/json"];
@@ -90,6 +115,126 @@ declare class WebhookDeliveriesResource {
     replay(id: string, opts?: ReplayOptions): Promise<WebhookDeliveryReplayResult>;
 }
 
+type ListResponse$2 = paths["/api/v1/whatsapp/templates"]["get"]["responses"][200]["content"]["application/json"];
+type CreateBody$2 = NonNullable<paths["/api/v1/whatsapp/templates"]["post"]["requestBody"]>["content"]["application/json"];
+type CreateResponse = paths["/api/v1/whatsapp/templates"]["post"]["responses"][201]["content"]["application/json"];
+type WhatsAppTemplate = ListResponse$2["data"][number];
+type WhatsAppTemplateCreateInput = CreateBody$2;
+type WhatsAppTemplateCreateResult = CreateResponse["data"];
+interface ListOptions$2 {
+    connectionId: string;
+    signal?: AbortSignal;
+}
+interface DeleteOptions {
+    connectionId: string;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+interface CreateOptions {
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+declare class WhatsAppTemplatesResource {
+    private readonly http;
+    constructor(http: HttpClientLike);
+    list(opts: ListOptions$2): Promise<WhatsAppTemplate[]>;
+    create(input: WhatsAppTemplateCreateInput, opts?: CreateOptions): Promise<WhatsAppTemplateCreateResult>;
+    delete(name: string, opts: DeleteOptions): Promise<void>;
+}
+
+type ListResponse$1 = paths["/api/v1/whatsapp/broadcasts"]["get"]["responses"][200]["content"]["application/json"];
+type CreateBody$1 = NonNullable<paths["/api/v1/whatsapp/broadcasts"]["post"]["requestBody"]>["content"]["application/json"];
+type GetResponse = paths["/api/v1/whatsapp/broadcasts/{id}"]["get"]["responses"][200]["content"]["application/json"];
+type WhatsAppBroadcast = ListResponse$1["data"][number];
+type WhatsAppBroadcastDetail = GetResponse["data"];
+type WhatsAppBroadcastCreateInput = CreateBody$1;
+interface ListOptions$1 {
+    connectionId: string;
+    signal?: AbortSignal;
+}
+interface MutationOptions$1 {
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+declare class WhatsAppBroadcastsResource {
+    private readonly http;
+    constructor(http: HttpClientLike);
+    list(opts: ListOptions$1): Promise<WhatsAppBroadcast[]>;
+    create(input: WhatsAppBroadcastCreateInput, opts?: MutationOptions$1): Promise<WhatsAppBroadcast>;
+    get(id: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<WhatsAppBroadcastDetail>;
+    cancel(id: string, opts?: MutationOptions$1): Promise<WhatsAppBroadcast>;
+    /**
+     * Execute the broadcast. Long-running — iterates recipients with 100ms
+     * pacing between sends. Consider extending your HTTP client's timeout
+     * for broadcasts over a few hundred recipients (the Atribu server caps
+     * the route at 300s).
+     */
+    send(id: string, opts?: MutationOptions$1): Promise<WhatsAppBroadcast>;
+}
+
+/**
+ * WhatsApp-specific resource namespace. Mounted on `AtribuClient.whatsapp`.
+ * Cross-channel messaging stays on `AtribuClient.messages`.
+ */
+declare class WhatsAppNamespace {
+    readonly templates: WhatsAppTemplatesResource;
+    readonly broadcasts: WhatsAppBroadcastsResource;
+    constructor(http: HttpClientLike);
+}
+
+type ListResponse = paths["/api/v1/instagram/triggers"]["get"]["responses"][200]["content"]["application/json"];
+type CreateBody = NonNullable<paths["/api/v1/instagram/triggers"]["post"]["requestBody"]>["content"]["application/json"];
+type UpdateBody = NonNullable<paths["/api/v1/instagram/triggers/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
+type TestDmBody = NonNullable<paths["/api/v1/instagram/triggers/{id}/test-dm"]["post"]["requestBody"]>["content"]["application/json"];
+type TestDmResponse = paths["/api/v1/instagram/triggers/{id}/test-dm"]["post"]["responses"][200]["content"]["application/json"];
+type ResumeResponse = paths["/api/v1/instagram/triggers/resume"]["post"]["responses"][200]["content"]["application/json"];
+type InstagramTrigger = ListResponse["data"][number];
+type InstagramTriggerCreateInput = CreateBody;
+type InstagramTriggerUpdateInput = UpdateBody;
+interface ListOptions {
+    connectionId: string;
+    signal?: AbortSignal;
+}
+interface MutationOptions {
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+interface ResumeOptions extends MutationOptions {
+    connectionId: string;
+}
+declare class InstagramTriggersResource {
+    private readonly http;
+    constructor(http: HttpClientLike);
+    list(opts: ListOptions): Promise<InstagramTrigger[]>;
+    create(input: InstagramTriggerCreateInput, opts?: MutationOptions): Promise<InstagramTrigger>;
+    update(id: string, input: InstagramTriggerUpdateInput, opts?: MutationOptions): Promise<InstagramTrigger>;
+    delete(id: string, opts?: MutationOptions): Promise<void>;
+    /**
+     * Send the trigger's `opening_message` as a one-off DM to a test IGSID.
+     * Uses Meta's HUMAN_AGENT tag — recipient must have DMed the IG account
+     * in the past 7 days, otherwise Meta rejects the send.
+     */
+    testDm(id: string, input: TestDmBody, opts?: MutationOptions): Promise<TestDmResponse["data"]>;
+    /**
+     * Manually clear the comment-to-DM circuit breaker for the connection's
+     * IG account. The breaker normally clears itself once spam signals
+     * subside; this method exists for ops intervention.
+     */
+    resumeCircuit(opts: ResumeOptions): Promise<ResumeResponse["data"]>;
+}
+
+/**
+ * Instagram-specific resource namespace. Mounted on `AtribuClient.instagram`.
+ * Cross-channel messaging stays on `AtribuClient.messages` and
+ * `AtribuClient.comments`.
+ */
+declare class InstagramNamespace {
+    readonly triggers: InstagramTriggersResource;
+    constructor(http: HttpClientLike);
+}
+
 /**
  * Opt-in retry layer.
  *
@@ -158,15 +303,21 @@ declare function isRetryableError(err: unknown): err is AtribuError;
 interface ResourceBundle {
     messages: MessagesResource;
     comments: CommentsResource;
+    connections: ConnectionsResource;
     webhooks: {
         subscriptions: WebhookSubscriptionsResource;
         deliveries: WebhookDeliveriesResource;
     };
+    whatsapp: WhatsAppNamespace;
+    instagram: InstagramNamespace;
 }
 declare class AtribuClient {
     readonly messages: MessagesResource;
     readonly comments: CommentsResource;
+    readonly connections: ConnectionsResource;
     readonly webhooks: ResourceBundle["webhooks"];
+    readonly whatsapp: WhatsAppNamespace;
+    readonly instagram: InstagramNamespace;
     /** @internal — exposed for `withRetry` chaining; do not depend on this. */
     protected readonly _http: HttpClientLike;
     constructor(config: AtribuClientConfig);
@@ -189,10 +340,10 @@ declare class AtribuClient {
     private static _fromHttp;
 }
 
-declare const SDK_VERSION = "0.1.2";
+declare const SDK_VERSION = "0.1.4";
 
 type Runtime = "node" | "bun" | "deno" | "edge" | "browser" | "unknown";
 declare function detectRuntime(): Runtime;
 declare function runtimeTag(): string;
 
-export { AtribuClient, type AtribuClientConfig, AtribuError, type BackoffStrategy, type CommentPrivateReplyInput, type CommentReplyInput, type CommentReplyOptions, type CommentReplyResponse, type MessageContent, type MessageSendInput, type MessageSendResponse, type MutationOptions, type ReplayOptions, type RetryOptions, RetryingHttpClient, type Runtime, SDK_VERSION, type SendOptions, type WebhookDeliveryReplayResult, type WebhookSubscription, type WebhookSubscriptionCreateInput, type WebhookSubscriptionRotateOptions, type WebhookSubscriptionRotateResult, type WebhookSubscriptionTestResult, type WebhookSubscriptionUpdateInput, type WebhookSubscriptionWithSecret, detectRuntime, isRetryableError, runtimeTag };
+export { AtribuClient, type AtribuClientConfig, AtribuError, type BackoffStrategy, type CommentPrivateReplyInput, type CommentReplyInput, type CommentReplyOptions, type CommentReplyResponse, type Connection, type InstagramTrigger, type InstagramTriggerCreateInput, type InstagramTriggerUpdateInput, type MessageContent, type MessageSendInput, type MessageSendResponse, type MutationOptions$2 as MutationOptions, type ReplayOptions, type RetryOptions, RetryingHttpClient, type Runtime, SDK_VERSION, type SendOptions, type WebhookDeliveryReplayResult, type WebhookSubscription, type WebhookSubscriptionCreateInput, type WebhookSubscriptionRotateOptions, type WebhookSubscriptionRotateResult, type WebhookSubscriptionTestResult, type WebhookSubscriptionUpdateInput, type WebhookSubscriptionWithSecret, type WhatsAppBroadcast, type WhatsAppBroadcastCreateInput, type WhatsAppBroadcastDetail, type WhatsAppTemplate, type WhatsAppTemplateCreateInput, type WhatsAppTemplateCreateResult, detectRuntime, isRetryableError, runtimeTag };

package/dist/index.js

@@ -126,7 +126,7 @@ function parseRetryAfter(header) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.2";
+var SDK_VERSION = "0.1.4";
 
 // src/runtime.ts
 function detectRuntime() {
@@ -154,6 +154,7 @@ var HttpClient = class {
   constructor(cfg) {
     this.cfg = cfg;
   }
+  cfg;
   async request(opts) {
     const url = this.buildUrl(opts.path, opts.query);
     const headers = this.buildHeaders(opts);
@@ -284,6 +285,7 @@ var MessagesResource = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async send(input, opts = {}) {
     const res = await this.http.request({
       method: "POST",
@@ -301,6 +303,7 @@ var CommentsResource = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async reply(input, opts = {}) {
     const { comment_id, ...body } = input;
     const res = await this.http.request({
@@ -325,11 +328,51 @@ var CommentsResource = class {
   }
 };
 
+// src/resources/connections.ts
+var ConnectionsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async list(opts = {}) {
+    const qs = opts.channel ? `?channel=${encodeURIComponent(opts.channel)}` : "";
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/connections${qs}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/connections/${encodeURIComponent(id)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Revoke this OAuth app's authorization for the connection. Does NOT
+   * disconnect the underlying data_connection (other consumers + the
+   * Atribu UI still see it). Direct admin keys reject this call with 400.
+   */
+  async revoke(id, opts = {}) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/api/v1/connections/${encodeURIComponent(id)}`,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal,
+      expectEmpty: true
+    });
+  }
+};
+
 // src/resources/webhook-subscriptions.ts
 var WebhookSubscriptionsResource = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async list(opts = {}) {
     const res = await this.http.request({
       method: "GET",
@@ -393,6 +436,7 @@ var WebhookDeliveriesResource = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async replay(id, opts = {}) {
     const res = await this.http.request({
       method: "POST",
@@ -404,6 +448,195 @@ var WebhookDeliveriesResource = class {
   }
 };
 
+// src/resources/whatsapp/templates.ts
+var WhatsAppTemplatesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async list(opts) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/whatsapp/templates?connection_id=${encodeURIComponent(opts.connectionId)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/whatsapp/templates",
+      body: input,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(name, opts) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/api/v1/whatsapp/templates/${encodeURIComponent(name)}?connection_id=${encodeURIComponent(opts.connectionId)}`,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal,
+      expectEmpty: true
+    });
+  }
+};
+
+// src/resources/whatsapp/broadcasts.ts
+var WhatsAppBroadcastsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async list(opts) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/whatsapp/broadcasts?connection_id=${encodeURIComponent(opts.connectionId)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/whatsapp/broadcasts",
+      body: input,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/whatsapp/broadcasts/${encodeURIComponent(id)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async cancel(id, opts = {}) {
+    const body = { status: "cancelled" };
+    const res = await this.http.request({
+      method: "PATCH",
+      path: `/api/v1/whatsapp/broadcasts/${encodeURIComponent(id)}`,
+      body,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Execute the broadcast. Long-running — iterates recipients with 100ms
+   * pacing between sends. Consider extending your HTTP client's timeout
+   * for broadcasts over a few hundred recipients (the Atribu server caps
+   * the route at 300s).
+   */
+  async send(id, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/whatsapp/broadcasts/${encodeURIComponent(id)}/send`,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// src/resources/whatsapp/index.ts
+var WhatsAppNamespace = class {
+  templates;
+  broadcasts;
+  constructor(http) {
+    this.templates = new WhatsAppTemplatesResource(http);
+    this.broadcasts = new WhatsAppBroadcastsResource(http);
+  }
+};
+
+// src/resources/instagram/triggers.ts
+var InstagramTriggersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async list(opts) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/instagram/triggers?connection_id=${encodeURIComponent(opts.connectionId)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/instagram/triggers",
+      body: input,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await this.http.request({
+      method: "PATCH",
+      path: `/api/v1/instagram/triggers/${encodeURIComponent(id)}`,
+      body: input,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/api/v1/instagram/triggers/${encodeURIComponent(id)}`,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal,
+      expectEmpty: true
+    });
+  }
+  /**
+   * Send the trigger's `opening_message` as a one-off DM to a test IGSID.
+   * Uses Meta's HUMAN_AGENT tag — recipient must have DMed the IG account
+   * in the past 7 days, otherwise Meta rejects the send.
+   */
+  async testDm(id, input, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/instagram/triggers/${encodeURIComponent(id)}/test-dm`,
+      body: input,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Manually clear the comment-to-DM circuit breaker for the connection's
+   * IG account. The breaker normally clears itself once spam signals
+   * subside; this method exists for ops intervention.
+   */
+  async resumeCircuit(opts) {
+    const body = { connection_id: opts.connectionId };
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/instagram/triggers/resume",
+      body,
+      idempotencyKey: opts.idempotencyKey,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// src/resources/instagram/index.ts
+var InstagramNamespace = class {
+  triggers;
+  constructor(http) {
+    this.triggers = new InstagramTriggersResource(http);
+  }
+};
+
 // src/retry-wrapper.ts
 function resolveRetry(o) {
   return {
@@ -421,6 +654,7 @@ var RetryingHttpClient = class {
     this.base = base;
     this.r = resolveRetry(options);
   }
+  base;
   r;
   async request(opts) {
     let lastErr;
@@ -480,16 +714,22 @@ function buildResources(http) {
   return {
     messages: new MessagesResource(http),
     comments: new CommentsResource(http),
+    connections: new ConnectionsResource(http),
     webhooks: {
       subscriptions: new WebhookSubscriptionsResource(http),
       deliveries: new WebhookDeliveriesResource(http)
-    }
+    },
+    whatsapp: new WhatsAppNamespace(http),
+    instagram: new InstagramNamespace(http)
   };
 }
 var AtribuClient = class _AtribuClient {
   messages;
   comments;
+  connections;
   webhooks;
+  whatsapp;
+  instagram;
   /** @internal — exposed for `withRetry` chaining; do not depend on this. */
   _http;
   constructor(config) {
@@ -497,7 +737,10 @@ var AtribuClient = class _AtribuClient {
     const r = buildResources(this._http);
     this.messages = r.messages;
     this.comments = r.comments;
+    this.connections = r.connections;
     this.webhooks = r.webhooks;
+    this.whatsapp = r.whatsapp;
+    this.instagram = r.instagram;
   }
   /**
    * Returns a new AtribuClient that retries on transient errors. The
@@ -525,7 +768,10 @@ var AtribuClient = class _AtribuClient {
       _http: http,
       messages: r.messages,
       comments: r.comments,
-      webhooks: r.webhooks
+      connections: r.connections,
+      webhooks: r.webhooks,
+      whatsapp: r.whatsapp,
+      instagram: r.instagram
     });
     return proto;
   }