@wassist/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1134 @@
+'use strict';
+
+const __sdkRequire = require;
+
+// src/errors.ts
+var WassistError = class extends Error {
+  /** HTTP status code if this error originated from an API response. */
+  statusCode;
+  /** Machine-readable error code (e.g. `not_found`) when the API provides one. */
+  code;
+  /**
+   * Request ID surfaced by the Wassist API in the `X-Request-Id` response
+   * header. Include this when filing support tickets.
+   */
+  requestId;
+  /** Raw response body, parsed as JSON when possible. */
+  raw;
+  constructor(opts) {
+    super(opts.message);
+    this.name = new.target.name;
+    this.statusCode = opts.statusCode;
+    this.code = opts.code;
+    this.requestId = opts.requestId;
+    this.raw = opts.raw;
+    if (opts.cause !== void 0) {
+      this.cause = opts.cause;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WassistAuthenticationError = class extends WassistError {
+};
+var WassistPermissionError = class extends WassistError {
+};
+var WassistInvalidRequestError = class extends WassistError {
+};
+var WassistNotFoundError = class extends WassistError {
+};
+var WassistConflictError = class extends WassistError {
+};
+var WassistRateLimitError = class extends WassistError {
+  /** Suggested wait in seconds, from the `Retry-After` response header. */
+  retryAfter;
+  constructor(opts) {
+    super(opts);
+    this.retryAfter = opts.retryAfter;
+  }
+};
+var WassistAPIError = class extends WassistError {
+};
+var WassistConnectionError = class extends WassistError {
+};
+var WassistTimeoutError = class extends WassistError {
+};
+var WassistSignatureVerificationError = class extends WassistError {
+  /** The raw `X-Wassist-Signature` header value as received. */
+  header;
+  /** The payload that was verified, as the SDK saw it. */
+  payload;
+  constructor(opts) {
+    super(opts);
+    this.header = opts.header;
+    this.payload = opts.payload;
+  }
+};
+function errorFromResponse(args) {
+  const { status, body, requestId, retryAfter } = args;
+  const message = extractMessage(body) ?? `HTTP ${status}`;
+  const code = extractCode(body);
+  const base = { message, statusCode: status, code, requestId, raw: body };
+  if (status === 401) return new WassistAuthenticationError(base);
+  if (status === 403) return new WassistPermissionError(base);
+  if (status === 404) return new WassistNotFoundError(base);
+  if (status === 409) return new WassistConflictError(base);
+  if (status === 429) return new WassistRateLimitError({ ...base, retryAfter });
+  if (status === 400 || status === 422) {
+    return new WassistInvalidRequestError(base);
+  }
+  if (status >= 500 && status < 600) return new WassistAPIError(base);
+  return new WassistError(base);
+}
+function extractMessage(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (typeof b.error === "string") return b.error;
+  if (typeof b.message === "string") return b.message;
+  if (typeof b.detail === "string") return b.detail;
+  if (b.error && typeof b.error === "object") {
+    const inner = b.error.message;
+    if (typeof inner === "string") return inner;
+  }
+  return void 0;
+}
+function extractCode(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (typeof b.code === "string") return b.code;
+  return void 0;
+}
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://backend.wassist.app";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var API_VERSION_PREFIX = "/api/v1";
+var RETRY_STATUSES = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  fetchImpl;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new WassistError({
+        message: "A Wassist `apiKey` is required. Create one at https://wassist.app/settings."
+      });
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const provided = config.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!provided) {
+      throw new WassistError({
+        message: "No `fetch` implementation found. Pass one via `fetch` in the Wassist constructor, or run on Node 18+ / a runtime with a global `fetch`."
+      });
+    }
+    this.fetchImpl = provided;
+  }
+  get(path, args) {
+    return this.request({ ...args, method: "GET", path });
+  }
+  post(path, body, options) {
+    return this.request({ method: "POST", path, body, options });
+  }
+  put(path, body, options) {
+    return this.request({ method: "PUT", path, body, options });
+  }
+  patch(path, body, options) {
+    return this.request({ method: "PATCH", path, body, options });
+  }
+  delete(path, options) {
+    return this.request({ method: "DELETE", path, options });
+  }
+  async request(args) {
+    const url = this.buildUrl(args.path, args.query);
+    const headers = this.buildHeaders(args);
+    const body = args.body === void 0 ? void 0 : JSON.stringify(args.body);
+    const maxRetries = args.options?.maxRetries ?? this.maxRetries;
+    const timeout = args.options?.timeout ?? this.timeout;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await this.doFetch({
+          url,
+          method: args.method,
+          headers,
+          body,
+          timeout,
+          signal: args.options?.signal
+        });
+        if (response.ok) {
+          if (response.status === 204) return void 0;
+          const text = await response.text();
+          if (!text) return void 0;
+          return JSON.parse(text);
+        }
+        const requestId = response.headers.get("x-request-id") ?? void 0;
+        const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+        const parsedBody = await safeJson(response);
+        const apiError = errorFromResponse({
+          status: response.status,
+          body: parsedBody,
+          requestId,
+          retryAfter
+        });
+        const isRetryable = RETRY_STATUSES.has(response.status);
+        if (isRetryable && attempt < maxRetries) {
+          await sleep(computeBackoff(attempt, apiError));
+          lastError = apiError;
+          continue;
+        }
+        throw apiError;
+      } catch (err) {
+        if (err instanceof WassistError) {
+          if (attempt < maxRetries && (err instanceof WassistRateLimitError || isRetryableApiError(err))) {
+            await sleep(computeBackoff(attempt, err));
+            lastError = err;
+            continue;
+          }
+          throw err;
+        }
+        const mapped = mapFetchError(err);
+        if (attempt < maxRetries && isRetryableTransport(mapped)) {
+          await sleep(computeBackoff(attempt));
+          lastError = mapped;
+          continue;
+        }
+        throw mapped;
+      }
+    }
+    throw lastError instanceof Error ? lastError : new WassistError({ message: "Wassist request failed after retries." });
+  }
+  buildUrl(path, query) {
+    const prefixedPath = path.startsWith("/") ? path : `/${path}`;
+    const fullPath = prefixedPath.startsWith(API_VERSION_PREFIX) ? prefixedPath : `${API_VERSION_PREFIX}${prefixedPath}`;
+    const url = new URL(this.baseUrl + fullPath);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0 || value === null) continue;
+        url.searchParams.append(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(args) {
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "Accept": "application/json",
+      "User-Agent": `wassist-sdk-node/${SDK_VERSION}`,
+      "X-Wassist-Client": `wassist-sdk-node/${SDK_VERSION}`
+    };
+    if (args.body !== void 0) headers["Content-Type"] = "application/json";
+    if (args.options?.idempotencyKey) {
+      headers["Idempotency-Key"] = args.options.idempotencyKey;
+    }
+    if (args.options?.headers) {
+      for (const [k, v] of Object.entries(args.options.headers)) headers[k] = v;
+    }
+    return headers;
+  }
+  async doFetch(args) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    if (args.signal) {
+      if (args.signal.aborted) controller.abort();
+      else args.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timeoutId = setTimeout(() => controller.abort(), args.timeout);
+    try {
+      return await this.fetchImpl(args.url, {
+        method: args.method,
+        headers: args.headers,
+        body: args.body,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+      if (args.signal) args.signal.removeEventListener("abort", onAbort);
+    }
+  }
+};
+function safeJson(response) {
+  return response.text().then((text) => {
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }).catch(() => void 0);
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const asNum = Number(value);
+  if (Number.isFinite(asNum) && asNum >= 0) return asNum;
+  const asDate = Date.parse(value);
+  if (Number.isNaN(asDate)) return void 0;
+  return Math.max(0, Math.floor((asDate - Date.now()) / 1e3));
+}
+function computeBackoff(attempt, err) {
+  if (err instanceof WassistRateLimitError && typeof err.retryAfter === "number") {
+    return err.retryAfter * 1e3;
+  }
+  const base = 500 * Math.pow(2, attempt);
+  const jitter = base * Math.random();
+  return Math.min(base + jitter, 8e3);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableApiError(err) {
+  return err.statusCode !== void 0 && RETRY_STATUSES.has(err.statusCode);
+}
+function isRetryableTransport(err) {
+  return err instanceof WassistConnectionError;
+}
+function mapFetchError(err) {
+  if (err instanceof Error) {
+    if (err.name === "AbortError") {
+      return new WassistTimeoutError({
+        message: "Request timed out.",
+        cause: err
+      });
+    }
+    return new WassistConnectionError({
+      message: `Network error: ${err.message}`,
+      cause: err
+    });
+  }
+  return new WassistConnectionError({ message: "Unknown network error." });
+}
+
+// src/pagination.ts
+var AutoPaginatedList = class {
+  fetchPage;
+  params;
+  options;
+  /** @internal */
+  constructor(fetchPage, params = {}, options) {
+    this.fetchPage = fetchPage;
+    this.params = params;
+    this.options = options;
+  }
+  /**
+   * Async iterator over every item across every page, fetched lazily.
+   */
+  async *[Symbol.asyncIterator]() {
+    const limit = this.params.limit ?? 50;
+    let offset = this.params.offset ?? 0;
+    let hasMore = true;
+    while (hasMore) {
+      const page = await this.fetchPage({ limit, offset });
+      for (const item of page.results) yield item;
+      hasMore = page.next !== null && page.results.length > 0;
+      offset += page.results.length || limit;
+    }
+  }
+  /**
+   * Fetch the first page only and return it as a {@link Page}.
+   */
+  async firstPage() {
+    const limit = this.params.limit ?? 50;
+    const offset = this.params.offset ?? 0;
+    const page = await this.fetchPage({ limit, offset });
+    return {
+      data: page.results,
+      totalCount: page.count,
+      hasMore: page.next !== null,
+      nextOffset: offset + page.results.length
+    };
+  }
+  /**
+   * Walk every page and collect every item into a single array.
+   *
+   * Convenient for small lists; for large ones prefer `for await`.
+   */
+  async all() {
+    const out = [];
+    for await (const item of this) out.push(item);
+    return out;
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List every agent on your account.
+   *
+   * Returns a lazily-fetched paginated list. Use `for await` to walk all
+   * pages, or `.firstPage()` for just the first.
+   *
+   * `GET /agents/`
+   *
+   * @example
+   * ```ts
+   * for await (const agent of wassist.agents.list()) {
+   *   console.log(agent.id, agent.name);
+   * }
+   * ```
+   */
+  list(params = {}, options) {
+    return new AutoPaginatedList(
+      (p) => this.http.get("/agents/", { query: p, options }),
+      params,
+      options
+    );
+  }
+  /**
+   * Retrieve a single agent by ID.
+   *
+   * `GET /agents/{id}/`
+   */
+  get(id, options) {
+    return this.http.get(`/agents/${encodeURIComponent(id)}/`, { options });
+  }
+  /**
+   * Create a new agent with the given display name. Configure it further
+   * with {@link AgentsResource.update}.
+   *
+   * `POST /agents/`
+   */
+  create(input, options) {
+    return this.http.post("/agents/", input, options);
+  }
+  /**
+   * Create a Bring-Your-Own-Agent (BYOA) — Wassist forwards inbound
+   * messages to your webhook and posts back replies you author yourself.
+   *
+   * `POST /agents/byoa/`
+   */
+  createBYOA(input, options) {
+    return this.http.post("/agents/byoa/", input, options);
+  }
+  /**
+   * Partially update an agent. Only the fields you pass are modified.
+   *
+   * Nested sub-resource arrays (tools, memory keys, etc.) are diffed
+   * server-side by `id`: include an `id` to update an existing entry,
+   * omit it to create one.
+   *
+   * `PATCH /agents/{id}/`
+   */
+  update(id, input, options) {
+    return this.http.patch(`/agents/${encodeURIComponent(id)}/`, input, options);
+  }
+  /**
+   * Soft-delete an agent. The agent stops responding immediately;
+   * conversation history is retained.
+   *
+   * `DELETE /agents/{id}/`
+   */
+  delete(id, options) {
+    return this.http.delete(`/agents/${encodeURIComponent(id)}/`, options);
+  }
+};
+
+// src/resources/messages.ts
+var MessagesResource = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List messages in a conversation, newest first.
+   *
+   * `GET /conversations/{id}/messages/`
+   */
+  list(conversationId, params = {}, options) {
+    const path = `/conversations/${encodeURIComponent(conversationId)}/messages/`;
+    return new AutoPaginatedList(
+      (p) => this.http.get(path, { query: p, options }),
+      params,
+      options
+    );
+  }
+  /**
+   * Send a message in a conversation.
+   *
+   * The input is a discriminated union — set `type` and populate the
+   * matching field (`text`, `template`, `cta`, or `unified`).
+   *
+   * `POST /conversations/{id}/messages/`
+   *
+   * @example Plain text
+   * ```ts
+   * await wassist.conversations.messages.send(conv.id, {
+   *   type: 'text',
+   *   text: { body: 'Hello!' },
+   * });
+   * ```
+   *
+   * @example Approved template
+   * ```ts
+   * await wassist.conversations.messages.send(conv.id, {
+   *   type: 'template',
+   *   template: { name: 'order_update', variables: { body: ['Alex', '#1234'] } },
+   * });
+   * ```
+   */
+  send(conversationId, input, options) {
+    const path = `/conversations/${encodeURIComponent(conversationId)}/messages/`;
+    return this.http.post(path, input, options);
+  }
+};
+
+// src/resources/conversations.ts
+var ConversationsResource = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+    this.messages = new MessagesResource(http);
+  }
+  http;
+  /** Send and list messages within a conversation. */
+  messages;
+  /**
+   * List conversations on your account with rich filtering.
+   *
+   * `GET /conversations/`
+   *
+   * @example
+   * ```ts
+   * const recent = await wassist.conversations
+   *   .list({ ordering: '-last_message_time', limit: 20 })
+   *   .firstPage();
+   * ```
+   */
+  list(params = {}, options) {
+    const { limit, offset, ...filters } = params;
+    return new AutoPaginatedList(
+      (p) => this.http.get("/conversations/", {
+        query: { ...filters, ...p },
+        options
+      }),
+      { limit, offset },
+      options
+    );
+  }
+  /**
+   * Retrieve a single conversation by ID.
+   *
+   * `GET /conversations/{id}/`
+   */
+  get(id, options) {
+    return this.http.get(`/conversations/${encodeURIComponent(id)}/`, {
+      options
+    });
+  }
+  /**
+   * Create a new conversation with a contact.
+   *
+   * If the WhatsApp 24-hour reply window is closed for this contact, you
+   * must include a `template` message to open it.
+   *
+   * `POST /conversations/`
+   */
+  create(input, options) {
+    return this.http.post("/conversations/", input, options);
+  }
+  /**
+   * Prompt the agent in this conversation with a custom instruction.
+   * Equivalent to "wake the agent up and have it say this" — useful for
+   * outbound triggers and follow-ups.
+   *
+   * `POST /conversations/{id}/prompt/`
+   */
+  prompt(id, input, options) {
+    return this.http.post(
+      `/conversations/${encodeURIComponent(id)}/prompt/`,
+      input,
+      options
+    );
+  }
+  /**
+   * Send a WhatsApp read receipt for the most recent inbound message.
+   *
+   * `POST /conversations/{id}/read/`
+   */
+  read(id, options) {
+    return this.http.post(
+      `/conversations/${encodeURIComponent(id)}/read/`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Display the WhatsApp typing indicator on the contact's device.
+   *
+   * Note: WhatsApp also marks the most recent inbound message as read as
+   * a side effect — this is a platform limitation.
+   *
+   * `POST /conversations/{id}/typing/`
+   */
+  typing(id, options) {
+    return this.http.post(
+      `/conversations/${encodeURIComponent(id)}/typing/`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Route this conversation to a webhook. The agent pipeline is skipped
+   * while the override is active.
+   *
+   * Fires a `subscription.activated` event on the target webhook.
+   *
+   * `POST /conversations/{id}/subscribe/`
+   */
+  subscribe(id, input, options) {
+    return this.http.post(
+      `/conversations/${encodeURIComponent(id)}/subscribe/`,
+      input,
+      options
+    );
+  }
+  /**
+   * Clear the per-conversation routing override and fall back to the
+   * phone number's default routing.
+   *
+   * Fires a `subscription.revoked` event on the previously-subscribed
+   * webhook (if any).
+   *
+   * `POST /conversations/{id}/unsubscribe/`
+   */
+  unsubscribe(id, options) {
+    return this.http.post(
+      `/conversations/${encodeURIComponent(id)}/unsubscribe/`,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/phone-numbers.ts
+var PhoneNumbersResource = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List every WhatsApp number on your account.
+   *
+   * `GET /phone-numbers/`
+   */
+  list(params = {}, options) {
+    return new AutoPaginatedList(
+      (p) => this.http.get("/phone-numbers/", {
+        query: p,
+        options
+      }),
+      params,
+      options
+    );
+  }
+  /**
+   * View the WhatsApp Business Profile (about, address, websites, etc.)
+   * attached to this number.
+   *
+   * `GET /phone-numbers/{number}/business-profile/`
+   */
+  getBusinessProfile(number, options) {
+    return this.http.get(
+      `/phone-numbers/${encodeURIComponent(number)}/business-profile/`,
+      { options }
+    );
+  }
+  /**
+   * Route inbound messages on this number to a webhook by default. Drops
+   * any agent previously connected to the number.
+   *
+   * Phone-number routing changes do **not** fire
+   * `subscription.activated` / `.revoked` webhook events — those are
+   * reserved for per-conversation
+   * {@link ConversationsResource.subscribe} /
+   * {@link ConversationsResource.unsubscribe}.
+   *
+   * `POST /phone-numbers/{number}/subscribe/`
+   */
+  subscribe(number, input, options) {
+    return this.http.post(
+      `/phone-numbers/${encodeURIComponent(number)}/subscribe/`,
+      input,
+      options
+    );
+  }
+  /**
+   * Assign an agent as the default for this number. Drops any subscribed
+   * webhook.
+   *
+   * The agent must already be owned by or shared with the authenticated
+   * user.
+   *
+   * `POST /phone-numbers/{number}/connect-agent/`
+   */
+  connectAgent(number, input, options) {
+    return this.http.post(
+      `/phone-numbers/${encodeURIComponent(number)}/connect-agent/`,
+      input,
+      options
+    );
+  }
+  /**
+   * Clear default routing on this number entirely. Drops both the agent
+   * and the webhook.
+   *
+   * `POST /phone-numbers/{number}/unsubscribe/`
+   */
+  unsubscribe(number, input = {}, options) {
+    return this.http.post(
+      `/phone-numbers/${encodeURIComponent(number)}/unsubscribe/`,
+      input,
+      options
+    );
+  }
+};
+
+// src/resources/whatsapp-accounts.ts
+var WhatsAppAccountsResource = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List every WhatsApp Business Account on your Wassist account.
+   *
+   * `GET /whatsapp-accounts/`
+   */
+  list(params = {}, options) {
+    return new AutoPaginatedList(
+      (p) => this.http.get("/whatsapp-accounts/", {
+        query: p,
+        options
+      }),
+      params,
+      options
+    );
+  }
+  /**
+   * Retrieve a single WhatsApp Business Account by ID.
+   *
+   * `GET /whatsapp-accounts/{id}/`
+   */
+  get(id, options) {
+    return this.http.get(
+      `/whatsapp-accounts/${encodeURIComponent(id)}/`,
+      { options }
+    );
+  }
+  /**
+   * Add a pre-verified phone number (purchased via Meta's embedded
+   * signup flow) to a WhatsApp Business Account.
+   *
+   * `POST /whatsapp-accounts/{id}/add-number/`
+   */
+  addNumber(id, input, options) {
+    return this.http.post(
+      `/whatsapp-accounts/${encodeURIComponent(id)}/add-number/`,
+      input,
+      options
+    );
+  }
+  /**
+   * List Twilio phone numbers available for purchase + verification.
+   *
+   * `GET /available-numbers/`
+   */
+  availableNumbers(options) {
+    return this.http.get("/available-numbers/", { options });
+  }
+};
+
+// src/resources/whatsapp-link-sessions.ts
+var WhatsAppLinkSessionsResource = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List every link session you've created.
+   *
+   * `GET /whatsapp-link-sessions/`
+   */
+  list(params = {}, options) {
+    return new AutoPaginatedList(
+      (p) => this.http.get(
+        "/whatsapp-link-sessions/",
+        { query: p, options }
+      ),
+      params,
+      options
+    );
+  }
+  /**
+   * Retrieve a single link session by ID.
+   *
+   * `GET /whatsapp-link-sessions/{id}/`
+   */
+  get(id, options) {
+    return this.http.get(
+      `/whatsapp-link-sessions/${encodeURIComponent(id)}/`,
+      { options }
+    );
+  }
+  /**
+   * Create a new link session. Direct the user to the returned `linkUrl`.
+   *
+   * `POST /whatsapp-link-sessions/`
+   */
+  create(input, options) {
+    return this.http.post(
+      "/whatsapp-link-sessions/",
+      input,
+      options
+    );
+  }
+  /**
+   * Expire a pending link session early. Useful for invalidating stale
+   * URLs you've handed out to customers.
+   *
+   * `POST /whatsapp-link-sessions/{id}/expire/`
+   */
+  expire(id, options) {
+    return this.http.post(
+      `/whatsapp-link-sessions/${encodeURIComponent(id)}/expire/`,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/whatsapp-templates.ts
+var WhatsAppTemplatesResource = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List every template you've created in Wassist.
+   *
+   * `GET /whatsapp-templates/`
+   */
+  list(params = {}, options) {
+    return new AutoPaginatedList(
+      (p) => this.http.get("/whatsapp-templates/", {
+        query: p,
+        options
+      }),
+      params,
+      options
+    );
+  }
+  /**
+   * Retrieve a single template by ID.
+   *
+   * `GET /whatsapp-templates/{id}/`
+   */
+  get(id, options) {
+    return this.http.get(
+      `/whatsapp-templates/${encodeURIComponent(id)}/`,
+      { options }
+    );
+  }
+  /**
+   * Create a new template. Published per-WABA separately via {@link publish}.
+   *
+   * `POST /whatsapp-templates/`
+   */
+  create(input, options) {
+    return this.http.post("/whatsapp-templates/", input, options);
+  }
+  /**
+   * Update an existing template's metadata and components.
+   *
+   * `PATCH /whatsapp-templates/{id}/`
+   */
+  update(id, input, options) {
+    return this.http.patch(
+      `/whatsapp-templates/${encodeURIComponent(id)}/`,
+      input,
+      options
+    );
+  }
+  /**
+   * Delete a template (and unpublish from every WABA it was published to).
+   *
+   * `DELETE /whatsapp-templates/{id}/`
+   */
+  delete(id, options) {
+    return this.http.delete(
+      `/whatsapp-templates/${encodeURIComponent(id)}/`,
+      options
+    );
+  }
+  /**
+   * Submit this template to one or more WABAs for approval.
+   *
+   * Returns the updated template, plus per-account `publishResults` /
+   * `publishErrors`.
+   *
+   * `POST /whatsapp-templates/{id}/publish/`
+   */
+  publish(id, input, options) {
+    return this.http.post(
+      `/whatsapp-templates/${encodeURIComponent(id)}/publish/`,
+      input,
+      options
+    );
+  }
+  /**
+   * Remove this template from one or more WABAs.
+   *
+   * `POST /whatsapp-templates/{id}/unpublish/`
+   */
+  unpublish(id, input, options) {
+    return this.http.post(
+      `/whatsapp-templates/${encodeURIComponent(id)}/unpublish/`,
+      input,
+      options
+    );
+  }
+};
+
+// src/webhooks.ts
+var DEFAULT_TOLERANCE_SECONDS = 300;
+var Webhooks = class {
+  /**
+   * Verify the signature on a webhook delivery, parse the body, and return
+   * the typed event.
+   *
+   * @param payload      The raw request body, exactly as received — `string`,
+   *                     `Buffer`, or `Uint8Array`. **Do not parse it first;**
+   *                     even whitespace differences will break verification.
+   * @param header       The `X-Wassist-Signature` header value.
+   * @param secret       Your webhook signing secret. Find it in the
+   *                     [Wassist dashboard](https://wassist.app/developers/webhooks).
+   * @param options.tolerance  Replay-protection window in seconds (default 300).
+   * @throws {WassistSignatureVerificationError} When the header is malformed,
+   *  the HMAC doesn't match, or the timestamp is outside the tolerance window.
+   */
+  constructEvent(payload, header, secret, options = {}) {
+    const { signedPayload, parts } = this.prepare(payload, header);
+    const expected = this.signSync(signedPayload, secret);
+    this.assertValid(parts, expected, header ?? "", signedPayload, options);
+    return this.parseEvent(payload);
+  }
+  /**
+   * Async variant of {@link constructEvent} that uses Web Crypto, for
+   * runtimes that don't expose `node:crypto` (Cloudflare Workers, Deno,
+   * the browser).
+   */
+  async constructEventAsync(payload, header, secret, options = {}) {
+    const { signedPayload, parts } = this.prepare(payload, header);
+    const expected = await this.signAsync(signedPayload, secret);
+    this.assertValid(parts, expected, header ?? "", signedPayload, options);
+    return this.parseEvent(payload);
+  }
+  /**
+   * Compute the v1 signature for a `t.<body>` payload — exported as a
+   * convenience for testing.
+   */
+  signSync(signedPayload, secret) {
+    const nodeCrypto = loadNodeCrypto();
+    if (!nodeCrypto) {
+      throw new WassistSignatureVerificationError({
+        message: "node:crypto is unavailable in this runtime. Use `constructEventAsync` instead."
+      });
+    }
+    return nodeCrypto.createHmac("sha256", secret).update(signedPayload).digest("hex");
+  }
+  /**
+   * Web Crypto variant of {@link signSync}.
+   */
+  async signAsync(signedPayload, secret) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+      throw new WassistSignatureVerificationError({
+        message: "Web Crypto (`globalThis.crypto.subtle`) is unavailable in this runtime."
+      });
+    }
+    const enc = new TextEncoder();
+    const key = await subtle.importKey(
+      "raw",
+      enc.encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const sig = await subtle.sign("HMAC", key, enc.encode(signedPayload));
+    return toHex(new Uint8Array(sig));
+  }
+  // =============================================================================
+  // Internals
+  // =============================================================================
+  prepare(payload, header) {
+    if (!header) {
+      throw new WassistSignatureVerificationError({
+        message: "Missing X-Wassist-Signature header.",
+        header: header ?? void 0
+      });
+    }
+    const parts = parseHeader(header);
+    if (!parts.t || !parts.v1) {
+      throw new WassistSignatureVerificationError({
+        message: "Malformed X-Wassist-Signature header \u2014 expected `t=<unix>,v1=<hex>`.",
+        header
+      });
+    }
+    const bodyText = typeof payload === "string" ? payload : new TextDecoder().decode(payload);
+    return { signedPayload: `${parts.t}.${bodyText}`, parts };
+  }
+  assertValid(parts, expected, header, signedPayload, options) {
+    if (!constantTimeEqualsHex(parts.v1, expected)) {
+      throw new WassistSignatureVerificationError({
+        message: "Webhook signature did not match the expected value.",
+        header,
+        payload: signedPayload
+      });
+    }
+    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE_SECONDS;
+    if (tolerance > 0) {
+      const now = options.currentTimestamp ?? Math.floor(Date.now() / 1e3);
+      const ts = Number(parts.t);
+      if (!Number.isFinite(ts)) {
+        throw new WassistSignatureVerificationError({
+          message: `Invalid timestamp in X-Wassist-Signature: ${parts.t}`,
+          header
+        });
+      }
+      if (Math.abs(now - ts) > tolerance) {
+        throw new WassistSignatureVerificationError({
+          message: `Webhook timestamp is outside the ${tolerance}s tolerance window (received ${ts}, now ${now}).`,
+          header
+        });
+      }
+    }
+  }
+  parseEvent(payload) {
+    const text = typeof payload === "string" ? payload : new TextDecoder().decode(payload);
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new WassistSignatureVerificationError({
+        message: "Failed to parse webhook payload as JSON.",
+        payload: text,
+        cause: err
+      });
+    }
+  }
+};
+function parseHeader(header) {
+  const parts = {};
+  for (const segment of header.split(",")) {
+    const eq = segment.indexOf("=");
+    if (eq === -1) continue;
+    const key = segment.slice(0, eq).trim();
+    const value = segment.slice(eq + 1).trim();
+    if (key === "t" || key === "v1") parts[key] = value;
+  }
+  return parts;
+}
+function constantTimeEqualsHex(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+function toHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    const v = bytes[i] ?? 0;
+    out += v.toString(16).padStart(2, "0");
+  }
+  return out;
+}
+var webhooks = new Webhooks();
+var cachedNodeCrypto;
+function loadNodeCrypto() {
+  if (cachedNodeCrypto !== void 0) return cachedNodeCrypto ?? void 0;
+  try {
+    const req = typeof __sdkRequire === "function" ? __sdkRequire : globalThis.require;
+    cachedNodeCrypto = req?.("node:crypto") ?? null;
+  } catch {
+    cachedNodeCrypto = null;
+  }
+  return cachedNodeCrypto ?? void 0;
+}
+
+// src/client.ts
+var Wassist = class {
+  /** Create and manage AI agents. */
+  agents;
+  /** Send messages and manage conversations (with nested `messages` resource). */
+  conversations;
+  /** Manage your connected WhatsApp phone numbers and their routing. */
+  phoneNumbers;
+  /** Manage WhatsApp Business Accounts. */
+  whatsappAccounts;
+  /** Manage hosted WhatsApp account-linking sessions. */
+  whatsappLinkSessions;
+  /** Manage WhatsApp message templates. */
+  whatsappTemplates;
+  /** Verify inbound webhook signatures. */
+  webhooks = webhooks;
+  /**
+   * Webhook helpers — usable without instantiating a client.
+   *
+   * @example
+   * ```ts
+   * const event = Wassist.webhooks.constructEvent(body, header, secret);
+   * ```
+   */
+  static webhooks = webhooks;
+  constructor(config) {
+    const http = new HttpClient(config);
+    this.agents = new AgentsResource(http);
+    this.conversations = new ConversationsResource(http);
+    this.phoneNumbers = new PhoneNumbersResource(http);
+    this.whatsappAccounts = new WhatsAppAccountsResource(http);
+    this.whatsappLinkSessions = new WhatsAppLinkSessionsResource(http);
+    this.whatsappTemplates = new WhatsAppTemplatesResource(http);
+  }
+};
+
+exports.AgentsResource = AgentsResource;
+exports.AutoPaginatedList = AutoPaginatedList;
+exports.ConversationsResource = ConversationsResource;
+exports.MessagesResource = MessagesResource;
+exports.PhoneNumbersResource = PhoneNumbersResource;
+exports.SDK_VERSION = SDK_VERSION;
+exports.Wassist = Wassist;
+exports.WassistAPIError = WassistAPIError;
+exports.WassistAuthenticationError = WassistAuthenticationError;
+exports.WassistConflictError = WassistConflictError;
+exports.WassistConnectionError = WassistConnectionError;
+exports.WassistError = WassistError;
+exports.WassistInvalidRequestError = WassistInvalidRequestError;
+exports.WassistNotFoundError = WassistNotFoundError;
+exports.WassistPermissionError = WassistPermissionError;
+exports.WassistRateLimitError = WassistRateLimitError;
+exports.WassistSignatureVerificationError = WassistSignatureVerificationError;
+exports.WassistTimeoutError = WassistTimeoutError;
+exports.Webhooks = Webhooks;
+exports.WhatsAppAccountsResource = WhatsAppAccountsResource;
+exports.WhatsAppLinkSessionsResource = WhatsAppLinkSessionsResource;
+exports.WhatsAppTemplatesResource = WhatsAppTemplatesResource;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map