@open-apime/sdk 0.2.2

package/dist/index.cjs

@@ -0,0 +1,816 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  Apime: () => Apime,
+  ApimeError: () => ApimeError,
+  ApimeInstanceClient: () => ApimeInstanceClient,
+  ApimeUserClient: () => ApimeUserClient,
+  AuthenticationError: () => AuthenticationError,
+  ConfigurationError: () => ConfigurationError,
+  ConflictError: () => ConflictError,
+  ConnectionError: () => ConnectionError,
+  InvalidRequestError: () => InvalidRequestError,
+  InvalidSignatureError: () => InvalidSignatureError,
+  NotFoundError: () => NotFoundError,
+  PermissionError: () => PermissionError,
+  RateLimitError: () => RateLimitError,
+  SessionUnavailableError: () => SessionUnavailableError,
+  TimeoutError: () => TimeoutError,
+  UnprocessableError: () => UnprocessableError,
+  constructEvent: () => constructEvent,
+  hasSentry: () => hasSentry,
+  verifyWebhookSignature: () => verifyWebhookSignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/index.ts
+var ApimeError = class extends Error {
+  status;
+  body;
+  /** Value of the request id header, when the response carried one. */
+  requestId;
+  constructor(message, options = {}) {
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = new.target.name;
+    this.status = options.status;
+    this.body = options.body;
+    this.requestId = options.requestId;
+  }
+};
+var AuthenticationError = class extends ApimeError {
+};
+var PermissionError = class extends ApimeError {
+};
+var NotFoundError = class extends ApimeError {
+};
+var ConflictError = class extends ApimeError {
+};
+var UnprocessableError = class extends ApimeError {
+};
+var RateLimitError = class extends ApimeError {
+  retryAfterMs;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+var InvalidRequestError = class extends ApimeError {
+};
+var ApiError = class extends ApimeError {
+};
+var SessionUnavailableError = class extends ApiError {
+};
+var ConnectionError = class extends ApimeError {
+};
+var TimeoutError = class extends ConnectionError {
+};
+var ConfigurationError = class extends ApimeError {
+};
+
+// src/observability/sentry.ts
+function findScope() {
+  const carrier = globalThis.__SENTRY__;
+  if (!carrier?.version) return void 0;
+  const versioned = carrier[carrier.version];
+  const scope = versioned?.globalScope;
+  return typeof scope?.captureException === "function" ? scope : void 0;
+}
+function hasSentry() {
+  return findScope() !== void 0;
+}
+function reportToSentry(info) {
+  const scope = findScope();
+  if (!scope) return;
+  scope.captureException(info.error, {
+    captureContext: {
+      tags: {
+        sdk: "open-apime",
+        route: info.route,
+        method: info.method,
+        ...info.status !== void 0 ? { status: String(info.status) } : {}
+      },
+      extra: {
+        // Nao mandamos `path`: ele carrega o jid do contato, ou seja o telefone
+        // de quem conversa. `route` ja identifica o endpoint sem isso.
+        instanceId: info.instanceId,
+        attempt: info.attempt,
+        durationMs: info.durationMs,
+        idempotencyKey: info.idempotencyKey
+      }
+    }
+  });
+}
+
+// src/observability/index.ts
+function safeNotify(fn) {
+  if (!fn) return;
+  try {
+    fn();
+  } catch {
+  }
+}
+function toRoute(path) {
+  return path.replace(/\/instances\/[^/]+/, "/instances/{id}").replace(/\/(profile|business)\/[^/]+\/picture/, "/$1/{jid}/picture").replace(/\/(profile|business|contacts|userinfo|newsletters)\/[^/]+/, "/$1/{jid}").replace(/\/chat-settings\/[^/]+/, "/chat-settings/{chat}").replace(/\/groups\/(?!join$|resolve-invite$)[^/]+/, "/groups/{group}").replace(/\/tokens\/[^/]+$/, "/tokens/{tokenId}").replace(/\/users\/[^/]+(?=\/|$)/, "/users/{id}");
+}
+
+// src/http/errors.ts
+function messageFrom(body, status) {
+  if (body && typeof body === "object" && "error" in body) {
+    const raw = body.error;
+    if (typeof raw === "string" && raw.length > 0) return raw;
+  }
+  return `HTTP ${status}`;
+}
+function retryAfterMs(headers) {
+  const raw = headers.get("retry-after");
+  if (!raw) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return seconds * 1e3;
+  const date = Date.parse(raw);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function errorFromResponse(status, body, headers) {
+  const message = messageFrom(body, status);
+  const requestId = headers.get("x-request-id") ?? void 0;
+  const base = { status, body, ...requestId !== void 0 ? { requestId } : {} };
+  switch (status) {
+    case 401:
+      return new AuthenticationError(message, base);
+    case 403:
+      return new PermissionError(message, base);
+    case 404:
+      return new NotFoundError(message, base);
+    case 409:
+      return new ConflictError(message, base);
+    case 422:
+      return new UnprocessableError(message, base);
+    case 429: {
+      const after = retryAfterMs(headers);
+      return new RateLimitError(message, { ...base, ...after !== void 0 ? { retryAfterMs: after } : {} });
+    }
+    case 503:
+      return new SessionUnavailableError(message, base);
+    default:
+      if (status >= 500) return new ApiError(message, base);
+      return new InvalidRequestError(message, base);
+  }
+}
+
+// src/http/url.ts
+var BLOCKED_HOSTS = /* @__PURE__ */ new Set(["169.254.169.254", "metadata.google.internal"]);
+function assertUsableBaseUrl(raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new ConfigurationError(`baseUrl inv\xE1lida: ${raw}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new ConfigurationError(`baseUrl deve usar http ou https, veio ${parsed.protocol}`);
+  }
+  if (BLOCKED_HOSTS.has(parsed.hostname)) {
+    throw new ConfigurationError("baseUrl aponta para endpoint de metadados da nuvem");
+  }
+  if (isPrivateIPv4(parsed.hostname)) {
+    throw new ConfigurationError("baseUrl aponta para IP privado ou loopback");
+  }
+  return parsed;
+}
+function isPrivateIPv4(host) {
+  const parts = host.split(".");
+  if (parts.length !== 4) return false;
+  const nums = parts.map(Number);
+  if (nums.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) return false;
+  const [a = 0, b = 0] = nums;
+  return a === 10 || a === 127 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+}
+function pathSegment(value) {
+  return encodeURIComponent(value);
+}
+function buildUrl(base, path, query) {
+  const prefix = base.pathname.replace(/\/+$/, "");
+  const url = new URL(`${prefix}/api${path}`, base);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+
+// src/http/client.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_MAX_RETRIES = 2;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var HttpClient = class {
+  baseUrl;
+  auth;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  userAgent;
+  observer;
+  autoReport;
+  instanceId;
+  constructor(options) {
+    this.baseUrl = assertUsableBaseUrl(options.baseUrl);
+    this.auth = options.auth;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.userAgent = options.appName ? `open-apime-sdk (${options.appName})` : "open-apime-sdk";
+    this.observer = options.observer;
+    this.autoReport = options.autoReport ?? true;
+    this.instanceId = options.auth.type === "instanceToken" ? options.auth.instanceId : void 0;
+  }
+  info(args, attempt) {
+    return {
+      method: args.method,
+      route: toRoute(args.path),
+      path: args.path,
+      instanceId: this.instanceId,
+      attempt: attempt + 1,
+      idempotencyKey: args.options?.idempotencyKey
+    };
+  }
+  async request(args) {
+    const attempts = (args.options?.maxRetries ?? this.maxRetries) + 1;
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const info = this.info(args, attempt);
+      const startedAt = Date.now();
+      safeNotify(this.observer?.onRequest && (() => this.observer?.onRequest?.(info)));
+      try {
+        const result = await this.attempt(args);
+        const durationMs = Date.now() - startedAt;
+        safeNotify(this.observer?.onSuccess && (() => this.observer?.onSuccess?.({ ...info, status: 200, durationMs })));
+        return result;
+      } catch (error) {
+        lastError = error;
+        const isLast = attempt === attempts - 1;
+        const retryable = !isLast && this.mayRetry(args, error);
+        const failure = {
+          ...info,
+          status: error instanceof ApimeError ? error.status : void 0,
+          durationMs: Date.now() - startedAt,
+          error,
+          willRetry: retryable
+        };
+        if (this.observer?.onError) {
+          safeNotify(() => this.observer?.onError?.(failure));
+        } else if (this.autoReport && !retryable) {
+          safeNotify(() => reportToSentry(failure));
+        }
+        if (isLast || !retryable) break;
+        const delayMs = backoffMs(attempt, error);
+        safeNotify(this.observer?.onRetry && (() => this.observer?.onRetry?.({ ...failure, delayMs })));
+        await sleep(delayMs, args.options?.signal);
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * A write is only retried when the caller passed an idempotency key: without
+   * it a retried send can deliver the same WhatsApp message twice. The one
+   * exception is 503, which the apime returns before touching WhatsApp.
+   */
+  mayRetry(args, error) {
+    if (!(error instanceof ApimeError)) return false;
+    if (error instanceof TimeoutError) return this.writeIsSafe(args, error);
+    if (error instanceof ConnectionError) return this.writeIsSafe(args, error);
+    if (error.status === void 0) return false;
+    if (!RETRYABLE_STATUS.has(error.status)) return false;
+    return this.writeIsSafe(args, error);
+  }
+  writeIsSafe(args, error) {
+    if (args.method === "GET") return true;
+    if (args.options?.idempotencyKey) return true;
+    return error instanceof ApimeError && error.status === 503;
+  }
+  async attempt(args) {
+    const url = buildUrl(this.baseUrl, args.path, args.query);
+    const timeoutMs = args.options?.timeoutMs ?? this.timeoutMs;
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    args.options?.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const headers = {
+      authorization: `Bearer ${this.auth.token}`,
+      accept: "application/json",
+      "user-agent": this.userAgent,
+      ...args.options?.headers
+    };
+    if (args.options?.idempotencyKey) headers["idempotency-key"] = args.options.idempotencyKey;
+    let init = { method: args.method, headers, signal: controller.signal };
+    if (args.body instanceof FormData) {
+      init = { ...init, body: args.body };
+    } else if (args.body !== void 0) {
+      headers["content-type"] = "application/json";
+      init = { ...init, body: JSON.stringify(args.body) };
+    }
+    let response;
+    try {
+      response = await this.fetchImpl(url, init);
+    } catch (cause) {
+      if (controller.signal.aborted && args.options?.signal?.aborted !== true) {
+        throw new TimeoutError(`a requisi\xE7\xE3o passou de ${timeoutMs}ms`, { cause });
+      }
+      throw new ConnectionError("falha de rede ao falar com o apime", { cause });
+    } finally {
+      clearTimeout(timer);
+      args.options?.signal?.removeEventListener("abort", onAbort);
+    }
+    const payload = await readBody(response);
+    if (!response.ok) throw errorFromResponse(response.status, payload, response.headers);
+    return unwrap(payload);
+  }
+};
+function unwrap(body) {
+  if (body && typeof body === "object" && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+async function readBody(response) {
+  const text = await response.text();
+  if (text.length === 0) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function backoffMs(attempt, error) {
+  if (error instanceof RateLimitError && error.retryAfterMs !== void 0) {
+    return error.retryAfterMs;
+  }
+  const ceiling = Math.min(1e3 * 2 ** attempt, 8e3);
+  return Math.random() * ceiling;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new ConnectionError("requisi\xE7\xE3o cancelada"));
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(new ConnectionError("requisi\xE7\xE3o cancelada"));
+    }, { once: true });
+  });
+}
+
+// src/resources/instances/index.ts
+var InstancesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(options) {
+    return this.http.request({ method: "GET", path: "/instances", ...options ? { options } : {} });
+  }
+  create(input, options) {
+    return this.http.request({ method: "POST", path: "/instances", body: input, ...options ? { options } : {} });
+  }
+  get(instanceId, options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(instanceId)}`, ...options ? { options } : {} });
+  }
+  update(instanceId, input, options) {
+    return this.http.request({ method: "PUT", path: `/instances/${pathSegment(instanceId)}`, body: input, ...options ? { options } : {} });
+  }
+  delete(instanceId, options) {
+    return this.http.request({ method: "DELETE", path: `/instances/${pathSegment(instanceId)}`, ...options ? { options } : {} });
+  }
+  rotateToken(instanceId, options) {
+    return this.http.request({ method: "POST", path: `/instances/${pathSegment(instanceId)}/token/rotate`, ...options ? { options } : {} });
+  }
+  getQrCode(instanceId, options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(instanceId)}/qr`, ...options ? { options } : {} });
+  }
+  disconnect(instanceId, options) {
+    return this.http.request({ method: "POST", path: `/instances/${pathSegment(instanceId)}/disconnect`, ...options ? { options } : {} });
+  }
+  listEvents(instanceId, query, options) {
+    return this.http.request({
+      method: "GET",
+      path: `/instances/${pathSegment(instanceId)}/events`,
+      ...query ? { query } : {},
+      ...options ? { options } : {}
+    });
+  }
+};
+var ScopedInstanceResource = class {
+  constructor(http, instanceId) {
+    this.http = http;
+    this.instanceId = instanceId;
+  }
+  http;
+  instanceId;
+  get(options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(this.instanceId)}`, ...options ? { options } : {} });
+  }
+  /** Only reachable with an instance token; a user token gets a 403. */
+  info(options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(this.instanceId)}/info`, ...options ? { options } : {} });
+  }
+  getQrCode(options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(this.instanceId)}/qr`, ...options ? { options } : {} });
+  }
+  disconnect(options) {
+    return this.http.request({ method: "POST", path: `/instances/${pathSegment(this.instanceId)}/disconnect`, ...options ? { options } : {} });
+  }
+  listEvents(query, options) {
+    return this.http.request({
+      method: "GET",
+      path: `/instances/${pathSegment(this.instanceId)}/events`,
+      ...query ? { query } : {},
+      ...options ? { options } : {}
+    });
+  }
+  getProfile(jid, options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(this.instanceId)}/profile/${pathSegment(jid)}`, ...options ? { options } : {} });
+  }
+  getBusinessProfile(jid, options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(this.instanceId)}/business/${pathSegment(jid)}`, ...options ? { options } : {} });
+  }
+  getProfilePicture(jid, options) {
+    return this.http.request({ method: "GET", path: `/instances/${pathSegment(this.instanceId)}/profile/${pathSegment(jid)}/picture`, ...options ? { options } : {} });
+  }
+};
+
+// src/resources/messages/index.ts
+var MessagesResource = class {
+  constructor(http, instanceId) {
+    this.http = http;
+    this.instanceId = instanceId;
+  }
+  http;
+  instanceId;
+  get base() {
+    return `/instances/${pathSegment(this.instanceId)}/messages`;
+  }
+  sendText(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/text`, body: input, ...options ? { options } : {} });
+  }
+  sendMedia(input, options) {
+    const form = toForm(input, ["file", "filename"]);
+    form.set("file", input.file, input.filename ?? fileName(input.file, "media"));
+    return this.http.request({ method: "POST", path: `${this.base}/media`, body: form, ...options ? { options } : {} });
+  }
+  sendAudio(input, options) {
+    const form = toForm(input, ["file", "filename"]);
+    form.set("file", input.file, input.filename ?? fileName(input.file, "audio.ogg"));
+    return this.http.request({ method: "POST", path: `${this.base}/audio`, body: form, ...options ? { options } : {} });
+  }
+  sendDocument(input, options) {
+    const form = toForm(input, ["file"]);
+    form.set("file", input.file, input.filename ?? fileName(input.file, "document"));
+    return this.http.request({ method: "POST", path: `${this.base}/document`, body: form, ...options ? { options } : {} });
+  }
+  sendContact(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/contact`, body: input, ...options ? { options } : {} });
+  }
+  sendLocation(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/location`, body: input, ...options ? { options } : {} });
+  }
+  /** Generic enqueue, for a type the SDK does not model yet. */
+  enqueue(input, options) {
+    return this.http.request({ method: "POST", path: this.base, body: input, ...options ? { options } : {} });
+  }
+  list(options) {
+    return this.http.request({ method: "GET", path: this.base, ...options ? { options } : {} });
+  }
+};
+function toForm(input, skip) {
+  const form = new FormData();
+  for (const [key, value] of Object.entries(input)) {
+    if (skip.includes(key) || value === void 0 || value === null) continue;
+    form.set(key, typeof value === "string" ? value : String(value));
+  }
+  return form;
+}
+function fileName(file, fallback) {
+  return "name" in file && typeof file.name === "string" && file.name.length > 0 ? file.name : fallback;
+}
+
+// src/resources/tokens/index.ts
+var TokensResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(options) {
+    return this.http.request({ method: "GET", path: "/tokens", ...options ? { options } : {} });
+  }
+  create(input, options) {
+    return this.http.request({ method: "POST", path: "/tokens", body: input, ...options ? { options } : {} });
+  }
+  delete(tokenId, options) {
+    return this.http.request({ method: "DELETE", path: `/tokens/${pathSegment(tokenId)}`, ...options ? { options } : {} });
+  }
+};
+
+// src/resources/users/index.ts
+var UsersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(options) {
+    return this.http.request({ method: "GET", path: "/users", ...options ? { options } : {} });
+  }
+  create(input, options) {
+    return this.http.request({ method: "POST", path: "/users", body: input, ...options ? { options } : {} });
+  }
+  updatePassword(userId, password, options) {
+    return this.http.request({ method: "PATCH", path: `/users/${pathSegment(userId)}/password`, body: { password }, ...options ? { options } : {} });
+  }
+  rotateApiToken(userId, options) {
+    return this.http.request({ method: "POST", path: `/users/${pathSegment(userId)}/token`, ...options ? { options } : {} });
+  }
+  delete(userId, options) {
+    return this.http.request({ method: "DELETE", path: `/users/${pathSegment(userId)}`, ...options ? { options } : {} });
+  }
+};
+
+// src/resources/whatsapp/index.ts
+var WhatsAppResource = class {
+  constructor(http, instanceId) {
+    this.http = http;
+    this.instanceId = instanceId;
+    this.groups = new GroupsResource(http, instanceId);
+    this.newsletters = new NewslettersResource(http, instanceId);
+  }
+  http;
+  instanceId;
+  groups;
+  newsletters;
+  get base() {
+    return `/instances/${pathSegment(this.instanceId)}/whatsapp`;
+  }
+  checkNumber(phone, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/check`, body: { phone }, ...options ? { options } : {} });
+  }
+  /** `to` is optional: without it the presence is global, not per chat. */
+  setPresence(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/presence`, body: input, ...options ? { options } : {} });
+  }
+  listContacts(options) {
+    return this.http.request({ method: "GET", path: `${this.base}/contacts`, ...options ? { options } : {} });
+  }
+  getContact(jid, options) {
+    return this.http.request({ method: "GET", path: `${this.base}/contacts/${pathSegment(jid)}`, ...options ? { options } : {} });
+  }
+  getUserInfo(jid, options) {
+    return this.http.request({ method: "GET", path: `${this.base}/userinfo/${pathSegment(jid)}`, ...options ? { options } : {} });
+  }
+  /** `sender` is required in groups, to identify whose message it is. */
+  markRead(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/messages/read`, body: input, ...options ? { options } : {} });
+  }
+  deleteMessage(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/messages/delete`, body: input, ...options ? { options } : {} });
+  }
+  editMessage(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/messages/edit`, body: input, ...options ? { options } : {} });
+  }
+  /** An empty `emoji` removes the reaction. */
+  react(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/messages/react`, body: input, ...options ? { options } : {} });
+  }
+  getPrivacySettings(options) {
+    return this.http.request({ method: "GET", path: `${this.base}/privacy`, ...options ? { options } : {} });
+  }
+  setPrivacySetting(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/privacy`, body: input, ...options ? { options } : {} });
+  }
+  getStatusPrivacy(options) {
+    return this.http.request({ method: "GET", path: `${this.base}/status-privacy`, ...options ? { options } : {} });
+  }
+  getChatSettings(chat, options) {
+    return this.http.request({ method: "GET", path: `${this.base}/chat-settings/${pathSegment(chat)}`, ...options ? { options } : {} });
+  }
+  /** `muted_until` as null unmutes. */
+  setChatSettings(chat, input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/chat-settings/${pathSegment(chat)}`, body: input, ...options ? { options } : {} });
+  }
+  setStatusMessage(message, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/status`, body: { message }, ...options ? { options } : {} });
+  }
+  /** `seconds` as 0 turns disappearing messages off. */
+  setDefaultDisappearingTimer(seconds, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/disappearing-timer`, body: { seconds }, ...options ? { options } : {} });
+  }
+  uploadMedia(input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/upload`, body: input, ...options ? { options } : {} });
+  }
+  /** `revoke` invalidates the previous link and issues another. */
+  getContactQrLink(query, options) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.base}/qr/contact`,
+      ...query?.revoke !== void 0 ? { query: { revoke: String(query.revoke) } } : {},
+      ...options ? { options } : {}
+    });
+  }
+  resolveContactQrLink(code, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/qr/contact/resolve`, body: { code }, ...options ? { options } : {} });
+  }
+  resolveBusinessMessageLink(code, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/qr/business-message/resolve`, body: { code }, ...options ? { options } : {} });
+  }
+};
+var GroupsResource = class {
+  constructor(http, instanceId) {
+    this.http = http;
+    this.instanceId = instanceId;
+  }
+  http;
+  instanceId;
+  get base() {
+    return `/instances/${pathSegment(this.instanceId)}/whatsapp/groups`;
+  }
+  list(options) {
+    return this.http.request({ method: "GET", path: this.base, ...options ? { options } : {} });
+  }
+  create(input, options) {
+    return this.http.request({ method: "POST", path: this.base, body: input, ...options ? { options } : {} });
+  }
+  get(group, options) {
+    return this.http.request({ method: "GET", path: `${this.base}/${pathSegment(group)}`, ...options ? { options } : {} });
+  }
+  getInviteLink(group, options) {
+    return this.http.request({ method: "GET", path: `${this.base}/${pathSegment(group)}/invite-link`, ...options ? { options } : {} });
+  }
+  resolveInvite(link, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/resolve-invite`, body: { link }, ...options ? { options } : {} });
+  }
+  join(link, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/join`, body: { link }, ...options ? { options } : {} });
+  }
+  leave(group, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/${pathSegment(group)}/leave`, ...options ? { options } : {} });
+  }
+  updateParticipants(group, input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/${pathSegment(group)}/participants`, body: input, ...options ? { options } : {} });
+  }
+  listJoinRequests(group, options) {
+    return this.http.request({ method: "GET", path: `${this.base}/${pathSegment(group)}/requests`, ...options ? { options } : {} });
+  }
+  updateJoinRequests(group, input, options) {
+    return this.http.request({ method: "POST", path: `${this.base}/${pathSegment(group)}/requests`, body: input, ...options ? { options } : {} });
+  }
+};
+var NewslettersResource = class {
+  constructor(http, instanceId) {
+    this.http = http;
+    this.instanceId = instanceId;
+  }
+  http;
+  instanceId;
+  base(jid) {
+    return `/instances/${pathSegment(this.instanceId)}/whatsapp/newsletters/${pathSegment(jid)}`;
+  }
+  subscribeLiveUpdates(jid, options) {
+    return this.http.request({ method: "POST", path: `${this.base(jid)}/live-updates`, ...options ? { options } : {} });
+  }
+  markViewed(jid, serverIds, options) {
+    return this.http.request({ method: "POST", path: `${this.base(jid)}/mark-viewed`, body: { server_ids: serverIds }, ...options ? { options } : {} });
+  }
+  react(jid, input, options) {
+    return this.http.request({ method: "POST", path: `${this.base(jid)}/reaction`, body: input, ...options ? { options } : {} });
+  }
+  getMessageUpdates(jid, options) {
+    return this.http.request({ method: "POST", path: `${this.base(jid)}/message-updates`, ...options ? { options } : {} });
+  }
+};
+
+// src/client.ts
+var ApimeUserClient = class {
+  instances;
+  /** Requires the user to have role admin; other users get a 403. */
+  users;
+  tokens;
+  http;
+  constructor(auth, options) {
+    this.http = new HttpClient(toHttpOptions(auth, options));
+    this.instances = new InstancesResource(this.http);
+    this.users = new UsersResource(this.http);
+    this.tokens = new TokensResource(this.http);
+  }
+  /** Escape hatch for a route the SDK does not cover yet. */
+  request(args) {
+    return this.http.request(args);
+  }
+};
+var ApimeInstanceClient = class {
+  instanceId;
+  instance;
+  messages;
+  whatsapp;
+  http;
+  constructor(auth, options) {
+    this.http = new HttpClient(toHttpOptions(auth, options));
+    this.instanceId = auth.instanceId;
+    this.instance = new ScopedInstanceResource(this.http, auth.instanceId);
+    this.messages = new MessagesResource(this.http, auth.instanceId);
+    this.whatsapp = new WhatsAppResource(this.http, auth.instanceId);
+  }
+  request(args) {
+    return this.http.request(args);
+  }
+};
+function toHttpOptions(auth, options) {
+  return {
+    baseUrl: options.baseUrl,
+    auth,
+    ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+    ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {},
+    ...options.fetch !== void 0 ? { fetch: options.fetch } : {},
+    ...options.appName !== void 0 ? { appName: options.appName } : {},
+    ...options.observer !== void 0 ? { observer: options.observer } : {},
+    ...options.autoReport !== void 0 ? { autoReport: options.autoReport } : {}
+  };
+}
+var Apime = {
+  withUserJwt(token, options) {
+    return new ApimeUserClient({ type: "userJwt", token }, options);
+  },
+  withApiToken(token, options) {
+    return new ApimeUserClient({ type: "apiToken", token }, options);
+  },
+  withInstanceToken(credentials, options) {
+    return new ApimeInstanceClient(
+      { type: "instanceToken", token: credentials.token, instanceId: credentials.instanceId },
+      options
+    );
+  }
+};
+
+// src/webhook/index.ts
+var import_node_crypto = require("crypto");
+var InvalidSignatureError = class extends ApimeError {
+};
+function verifyWebhookSignature(rawBody, signature, secret) {
+  if (!signature || !secret) return false;
+  const body = typeof rawBody === "string" ? Buffer.from(rawBody, "utf8") : rawBody;
+  const expected = `sha256=${(0, import_node_crypto.createHmac)("sha256", secret).update(body).digest("hex")}`;
+  const received = Buffer.from(signature, "utf8");
+  const digest = Buffer.from(expected, "utf8");
+  if (received.length !== digest.length) return false;
+  return (0, import_node_crypto.timingSafeEqual)(received, digest);
+}
+function constructEvent(rawBody, signature, secret) {
+  if (!verifyWebhookSignature(rawBody, signature, secret)) {
+    throw new InvalidSignatureError("assinatura do webhook n\xE3o confere");
+  }
+  const text = typeof rawBody === "string" ? rawBody : rawBody.toString("utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (cause) {
+    throw new InvalidSignatureError("corpo do webhook n\xE3o \xE9 JSON v\xE1lido", { cause });
+  }
+  return parsed;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  Apime,
+  ApimeError,
+  ApimeInstanceClient,
+  ApimeUserClient,
+  AuthenticationError,
+  ConfigurationError,
+  ConflictError,
+  ConnectionError,
+  InvalidRequestError,
+  InvalidSignatureError,
+  NotFoundError,
+  PermissionError,
+  RateLimitError,
+  SessionUnavailableError,
+  TimeoutError,
+  UnprocessableError,
+  constructEvent,
+  hasSentry,
+  verifyWebhookSignature
+});