@letsbot/sdk 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,915 @@
+import { randomUUID, createHmac, timingSafeEqual } from 'crypto';
+
+// src/client.ts
+
+// src/errors.ts
+var LetsBotApiError = class _LetsBotApiError extends Error {
+  name = "LetsBotApiError";
+  /** HTTP status. Can be 200/202 for a refusal carried in the body. */
+  status;
+  /** Parsed response body (raw text when it was not JSON, `undefined` when empty). */
+  body;
+  /**
+   * Support reference. The API does not send a request-id header; the only reference it returns
+   * is `reference` on a 500 (`API-XXXXXXXXXX`) — quote it to support. `undefined` otherwise.
+   */
+  requestId;
+  /** Machine-readable code from the body (`error_code`, `code` or `error`), when there is one. */
+  code;
+  /** The operation that failed, e.g. `sendMessage`. */
+  operationId;
+  /** Seconds from a `Retry-After` header, when the response carried one. */
+  retryAfter;
+  /** Response headers. */
+  headers;
+  constructor(init) {
+    super(_LetsBotApiError.messageFrom(init.status, init.body, init.operationId));
+    this.status = init.status;
+    this.body = init.body;
+    this.headers = init.headers;
+    this.operationId = init.operationId;
+    this.retryAfter = init.retryAfter;
+    this.code = pickString(init.body, ["error_code", "code", "error"]);
+    this.requestId = pickString(init.body, ["reference"]) ?? init.headers.get("x-request-id") ?? void 0;
+  }
+  /**
+   * True for `409 idempotency_outcome_unknown`: an earlier request with this Idempotency-Key died
+   * before its result was known, so the message may or may not have been sent. Do not resend with
+   * the same key; check the message status, or send again with a NEW key if you accept a possible
+   * duplicate.
+   */
+  get isOutcomeUnknown() {
+    return this.status === 409 && this.code === "idempotency_outcome_unknown";
+  }
+  static messageFrom(status, body, operationId) {
+    const text = pickString(body, ["Message", "message", "data", "error"]) ?? (typeof body === "string" ? body.slice(0, 200) : "");
+    return `${operationId} failed (HTTP ${status})${text ? `: ${text}` : ""}`;
+  }
+};
+var LetsBotConnectionError = class extends Error {
+  name = "LetsBotConnectionError";
+  operationId;
+  constructor(operationId, cause) {
+    super(`${operationId} failed: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.operationId = operationId;
+  }
+};
+function pickString(body, keys) {
+  if (!body || typeof body !== "object") return void 0;
+  for (const key of keys) {
+    const value = body[key];
+    if (typeof value === "string" && value !== "") return value;
+  }
+  return void 0;
+}
+function isLogicalFailure(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return false;
+  const record = body;
+  if ("success" in record && record.success === false) return true;
+  return "Status" in record && [false, 0, "0", "false"].includes(record.Status);
+}
+
+// src/generated/operations.ts
+var operations = {
+  addGroupParticipant: { method: "POST", path: "/group/add/participant", params: "body", send: false },
+  archiveChat: { method: "POST", path: "/chat/archive", params: "body", send: false },
+  blockUser: { method: "POST", path: "/user/block", params: "body", send: false },
+  checkPhone: { method: "POST", path: "/check/phone", params: "body", send: false },
+  createGroup: { method: "POST", path: "/group/create", params: "body", send: false },
+  createProduct: { method: "POST", path: "/product/create", params: "body", send: false },
+  deleteMessage: { method: "DELETE", path: "/message/delete", params: "query", send: false },
+  demoteGroupParticipant: { method: "POST", path: "/group/demote/participant", params: "body", send: false },
+  findSession: { method: "POST", path: "/session/find", params: "none", send: false },
+  forwardMessage: { method: "POST", path: "/message/send/forward/message", params: "body", send: true },
+  getChatDisplayPicture: { method: "GET", path: "/group/display/picture", params: "query", send: false },
+  getChatList: { method: "GET", path: "/chat/list", params: "query", send: false },
+  getCollections: { method: "POST", path: "/product/get/collections", params: "body", send: false },
+  getContact: { method: "GET", path: "/live_chat/contact", params: "query", send: false },
+  getContacts: { method: "GET", path: "/contacts", params: "query", send: false },
+  getConversation: { method: "GET", path: "/chat/conversation", params: "query", send: false },
+  getGroupConversation: { method: "GET", path: "/group/conversation", params: "query", send: false },
+  getGroupList: { method: "GET", path: "/group/list", params: "none", send: false },
+  getLabels: { method: "GET", path: "/live_chat/labels", params: "none", send: false },
+  getMessageByID: { method: "GET", path: "/message/id", params: "query", send: false },
+  getMessages: { method: "GET", path: "/message/fetch", params: "query", send: false },
+  getModerators: { method: "GET", path: "/live_chat/moderators", params: "none", send: false },
+  getOrder: { method: "POST", path: "/product/get/order", params: "body", send: false },
+  getProduct: { method: "GET", path: "/product/id", params: "query", send: false },
+  getProducts: { method: "POST", path: "/product", params: "body", send: false },
+  groupGetInviteInfo: { method: "GET", path: "/invite/get/info", params: "query", send: false },
+  groupMetadata: { method: "GET", path: "/group/meta/data", params: "query", send: false },
+  groupSettings: { method: "POST", path: "/group/settings", params: "body", send: false },
+  index: { method: "GET", path: "/messages", params: "query", send: false },
+  inviteCode: { method: "POST", path: "/invite/code", params: "body", send: false },
+  joinGroup: { method: "POST", path: "/group/join", params: "body", send: false },
+  muteChat: { method: "POST", path: "/chat/mute", params: "body", send: false },
+  pinChat: { method: "POST", path: "/chat/pin", params: "body", send: false },
+  promoteGroupParticipant: { method: "POST", path: "/group/promote/participant", params: "body", send: false },
+  qr: { method: "POST", path: "/qr", params: "none", send: false },
+  queryBroadcast: { method: "POST", path: "/instance/query/broadcast", params: "body", send: false },
+  readChat: { method: "POST", path: "/chat/read", params: "body", send: false },
+  removeGroupParticipant: { method: "POST", path: "/group/remove/participant", params: "body", send: false },
+  renameGroup: { method: "POST", path: "/group/rename", params: "body", send: false },
+  revokeInviteCode: { method: "POST", path: "/invite/revoke/code", params: "body", send: false },
+  sendAudio: { method: "POST", path: "/send/audio", params: "body", send: true },
+  sendButtons: { method: "POST", path: "/button", params: "body", send: true },
+  sendButtonsAlias: { method: "POST", path: "/send/buttons", params: "body", send: true },
+  sendButtonsTemplate: { method: "POST", path: "/button/template", params: "body", send: true },
+  sendButtonsTemplateWithDocument: { method: "POST", path: "/button/document/template", params: "body", send: true },
+  sendButtonsTemplateWithImage: { method: "POST", path: "/button/image/template", params: "body", send: true },
+  sendButtonsTemplateWithLocation: { method: "POST", path: "/button/location/template", params: "body", send: true },
+  sendButtonsTemplateWithVideo: { method: "POST", path: "/button/video/template", params: "body", send: true },
+  sendButtonsWithDocument: { method: "POST", path: "/button/document", params: "body", send: true },
+  sendButtonsWithImage: { method: "POST", path: "/button/image", params: "body", send: true },
+  sendButtonsWithLocation: { method: "POST", path: "/button/location", params: "body", send: true },
+  sendButtonsWithVideo: { method: "POST", path: "/button/video", params: "body", send: true },
+  sendCarousel: { method: "POST", path: "/carousel", params: "body", send: true },
+  sendContact: { method: "POST", path: "/send/contact", params: "body", send: true },
+  sendDisappearingMessage: { method: "POST", path: "/message/send/disappearing", params: "body", send: true },
+  sendFile: { method: "POST", path: "/send/file", params: "body", send: true },
+  sendGif: { method: "POST", path: "/send/gif", params: "body", send: true },
+  sendImage: { method: "POST", path: "/send/image", params: "body", send: true },
+  sendInviteLink: { method: "POST", path: "/invite/send/link", params: "body", send: true },
+  sendList: { method: "POST", path: "/list/message", params: "body", send: true },
+  sendLocation: { method: "POST", path: "/send/location", params: "body", send: true },
+  sendMention: { method: "POST", path: "/message/send/mention", params: "body", send: true },
+  sendMessage: { method: "POST", path: "/message/send", params: "body", send: true },
+  sendPTT: { method: "POST", path: "/send/ptt", params: "body", send: true },
+  sendReaction: { method: "POST", path: "/message/send/reaction", params: "body", send: true },
+  sendReply: { method: "POST", path: "/message/send/reply", params: "body", send: true },
+  sendSimpleTemplate: { method: "POST", path: "/template/simple", params: "body", send: true },
+  sendSticker: { method: "POST", path: "/message/send/sticker", params: "body", send: true },
+  sendTemplateWithDocument: { method: "POST", path: "/template/document", params: "body", send: true },
+  sendTemplateWithImage: { method: "POST", path: "/template/image", params: "body", send: true },
+  sendTemplateWithVideo: { method: "POST", path: "/template/video", params: "body", send: true },
+  sendVideo: { method: "POST", path: "/send/video", params: "body", send: true },
+  sendWhatsAppTemplate: { method: "POST", path: "/template/send", params: "body", send: true },
+  sessionStatus: { method: "POST", path: "/session/status", params: "none", send: false },
+  setChatDisplayPicture: { method: "POST", path: "/group/set/display/picture", params: "body", send: false },
+  setContactLabel: { method: "POST", path: "/live_chat/set-label", params: "body", send: false },
+  setContactModerator: { method: "POST", path: "/live_chat/set-moderator", params: "body", send: false },
+  setDisplayPicture: { method: "POST", path: "/user/set/display/picture", params: "body", send: false },
+  setGroupDescription: { method: "POST", path: "/group/set/description", params: "body", send: false },
+  setPresence: { method: "POST", path: "/instance/set/presence", params: "body", send: false },
+  setProfileName: { method: "POST", path: "/user/set/name", params: "body", send: false },
+  setRecording: { method: "POST", path: "/chat/recording", params: "body", send: false },
+  setSettings: { method: "POST", path: "/instance/set/settings", params: "body", send: false },
+  setStatus: { method: "POST", path: "/instance/set/status", params: "body", send: false },
+  setTyping: { method: "POST", path: "/chat/typing", params: "body", send: false },
+  setUserStatus: { method: "POST", path: "/user/set/status", params: "body", send: false },
+  shareCatalog: { method: "POST", path: "/share/catalog", params: "body", send: true },
+  status: { method: "GET", path: "/instance/status", params: "none", send: false },
+  unarchiveChat: { method: "POST", path: "/chat/unarchive", params: "body", send: false },
+  unblockUser: { method: "POST", path: "/user/unblock", params: "body", send: false },
+  unmuteChat: { method: "POST", path: "/chat/unmute", params: "body", send: false },
+  unpinChat: { method: "POST", path: "/chat/unpin", params: "body", send: false },
+  unreadChat: { method: "POST", path: "/chat/unread", params: "body", send: false },
+  userBusinessProfile: { method: "POST", path: "/user/business", params: "body", send: false },
+  userDisplayPicture: { method: "GET", path: "/user/display/picture", params: "query", send: false },
+  userPresence: { method: "POST", path: "/user/presence", params: "body", send: false },
+  userStatus: { method: "POST", path: "/user/status", params: "body", send: false }
+};
+
+// src/rate-limit.ts
+var TokenBucket = class {
+  constructor(capacity, intervalMs, now = Date.now, wait = (ms) => new Promise((r) => setTimeout(r, ms))) {
+    this.capacity = capacity;
+    this.now = now;
+    this.wait = wait;
+    if (!(capacity > 0) || !(intervalMs > 0)) {
+      throw new RangeError("TokenBucket needs a positive capacity and interval");
+    }
+    this.tokens = capacity;
+    this.last = now();
+    this.refillPerMs = capacity / intervalMs;
+  }
+  capacity;
+  now;
+  wait;
+  tokens;
+  last;
+  refillPerMs;
+  /** Resolves once a token is available and taken. */
+  async take() {
+    for (; ; ) {
+      this.refill();
+      if (this.tokens >= 1) {
+        this.tokens -= 1;
+        return;
+      }
+      await this.wait(Math.ceil((1 - this.tokens) / this.refillPerMs));
+    }
+  }
+  /** Tokens available right now (for tests and diagnostics). */
+  available() {
+    this.refill();
+    return this.tokens;
+  }
+  refill() {
+    const now = this.now();
+    const elapsed = now - this.last;
+    if (elapsed > 0) {
+      this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.refillPerMs);
+      this.last = now;
+    }
+  }
+};
+
+// src/retry.ts
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 8e3,
+  maxRetryAfterMs: 6e4
+};
+function backoffDelay(attempt, options, random = Math.random) {
+  const ceiling = Math.min(options.maxDelayMs, options.baseDelayMs * 2 ** attempt);
+  return Math.floor(random() * ceiling);
+}
+function parseRetryAfter(value, now = Date.now()) {
+  if (value === null || value.trim() === "") return void 0;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, Math.ceil((date - now) / 1e3));
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://letsbot.net/api/v1";
+var SDK_VERSION = "0.2.0";
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+var RETRYABLE_5XX = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var LetsBotClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  retry;
+  bucket;
+  throwOnLogicalFailure;
+  fetchImpl;
+  newKey;
+  userAgent;
+  sleep;
+  random;
+  constructor(options, keyLabel = "LetsBotClient: `apiKey` (the channel lb_api_key)") {
+    if (!options || typeof options.apiKey !== "string" || options.apiKey.trim() === "") {
+      throw new TypeError(`${keyLabel} is required`);
+    }
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new TypeError("LetsBotClient: no fetch available. Use Node 18+ or pass `fetch`.");
+    }
+    this.apiKey = options.apiKey.trim();
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.retry = { ...DEFAULT_RETRY, ...options.retry ?? {} };
+    this.throwOnLogicalFailure = options.throwOnLogicalFailure ?? true;
+    this.fetchImpl = fetchImpl;
+    this.newKey = options.generateIdempotencyKey ?? (() => randomUUID());
+    this.userAgent = `letsbot-sdk-typescript/${SDK_VERSION}${options.userAgent ? ` ${options.userAgent}` : ""}`;
+    this.sleep = options.sleep ?? sleep;
+    this.random = options.random ?? Math.random;
+    const perMinute = options.rateLimit === false ? null : options.rateLimit?.requestsPerMinute ?? 1e3;
+    this.bucket = perMinute === null ? null : new TokenBucket(perMinute, 6e4, options.now ?? Date.now, this.sleep);
+  }
+  /** Call any operation by its operationId and get the body. */
+  async call(operationId, ...args) {
+    return (await this.callWithResponse(operationId, ...args)).data;
+  }
+  /** Call any operation and get the body plus status, headers, Idempotency-Key and replay flag. */
+  async callWithResponse(operationId, ...args) {
+    const [params, options = {}] = args;
+    const meta = operations[operationId];
+    if (!meta) {
+      throw new TypeError(`Unknown LetsBot operation: ${String(operationId)}`);
+    }
+    const url = new URL(this.baseUrl + meta.path);
+    const headers = this.baseHeaders(options);
+    let body;
+    if (meta.params === "query") {
+      appendQuery(url, params);
+    } else if (meta.params === "body") {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(params ?? {});
+    }
+    let idempotencyKey;
+    if (meta.send && options.idempotencyKey !== false) {
+      idempotencyKey = options.idempotencyKey ?? this.newKey();
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+    const unsafeRetryAllowed = IDEMPOTENT_METHODS.has(meta.method) || meta.send && idempotencyKey !== void 0;
+    return this.perform(operationId, meta.method, url, headers, body, { idempotencyKey, unsafeRetryAllowed }, options);
+  }
+  /** Accept, auth, User-Agent and the per-call extra headers. */
+  baseHeaders(options) {
+    return {
+      Accept: "application/json",
+      ...this.authHeaders(this.apiKey),
+      "User-Agent": this.userAgent,
+      ...options.headers ?? {}
+    };
+  }
+  /** How the key travels. The /api/v1 channel API takes a Bearer token. */
+  authHeaders(apiKey) {
+    return { Authorization: `Bearer ${apiKey}` };
+  }
+  /**
+   * One request with the client's rate limit, timeout, retries and error mapping.
+   * `unsafeRetryAllowed`: whether a network error / 5xx may be retried (reads, keyed sends).
+   */
+  async perform(operationId, method, url, headers, body, retry, options) {
+    const { idempotencyKey, unsafeRetryAllowed } = retry;
+    const maxRetries = options.maxRetries ?? this.retry.maxRetries;
+    for (let attempt = 0; ; attempt++) {
+      throwIfAborted(options.signal);
+      if (this.bucket) await this.bucket.take();
+      let response;
+      try {
+        response = await this.send(url, method, headers, body, options);
+      } catch (error2) {
+        if (options.signal?.aborted) throw options.signal.reason ?? error2;
+        if (unsafeRetryAllowed && attempt < maxRetries) {
+          await this.wait(backoffDelay(attempt, this.retry, this.random), options.signal);
+          continue;
+        }
+        throw new LetsBotConnectionError(operationId, error2);
+      }
+      const parsed = await readBody(response);
+      const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+      if (response.ok && !(this.throwOnLogicalFailure && isLogicalFailure(parsed))) {
+        return {
+          data: parsed,
+          status: response.status,
+          headers: response.headers,
+          idempotencyKey,
+          replayed: response.headers.get("idempotent-replayed") === "true",
+          attempts: attempt + 1
+        };
+      }
+      const error = new LetsBotApiError({ status: response.status, body: parsed, headers: response.headers, operationId, retryAfter });
+      if (!response.ok && attempt < maxRetries && this.shouldRetry(error, unsafeRetryAllowed)) {
+        let delay = backoffDelay(attempt, this.retry, this.random);
+        if (retryAfter !== void 0) {
+          if (retryAfter * 1e3 > this.retry.maxRetryAfterMs) throw error;
+          delay = retryAfter * 1e3;
+        }
+        await this.wait(delay, options.signal);
+        continue;
+      }
+      throw error;
+    }
+  }
+  shouldRetry(error, unsafeRetryAllowed) {
+    if (error.status === 429) return true;
+    if (error.status === 409 && error.code === "idempotency_request_in_progress") return true;
+    return RETRYABLE_5XX.has(error.status) && unsafeRetryAllowed;
+  }
+  async send(url, method, headers, body, options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new Error(`timed out after ${options.timeoutMs ?? this.timeoutMs} ms`)), options.timeoutMs ?? this.timeoutMs);
+    const onAbort = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      return await this.fetchImpl(url.toString(), { method, headers, body, signal: controller.signal });
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async wait(ms, signal) {
+    await this.sleep(ms);
+    throwIfAborted(signal);
+  }
+};
+function appendQuery(url, params) {
+  for (const [key, value] of Object.entries(params ?? {})) {
+    if (value === void 0 || value === null) continue;
+    url.searchParams.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+  }
+}
+async function readBody(response) {
+  const text = await response.text();
+  if (text === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new Error("aborted");
+  }
+}
+
+// src/resources.ts
+var resourceMap = {
+  messages: {
+    send: "sendMessage",
+    sendDisappearing: "sendDisappearingMessage",
+    forward: "forwardMessage",
+    sendSticker: "sendSticker",
+    react: "sendReaction",
+    reply: "sendReply",
+    mention: "sendMention",
+    sendList: "sendList",
+    fetch: "getMessages",
+    get: "getMessageByID",
+    delete: "deleteMessage"
+  },
+  media: {
+    sendFile: "sendFile",
+    sendImage: "sendImage",
+    sendAudio: "sendAudio",
+    sendVideo: "sendVideo",
+    sendGif: "sendGif",
+    sendLocation: "sendLocation",
+    sendVoiceNote: "sendPTT",
+    sendContact: "sendContact",
+    shareCatalog: "shareCatalog"
+  },
+  interactive: {
+    sendButtons: "sendButtons",
+    sendButtonsWithImage: "sendButtonsWithImage",
+    sendButtonsWithVideo: "sendButtonsWithVideo",
+    sendButtonsWithLocation: "sendButtonsWithLocation",
+    sendButtonsWithDocument: "sendButtonsWithDocument",
+    sendButtonsTemplate: "sendButtonsTemplate",
+    sendButtonsTemplateWithImage: "sendButtonsTemplateWithImage",
+    sendButtonsTemplateWithVideo: "sendButtonsTemplateWithVideo",
+    sendButtonsTemplateWithLocation: "sendButtonsTemplateWithLocation",
+    sendButtonsTemplateWithDocument: "sendButtonsTemplateWithDocument",
+    sendCarousel: "sendCarousel"
+  },
+  templates: {
+    send: "sendWhatsAppTemplate",
+    sendSimple: "sendSimpleTemplate",
+    sendWithImage: "sendTemplateWithImage",
+    sendWithDocument: "sendTemplateWithDocument",
+    sendWithVideo: "sendTemplateWithVideo"
+  },
+  chats: {
+    list: "getChatList",
+    conversation: "getConversation",
+    typing: "setTyping",
+    recording: "setRecording",
+    read: "readChat",
+    unread: "unreadChat",
+    archive: "archiveChat",
+    unarchive: "unarchiveChat",
+    mute: "muteChat",
+    unmute: "unmuteChat",
+    pin: "pinChat",
+    unpin: "unpinChat",
+    checkPhone: "checkPhone"
+  },
+  contacts: {
+    list: "getContacts",
+    get: "getContact",
+    listModerators: "getModerators",
+    assignModerator: "setContactModerator",
+    listLabels: "getLabels",
+    addLabel: "setContactLabel"
+  },
+  groups: {
+    create: "createGroup",
+    join: "joinGroup",
+    list: "getGroupList",
+    conversation: "getGroupConversation",
+    metadata: "groupMetadata",
+    settings: "groupSettings",
+    rename: "renameGroup",
+    setDescription: "setGroupDescription",
+    addParticipants: "addGroupParticipant",
+    removeParticipants: "removeGroupParticipant",
+    promoteParticipants: "promoteGroupParticipant",
+    demoteParticipants: "demoteGroupParticipant",
+    setPicture: "setChatDisplayPicture",
+    getPicture: "getChatDisplayPicture"
+  },
+  invites: {
+    getCode: "inviteCode",
+    revokeCode: "revokeInviteCode",
+    sendLink: "sendInviteLink",
+    getInfo: "groupGetInviteInfo"
+  },
+  user: {
+    setName: "setProfileName",
+    businessProfile: "userBusinessProfile",
+    block: "blockUser",
+    unblock: "unblockUser",
+    setPicture: "setDisplayPicture",
+    status: "userStatus",
+    setStatus: "setUserStatus",
+    presence: "userPresence",
+    picture: "userDisplayPicture"
+  },
+  instance: {
+    status: "status",
+    setStatus: "setStatus",
+    setPresence: "setPresence",
+    setSettings: "setSettings",
+    queryBroadcast: "queryBroadcast"
+  },
+  products: {
+    list: "getProducts",
+    get: "getProduct",
+    create: "createProduct",
+    collections: "getCollections",
+    getOrder: "getOrder"
+  },
+  session: {
+    qr: "qr",
+    find: "findSession",
+    status: "sessionStatus"
+  },
+  archive: {
+    list: "index"
+  }
+};
+function bindResource(client, map) {
+  const bound = {};
+  for (const [name, operationId] of Object.entries(map)) {
+    bound[name] = (...args) => client.call(operationId, ...args);
+  }
+  return bound;
+}
+async function* iterateArchive(client, params, options) {
+  let cursor;
+  do {
+    const page = await client.call("index", { ...params, ...cursor ? { cursor } : {} }, options);
+    yield* page.data;
+    cursor = page.next_cursor ?? void 0;
+  } while (cursor);
+}
+var LEGACY_WEBHOOK_SECRET = "Letsbot";
+function experimental_verifyWebhookSignature(rawBody, signature, secret = LEGACY_WEBHOOK_SECRET) {
+  if (typeof signature !== "string" || !/^[0-9a-f]{64}$/i.test(signature.trim())) return false;
+  const expected = createHmac("sha256", secret).update(rawBody).digest();
+  const given = Buffer.from(signature.trim(), "hex");
+  return given.length === expected.length && timingSafeEqual(given, expected);
+}
+
+// src/generated/crm-operations.ts
+var crmOperations = {
+  crmAddCompanyNote: { method: "POST", path: "/companies/{id}/notes", body: true },
+  crmAddContactNote: { method: "POST", path: "/contacts/{id}/notes", body: true },
+  crmAddDealNote: { method: "POST", path: "/deals/{id}/notes", body: true },
+  crmCompaniesSchema: { method: "GET", path: "/companies/schema", body: false },
+  crmCompleteTask: { method: "POST", path: "/tasks/{id}/complete", body: false },
+  crmContactsSchema: { method: "GET", path: "/contacts/schema", body: false },
+  crmCreateActivity: { method: "POST", path: "/activities", body: true },
+  crmCreateCompany: { method: "POST", path: "/companies", body: true },
+  crmCreateContact: { method: "POST", path: "/contacts", body: true },
+  crmCreateDeal: { method: "POST", path: "/deals", body: true },
+  crmCreateProduct: { method: "POST", path: "/products", body: true },
+  crmCreateQuote: { method: "POST", path: "/quotes", body: true },
+  crmCreateTask: { method: "POST", path: "/tasks", body: true },
+  crmDeleteCompany: { method: "DELETE", path: "/companies/{id}", body: false },
+  crmDeleteDeal: { method: "DELETE", path: "/deals/{id}", body: false },
+  crmDeleteProduct: { method: "DELETE", path: "/products/{id}", body: false },
+  crmDeleteQuote: { method: "DELETE", path: "/quotes/{id}", body: false },
+  crmDeleteTask: { method: "DELETE", path: "/tasks/{id}", body: false },
+  crmGetActivity: { method: "GET", path: "/activities/{id}", body: false },
+  crmGetCompany: { method: "GET", path: "/companies/{id}", body: false },
+  crmGetContact: { method: "GET", path: "/contacts/{id}", body: false },
+  crmGetDeal: { method: "GET", path: "/deals/{id}", body: false },
+  crmGetProduct: { method: "GET", path: "/products/{id}", body: false },
+  crmGetQuote: { method: "GET", path: "/quotes/{id}", body: false },
+  crmGetTask: { method: "GET", path: "/tasks/{id}", body: false },
+  crmHookSample: { method: "GET", path: "/hooks/sample", body: false },
+  crmLinkCompanyContact: { method: "POST", path: "/companies/{id}/contacts", body: true },
+  crmListActivities: { method: "GET", path: "/activities", body: false },
+  crmListCompanies: { method: "GET", path: "/companies", body: false },
+  crmListContacts: { method: "GET", path: "/contacts", body: false },
+  crmListDeals: { method: "GET", path: "/deals", body: false },
+  crmListHookEvents: { method: "GET", path: "/hooks/events", body: false },
+  crmListHooks: { method: "GET", path: "/hooks", body: false },
+  crmListLostReasons: { method: "GET", path: "/deals/lost-reasons", body: false },
+  crmListPipelines: { method: "GET", path: "/pipelines", body: false },
+  crmListProducts: { method: "GET", path: "/products", body: false },
+  crmListQuotes: { method: "GET", path: "/quotes", body: false },
+  crmListTasks: { method: "GET", path: "/tasks", body: false },
+  crmMarkDealLost: { method: "POST", path: "/deals/{id}/lost", body: true },
+  crmMarkDealWon: { method: "POST", path: "/deals/{id}/won", body: false },
+  crmMoveDealStage: { method: "POST", path: "/deals/{id}/stage", body: true },
+  crmProductsSchema: { method: "GET", path: "/products/schema", body: false },
+  crmQuotesSchema: { method: "GET", path: "/quotes/schema", body: false },
+  crmSearchCompanies: { method: "GET", path: "/companies/search", body: false },
+  crmSearchContacts: { method: "GET", path: "/contacts/search", body: false },
+  crmSearchDeals: { method: "GET", path: "/deals/search", body: false },
+  crmSubscribeHook: { method: "POST", path: "/hooks", body: true },
+  crmUnlinkCompanyContact: { method: "DELETE", path: "/companies/{id}/contacts/{contactId}", body: false },
+  crmUnsubscribeHook: { method: "DELETE", path: "/hooks/{id}", body: false },
+  crmUpdateCompany: { method: "PATCH", path: "/companies/{id}", body: true },
+  crmUpdateContact: { method: "PATCH", path: "/contacts/{id}", body: true },
+  crmUpdateDeal: { method: "PATCH", path: "/deals/{id}", body: true },
+  crmUpdateProduct: { method: "PATCH", path: "/products/{id}", body: true },
+  crmUpdateQuote: { method: "PATCH", path: "/quotes/{id}", body: true },
+  crmUpdateTask: { method: "PATCH", path: "/tasks/{id}", body: true }
+};
+
+// src/crm.ts
+var CRM_DEFAULT_RATE_LIMIT = 120;
+var CRM_SIGNATURE_HEADER = "X-LetsBot-Signature";
+var crmResourceMap = {
+  contacts: {
+    list: "crmListContacts",
+    schema: "crmContactsSchema",
+    search: "crmSearchContacts",
+    get: "crmGetContact",
+    create: "crmCreateContact",
+    update: "crmUpdateContact",
+    addNote: "crmAddContactNote"
+  },
+  companies: {
+    list: "crmListCompanies",
+    schema: "crmCompaniesSchema",
+    search: "crmSearchCompanies",
+    get: "crmGetCompany",
+    create: "crmCreateCompany",
+    update: "crmUpdateCompany",
+    delete: "crmDeleteCompany",
+    linkContact: "crmLinkCompanyContact",
+    unlinkContact: "crmUnlinkCompanyContact",
+    addNote: "crmAddCompanyNote"
+  },
+  deals: {
+    list: "crmListDeals",
+    pipelines: "crmListPipelines",
+    lostReasons: "crmListLostReasons",
+    search: "crmSearchDeals",
+    get: "crmGetDeal",
+    create: "crmCreateDeal",
+    update: "crmUpdateDeal",
+    delete: "crmDeleteDeal",
+    moveStage: "crmMoveDealStage",
+    markWon: "crmMarkDealWon",
+    markLost: "crmMarkDealLost",
+    addNote: "crmAddDealNote"
+  },
+  tasks: {
+    list: "crmListTasks",
+    get: "crmGetTask",
+    create: "crmCreateTask",
+    update: "crmUpdateTask",
+    delete: "crmDeleteTask",
+    complete: "crmCompleteTask"
+  },
+  activities: {
+    list: "crmListActivities",
+    get: "crmGetActivity",
+    create: "crmCreateActivity"
+  },
+  quotes: {
+    list: "crmListQuotes",
+    schema: "crmQuotesSchema",
+    get: "crmGetQuote",
+    create: "crmCreateQuote",
+    update: "crmUpdateQuote",
+    delete: "crmDeleteQuote"
+  },
+  products: {
+    list: "crmListProducts",
+    schema: "crmProductsSchema",
+    get: "crmGetProduct",
+    create: "crmCreateProduct",
+    update: "crmUpdateProduct",
+    delete: "crmDeleteProduct"
+  },
+  hooks: {
+    list: "crmListHooks",
+    events: "crmListHookEvents",
+    sample: "crmHookSample",
+    subscribe: "crmSubscribeHook",
+    unsubscribe: "crmUnsubscribeHook"
+  }
+};
+var UNSAFE = /* @__PURE__ */ new Set(["POST", "PATCH", "PUT", "DELETE"]);
+function crmBaseUrl(workspace) {
+  const raw = workspace.trim();
+  if (raw === "") throw new TypeError("LetsBotCrm: `workspace` is empty");
+  const host = (/^https?:\/\//i.test(raw) ? new URL(raw).host : raw.split("/")[0]).toLowerCase();
+  return `https://${host.includes(".") ? host : `${host}.letsbot.net`}/api/v1/crm`;
+}
+var CrmTransport = class extends LetsBotClient {
+  authHeaders(apiKey) {
+    return { "X-Zapier-Api-Key": apiKey };
+  }
+  request(operationId, method, url, json, options) {
+    const headers = this.baseHeaders(options);
+    let body;
+    if (json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(json);
+    }
+    return this.perform(operationId, method, url, headers, body, { unsafeRetryAllowed: !UNSAFE.has(method) }, options);
+  }
+  get root() {
+    return this.baseUrl;
+  }
+};
+var LetsBotCrm = class {
+  contacts;
+  companies;
+  deals;
+  tasks;
+  activities;
+  quotes;
+  products;
+  hooks;
+  transport;
+  constructor(options) {
+    if (!options?.baseUrl && !options?.workspace) {
+      throw new TypeError("LetsBotCrm: pass `workspace` (e.g. mystore.letsbot.net) or `baseUrl`");
+    }
+    this.transport = new CrmTransport(
+      {
+        ...options,
+        baseUrl: options.baseUrl ?? crmBaseUrl(options.workspace),
+        rateLimit: options.rateLimit === false ? false : { requestsPerMinute: options.rateLimit?.requestsPerMinute ?? CRM_DEFAULT_RATE_LIMIT }
+      },
+      "LetsBotCrm: `apiKey` (a workspace API key with the crm scope)"
+    );
+    const bind = (map) => {
+      const bound = {};
+      for (const [name, id] of Object.entries(map)) {
+        bound[name] = (params, options2) => this.call(id, ...[params, options2]);
+      }
+      return bound;
+    };
+    this.contacts = bind(crmResourceMap.contacts);
+    this.companies = bind(crmResourceMap.companies);
+    this.deals = bind(crmResourceMap.deals);
+    this.tasks = bind(crmResourceMap.tasks);
+    this.activities = bind(crmResourceMap.activities);
+    this.quotes = bind(crmResourceMap.quotes);
+    this.products = bind(crmResourceMap.products);
+    this.hooks = bind(crmResourceMap.hooks);
+  }
+  /** The resolved base URL, e.g. `https://mystore.letsbot.net/api/v1/crm`. */
+  get baseUrl() {
+    return this.transport.root;
+  }
+  /** Call any CRM operation by its operationId and get the body. */
+  async call(operationId, ...args) {
+    return (await this.callWithResponse(operationId, ...args)).data;
+  }
+  /** Call any CRM operation and get the body plus status and headers. */
+  async callWithResponse(operationId, ...args) {
+    const [params = {}, options = {}] = args;
+    const meta = crmOperations[operationId];
+    if (!meta) throw new TypeError(`Unknown LetsBot CRM operation: ${String(operationId)}`);
+    const rest = { ...params };
+    const path = meta.path.replace(/\{(\w+)\}/g, (_, name) => {
+      const value = rest[name];
+      if (value === void 0 || value === null || value === "") {
+        throw new TypeError(`${operationId}: \`${name}\` is required`);
+      }
+      delete rest[name];
+      return encodeURIComponent(String(value));
+    });
+    const url = new URL(this.transport.root + path);
+    if (!meta.body) {
+      for (const [key, value] of Object.entries(rest)) {
+        if (value === void 0 || value === null) continue;
+        url.searchParams.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+      }
+    }
+    return this.transport.request(operationId, meta.method, url, meta.body ? rest : void 0, options);
+  }
+  /**
+   * Every row of a list, page by page (`meta.last_page`).
+   *
+   * ```ts
+   * for await (const deal of crm.iterate('crmListDeals', { status: 'won', sort: 'updated_at', dir: 'desc' })) { … }
+   * ```
+   */
+  async *iterate(operationId, params = {}, options) {
+    for (let page = 1; ; page++) {
+      const body = await this.call(operationId, ...[{ per_page: 100, ...params, page }, options]);
+      yield* body.data;
+      if (body.data.length === 0 || page >= (body.meta?.last_page ?? page)) return;
+    }
+  }
+};
+function verifyCrmWebhookSignature(rawBody, header, secret, options = {}) {
+  if (typeof header !== "string" || !secret) return false;
+  const parts = /* @__PURE__ */ new Map();
+  for (const piece of header.split(",")) {
+    const index = piece.indexOf("=");
+    if (index > 0) parts.set(piece.slice(0, index).trim(), piece.slice(index + 1).trim());
+  }
+  const t = parts.get("t") ?? "";
+  const v1 = parts.get("v1") ?? "";
+  if (!/^\d+$/.test(t) || !/^[0-9a-f]{64}$/i.test(v1)) return false;
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - Number(t)) > (options.toleranceSeconds ?? 300)) return false;
+  const expected = createHmac("sha256", secret).update(`${t}.`).update(rawBody).digest();
+  const given = Buffer.from(v1, "hex");
+  return given.length === expected.length && timingSafeEqual(given, expected);
+}
+var IDENTITY_MAX_SUB_LENGTH = 191;
+var IDENTITY_MAX_TTL_SECONDS = 7 * 24 * 60 * 60;
+var IDENTITY_DEFAULT_TTL = "24h";
+var UNIT_SECONDS = { s: 1, m: 60, h: 3600, d: 86400 };
+function ttlSeconds(value) {
+  let seconds;
+  if (typeof value === "number") {
+    seconds = value;
+  } else if (typeof value === "string") {
+    const match = /^\s*(\d+)\s*([smhd]?)\s*$/.exec(value);
+    if (!match) throw new TypeError(`expiresIn must be seconds or a string like "24h", got "${value}"`);
+    seconds = Number(match[1]) * UNIT_SECONDS[match[2] || "s"];
+  } else {
+    throw new TypeError('expiresIn must be a number of seconds or a string like "24h"');
+  }
+  if (!Number.isInteger(seconds) || seconds <= 0) {
+    throw new RangeError("expiresIn must be a positive whole number of seconds");
+  }
+  if (seconds > IDENTITY_MAX_TTL_SECONDS) {
+    throw new RangeError(`expiresIn must be at most 7 days (${IDENTITY_MAX_TTL_SECONDS} seconds)`);
+  }
+  return seconds;
+}
+function unixNow(now) {
+  if (now === void 0) return Math.floor(Date.now() / 1e3);
+  const value = now instanceof Date ? Math.floor(now.getTime() / 1e3) : Math.floor(now);
+  if (!Number.isFinite(value) || value < 0) throw new TypeError("now must be a valid Date or Unix time in seconds");
+  return value;
+}
+function base64url(input) {
+  return Buffer.from(input).toString("base64url");
+}
+function optionalClaim(name, value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new TypeError(`${name} must be a string`);
+  return value;
+}
+function createIdentityToken(options) {
+  if (options === null || typeof options !== "object") throw new TypeError("options are required");
+  const { userId, secret, expiresIn = IDENTITY_DEFAULT_TTL, now } = options;
+  if (typeof secret !== "string" || secret.length === 0) {
+    throw new TypeError("secret must be a non-empty string (the app's Identity Secret)");
+  }
+  if (typeof userId === "number" && !Number.isFinite(userId)) throw new TypeError("userId must be a finite number or a string");
+  if (typeof userId !== "string" && typeof userId !== "number") throw new TypeError("userId must be a string or a number");
+  const sub = String(userId).trim();
+  if (sub.length === 0) throw new TypeError("userId must not be empty");
+  if ([...sub].length > IDENTITY_MAX_SUB_LENGTH) {
+    throw new RangeError(`userId must be at most ${IDENTITY_MAX_SUB_LENGTH} characters`);
+  }
+  const iat = unixNow(now);
+  const claims = { sub, iat, exp: iat + ttlSeconds(expiresIn) };
+  const name = optionalClaim("name", options.name);
+  const email = optionalClaim("email", options.email);
+  const phone = optionalClaim("phone", options.phone);
+  if (name !== void 0) claims.name = name;
+  if (email !== void 0) claims.email = email;
+  if (phone !== void 0) claims.phone = phone;
+  const signingInput = `${base64url(JSON.stringify({ alg: "HS256", typ: "JWT" }))}.${base64url(JSON.stringify(claims))}`;
+  const signature = createHmac("sha256", secret).update(signingInput).digest("base64url");
+  return `${signingInput}.${signature}`;
+}
+
+// src/index.ts
+var LetsBot = class extends LetsBotClient {
+  messages;
+  media;
+  interactive;
+  templates;
+  chats;
+  contacts;
+  groups;
+  invites;
+  user;
+  instance;
+  products;
+  session;
+  archive;
+  constructor(options) {
+    super(options);
+    this.messages = bindResource(this, resourceMap.messages);
+    this.media = bindResource(this, resourceMap.media);
+    this.interactive = bindResource(this, resourceMap.interactive);
+    this.templates = bindResource(this, resourceMap.templates);
+    this.chats = bindResource(this, resourceMap.chats);
+    this.contacts = bindResource(this, resourceMap.contacts);
+    this.groups = bindResource(this, resourceMap.groups);
+    this.invites = bindResource(this, resourceMap.invites);
+    this.user = bindResource(this, resourceMap.user);
+    this.instance = bindResource(this, resourceMap.instance);
+    this.products = bindResource(this, resourceMap.products);
+    this.session = bindResource(this, resourceMap.session);
+    this.archive = {
+      ...bindResource(this, resourceMap.archive),
+      iterate: (params, options2) => iterateArchive(this, params, options2)
+    };
+  }
+};
+
+export { CRM_DEFAULT_RATE_LIMIT, CRM_SIGNATURE_HEADER, DEFAULT_BASE_URL, IDENTITY_DEFAULT_TTL, IDENTITY_MAX_SUB_LENGTH, IDENTITY_MAX_TTL_SECONDS, LEGACY_WEBHOOK_SECRET, LetsBot, LetsBotApiError, LetsBotClient, LetsBotConnectionError, LetsBotCrm, SDK_VERSION, TokenBucket, createIdentityToken, crmBaseUrl, crmOperations, crmResourceMap, experimental_verifyWebhookSignature, isLogicalFailure, operations, resourceMap, verifyCrmWebhookSignature };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map