@assinafy/sdk 1.4.0

package/dist/index.js

@@ -0,0 +1,1564 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  AssignmentResource: () => AssignmentResource,
+  AssinafyClient: () => AssinafyClient,
+  AssinafyError: () => AssinafyError,
+  AuthenticationResource: () => AuthenticationResource,
+  DocumentResource: () => DocumentResource,
+  FieldsResource: () => FieldsResource,
+  NetworkError: () => NetworkError,
+  SignerDocumentsResource: () => SignerDocumentsResource,
+  SignerResource: () => SignerResource,
+  TagResource: () => TagResource,
+  TemplateResource: () => TemplateResource,
+  ValidationError: () => ValidationError,
+  WebhookResource: () => WebhookResource,
+  WebhookVerifier: () => WebhookVerifier,
+  WorkspaceResource: () => WorkspaceResource,
+  buildAssignmentPayload: () => buildAssignmentPayload
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_axios2 = __toESM(require("axios"));
+
+// src/errors.ts
+var AssinafyError = class extends Error {
+  constructor(message, context = {}, options) {
+    super(message);
+    this.name = "AssinafyError";
+    this.context = context;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+var ApiError = class _ApiError extends AssinafyError {
+  constructor(message, statusCode, responseData = null, options) {
+    super(message, { statusCode, responseData }, options);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+    this.responseData = responseData;
+  }
+  static fromResponse(statusCode, responseData) {
+    const data = responseData ?? {};
+    const rawMessage = data["message"];
+    const rawError = data["error"];
+    const message = typeof rawMessage === "string" && rawMessage.length > 0 ? rawMessage : typeof rawError === "string" ? rawError : "API request failed";
+    return new _ApiError(message, statusCode, responseData);
+  }
+};
+var ValidationError = class extends AssinafyError {
+  constructor(message = "Validation failed", errors = {}) {
+    super(message, { errors });
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var NetworkError = class extends AssinafyError {
+  constructor(message, options) {
+    super(message, {}, options);
+    this.name = "NetworkError";
+  }
+};
+
+// src/utils.ts
+var import_axios = __toESM(require("axios"));
+function handleAssinafyResponse(response) {
+  const resp = response;
+  if (resp && typeof resp === "object" && resp.status !== void 0 && "data" in resp) {
+    if (resp.status >= 200 && resp.status < 300) {
+      return resp.data;
+    }
+    throw ApiError.fromResponse(resp.status, resp);
+  }
+  return response;
+}
+function toSdkError(error, fallbackMessage) {
+  if (error instanceof AssinafyError) {
+    return error;
+  }
+  if (import_axios.default.isAxiosError(error)) {
+    const status = error.response?.status;
+    if (status) {
+      return ApiError.fromResponse(status, error.response?.data ?? null);
+    }
+    return new NetworkError(`${fallbackMessage}: ${error.message}`, { cause: error });
+  }
+  if (error instanceof Error) {
+    return new AssinafyError(`${fallbackMessage}: ${error.message}`, {}, { cause: error });
+  }
+  return new AssinafyError(fallbackMessage, { cause: error });
+}
+function createNoopLogger() {
+  return {
+    debug: () => void 0,
+    info: () => void 0,
+    warn: () => void 0,
+    error: () => void 0
+  };
+}
+function cleanParams(params) {
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+// src/resources/documents.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+
+// src/resources/base.ts
+var BaseResource = class {
+  constructor(http, defaultAccountId, logger = createNoopLogger()) {
+    this.http = http;
+    this.defaultAccountId = defaultAccountId;
+    this.logger = logger;
+  }
+  /** Resolve the effective account id, throwing if none is available. */
+  accountId(explicit) {
+    const id = explicit ?? this.defaultAccountId;
+    if (!id) {
+      throw new ValidationError(
+        "Account ID is required. Provide it as a parameter or set a default in the client."
+      );
+    }
+    return id;
+  }
+  /** Guard required path arguments (documentId, signerId, …). */
+  requireId(value, name) {
+    if (!value) {
+      throw new ValidationError(`${name} is required`);
+    }
+    return value;
+  }
+  /** Execute an HTTP call and return the unwrapped envelope body. */
+  async call(label, request) {
+    try {
+      const response = await request();
+      return handleAssinafyResponse(response.data);
+    } catch (err) {
+      throw toSdkError(err, label);
+    }
+  }
+  /** Like {@link call} but returns `null` when the API responds with 404. */
+  async callOptional(label, request) {
+    try {
+      return await this.call(label, request);
+    } catch (err) {
+      if (err instanceof ApiError && err.statusCode === 404) return null;
+      throw err;
+    }
+  }
+  /** Execute an HTTP call that returns no body (DELETE / 204). */
+  async callVoid(label, request) {
+    try {
+      const response = await request();
+      if (response.status < 200 || response.status >= 300) {
+        throw new ValidationError(`${label}: HTTP ${response.status}`);
+      }
+    } catch (err) {
+      throw toSdkError(err, label);
+    }
+  }
+  /** Execute an HTTP call that returns binary data (artifact downloads). */
+  async callBinary(label, request) {
+    try {
+      const response = await request();
+      return Buffer.from(response.data);
+    } catch (err) {
+      throw toSdkError(err, label);
+    }
+  }
+  /** Execute a paginated list call and attach meta from `X-Pagination-*` headers. */
+  async callList(label, request) {
+    try {
+      const response = await request();
+      const unwrapped = handleAssinafyResponse(response.data);
+      const data = Array.isArray(unwrapped) ? unwrapped : Array.isArray(unwrapped?.data) ? unwrapped.data : [];
+      const meta = parsePaginationMeta(response.headers);
+      return meta === void 0 ? { data } : { data, meta };
+    } catch (err) {
+      throw toSdkError(err, label);
+    }
+  }
+};
+function parsePaginationMeta(headers) {
+  if (!headers) return void 0;
+  const read = (key) => {
+    const h = headers;
+    const raw = h[key] ?? h[key.toLowerCase()];
+    if (raw === void 0 || raw === null) return void 0;
+    return Array.isArray(raw) ? String(raw[0]) : String(raw);
+  };
+  const current = toInt(read("x-pagination-current-page"));
+  const perPage = toInt(read("x-pagination-per-page"));
+  const total = toInt(read("x-pagination-total-count"));
+  const lastPage = toInt(read("x-pagination-page-count"));
+  if (current === void 0 && perPage === void 0 && total === void 0 && lastPage === void 0) {
+    return void 0;
+  }
+  const meta = {};
+  if (current !== void 0) meta.current_page = current;
+  if (perPage !== void 0) meta.per_page = perPage;
+  if (total !== void 0) meta.total = total;
+  if (lastPage !== void 0) meta.last_page = lastPage;
+  return meta;
+}
+function toInt(value) {
+  if (value === void 0) return void 0;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+
+// src/resources/documents.ts
+var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+var READY_STATUSES = /* @__PURE__ */ new Set([
+  "metadata_ready",
+  "pending_signature",
+  "certificated"
+]);
+var FAILED_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "rejected_by_signer",
+  "rejected_by_user",
+  "expired"
+]);
+var DocumentResource = class extends BaseResource {
+  /**
+   * Upload a PDF to the workspace.
+   *
+   * @example
+   * ```ts
+   * await client.documents.upload({ filePath: './contract.pdf' });
+   * await client.documents.upload({ buffer, fileName: 'contract.pdf' }, { metadata });
+   * ```
+   */
+  async upload(source, options = {}) {
+    const { buffer, fileName } = await loadSource(source);
+    validateUpload(buffer, fileName);
+    const accountId = this.accountId(options.accountId);
+    const form = buildUploadForm(buffer, fileName, options.metadata);
+    this.logger.info("Uploading document", { fileName, size: buffer.byteLength });
+    const document = await this.call(
+      "Document upload failed",
+      () => this.http.post(`/accounts/${accountId}/documents`, form, {
+        headers: { "Content-Type": "multipart/form-data" }
+      })
+    );
+    if (!document?.id) {
+      throw new ValidationError("Upload succeeded but no document ID was returned", {
+        response: document
+      });
+    }
+    this.logger.info("Document uploaded", { documentId: document.id });
+    return document;
+  }
+  /**
+   * List workspace documents. Pagination info (if any) is attached in `meta`.
+   * Supports `status`, `method`, `tags`, `search`, `sort`, `page`, `per_page`.
+   */
+  async list(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.callList(
+      "Failed to list documents",
+      () => this.http.get(`/accounts/${id}/documents`, { params: cleanParams(params) })
+    );
+  }
+  /** Get document details. */
+  async details(documentId) {
+    const id = this.requireId(documentId, "Document ID");
+    return this.call("Failed to fetch document details", () => this.http.get(`/documents/${id}`));
+  }
+  /** Alias for {@link details}. */
+  async get(documentId) {
+    return this.details(documentId);
+  }
+  /** Poll document status until ready (or a terminal status / timeout). */
+  async waitUntilReady(documentId, options = {}) {
+    const id = this.requireId(documentId, "Document ID");
+    const maxWaitMs = options.maxWaitMs ?? 3e4;
+    const pollIntervalMs = options.pollIntervalMs ?? 2e3;
+    const start = Date.now();
+    let attempts = 0;
+    this.logger.info("Waiting for document to be ready", { documentId: id, maxWaitMs });
+    while (Date.now() - start < maxWaitMs) {
+      attempts++;
+      try {
+        const details = await this.details(id);
+        const status = details.status ?? "unknown";
+        this.logger.debug("Document status check", { attempts, status });
+        if (READY_STATUSES.has(status)) return details;
+        if (FAILED_STATUSES.has(status)) {
+          throw new ValidationError(`Document processing failed with status: ${status}`, {
+            status
+          });
+        }
+      } catch (err) {
+        if (err instanceof ValidationError) throw err;
+        this.logger.warn("Error checking document status", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      await sleep(pollIntervalMs);
+    }
+    throw new ValidationError("Timeout waiting for document to be ready", {
+      documentId: id,
+      attempts
+    });
+  }
+  /** Download a document artifact. Defaults to the certificated (signed) PDF. */
+  async download(documentId, artifactName = "certificated") {
+    const id = this.requireId(documentId, "Document ID");
+    return this.callBinary(
+      "Failed to download document",
+      () => this.http.get(`/documents/${id}/download/${artifactName}`, {
+        responseType: "arraybuffer"
+      })
+    );
+  }
+  /** Download the document thumbnail. */
+  async thumbnail(documentId) {
+    const id = this.requireId(documentId, "Document ID");
+    return this.callBinary(
+      "Failed to download document thumbnail",
+      () => this.http.get(`/documents/${id}/thumbnail`, { responseType: "arraybuffer" })
+    );
+  }
+  /** Download a single page as a JPEG. */
+  async downloadPage(documentId, pageId) {
+    const docId = this.requireId(documentId, "Document ID");
+    const pid = this.requireId(pageId, "Page ID");
+    return this.callBinary(
+      "Failed to download page",
+      () => this.http.get(`/documents/${docId}/pages/${pid}/download`, {
+        responseType: "arraybuffer"
+      })
+    );
+  }
+  /** Fetch the document activity log. */
+  async activities(documentId) {
+    const id = this.requireId(documentId, "Document ID");
+    const result = await this.call(
+      "Failed to fetch document activities",
+      () => this.http.get(`/documents/${id}/activities`)
+    );
+    return result ?? [];
+  }
+  /** Delete a document. */
+  async delete(documentId) {
+    const id = this.requireId(documentId, "Document ID");
+    return this.callVoid("Failed to delete document", () => this.http.delete(`/documents/${id}`));
+  }
+  /** List the tags attached to a document. */
+  async listTags(documentId, accountId) {
+    const accId = this.accountId(accountId);
+    const docId = this.requireId(documentId, "Document ID");
+    return this.call(
+      "Failed to list document tags",
+      () => this.http.get(`/accounts/${accId}/documents/${docId}/tags`)
+    );
+  }
+  /**
+   * Replace the document's tag set with `tags` (an array of tag names).
+   * Unknown names are auto-created; an empty array detaches all tags.
+   */
+  async replaceTags(documentId, tags, accountId) {
+    const accId = this.accountId(accountId);
+    const docId = this.requireId(documentId, "Document ID");
+    if (!Array.isArray(tags)) throw new ValidationError("tags must be an array of tag names");
+    return this.call(
+      "Failed to replace document tags",
+      () => this.http.put(`/accounts/${accId}/documents/${docId}/tags`, { tags })
+    );
+  }
+  /** Attach additional tags (by name) without removing existing ones. Idempotent. */
+  async addTags(documentId, tags, accountId) {
+    const accId = this.accountId(accountId);
+    const docId = this.requireId(documentId, "Document ID");
+    if (!Array.isArray(tags) || tags.length === 0) {
+      throw new ValidationError("tags must be a non-empty array of tag names");
+    }
+    return this.call(
+      "Failed to add document tags",
+      () => this.http.post(`/accounts/${accId}/documents/${docId}/tags`, { tags })
+    );
+  }
+  /** Detach a single tag from a document (the tag itself is not deleted). */
+  async detachTag(documentId, tagId, accountId) {
+    const accId = this.accountId(accountId);
+    const docId = this.requireId(documentId, "Document ID");
+    const tid = this.requireId(tagId, "Tag ID");
+    return this.callVoid(
+      "Failed to detach document tag",
+      () => this.http.delete(`/accounts/${accId}/documents/${docId}/tags/${tid}`)
+    );
+  }
+  /**
+   * Create a document from a template.
+   *
+   * @example
+   * ```ts
+   * await client.documents.createFromTemplate('tmpl_id', [
+   *   { role_id: 'role_id', id: 'signer_id', verification_method: 'Email', notification_methods: ['Email'] },
+   * ], { name: 'My Contract' });
+   * ```
+   */
+  async createFromTemplate(templateId, signers, options = {}, accountId) {
+    const tmplId = this.requireId(templateId, "Template ID");
+    const accId = this.accountId(accountId);
+    const body = { signers, ...options };
+    this.logger.info("Creating document from template", { templateId: tmplId, accountId: accId });
+    return this.call(
+      "Failed to create document from template",
+      () => this.http.post(`/accounts/${accId}/templates/${tmplId}/documents`, body)
+    );
+  }
+  /** Estimate the credit cost of creating a document from a template. */
+  async estimateCostFromTemplate(templateId, signers, accountId) {
+    const tmplId = this.requireId(templateId, "Template ID");
+    const accId = this.accountId(accountId);
+    return this.call(
+      "Failed to estimate cost from template",
+      () => this.http.post(`/accounts/${accId}/templates/${tmplId}/documents/estimate-cost`, { signers })
+    );
+  }
+  /** Verify a document by its signature hash. */
+  async verify(hash) {
+    const h = this.requireId(hash, "Signature hash");
+    return this.call("Failed to verify document", () => this.http.get(`/documents/${h}/verify`));
+  }
+  /**
+   * `GET /documents/statuses` — list every possible document status with
+   * its description and whether documents in that status can be deleted.
+   */
+  async statuses() {
+    return this.call(
+      "Failed to list document statuses",
+      () => this.http.get("/documents/statuses")
+    );
+  }
+  /**
+   * `GET /public/documents/{document_id}` — public, unauthenticated lookup of
+   * basic document info (used by the signing portal before the signer
+   * authenticates via the access code).
+   */
+  async getPublic(documentId) {
+    const id = this.requireId(documentId, "Document ID");
+    return this.call(
+      "Failed to fetch public document info",
+      () => this.http.get(`/public/documents/${id}`)
+    );
+  }
+  /**
+   * `PUT /public/documents/{document_id}/send-token` — send the 6-digit
+   * verification token to the signer's email / WhatsApp.
+   */
+  async sendToken(documentId, recipient, channel = "email") {
+    const id = this.requireId(documentId, "Document ID");
+    if (!recipient) throw new ValidationError("recipient is required");
+    return this.call(
+      "Failed to send signing token",
+      () => this.http.put(`/public/documents/${id}/send-token`, { recipient, channel })
+    );
+  }
+  /** Quick check: has every signer completed their assignment? */
+  async isFullySigned(documentId) {
+    const details = await this.details(documentId);
+    if (details.status === "certificated") return true;
+    const summary = details.assignment?.summary;
+    if (summary && typeof summary.signer_count === "number") {
+      return summary.signer_count > 0 && summary.signer_count === summary.completed_count;
+    }
+    return false;
+  }
+  /** Summarise signing progress for UI display. */
+  async getSigningProgress(documentId) {
+    const details = await this.details(documentId);
+    const summary = details.assignment?.summary;
+    const total = summary?.signer_count ?? details.assignment?.signers?.length ?? 0;
+    const signed = summary?.completed_count ?? 0;
+    const pending = Math.max(total - signed, 0);
+    const percentage = total > 0 ? Math.round(signed / total * 1e4) / 100 : 0;
+    return { signed, total, pending, percentage };
+  }
+};
+async function loadSource(source) {
+  if ("buffer" in source) {
+    if (!source.fileName) {
+      throw new ValidationError("fileName is required when uploading a Buffer");
+    }
+    return { buffer: source.buffer, fileName: source.fileName };
+  }
+  if (!source.filePath) {
+    throw new ValidationError("filePath is required");
+  }
+  const buffer = await import_node_fs.promises.readFile(source.filePath);
+  return { buffer, fileName: source.fileName ?? import_node_path.default.basename(source.filePath) };
+}
+function validateUpload(buffer, fileName) {
+  if (!buffer || buffer.byteLength === 0) {
+    throw new ValidationError("File buffer is empty", { fileName });
+  }
+  if (!fileName.toLowerCase().endsWith(".pdf")) {
+    throw new ValidationError("Only PDF files are supported", { fileName });
+  }
+  if (buffer.byteLength > MAX_UPLOAD_BYTES) {
+    throw new ValidationError("File size exceeds maximum allowed (25MB)", {
+      fileSize: buffer.byteLength,
+      maxSize: MAX_UPLOAD_BYTES
+    });
+  }
+}
+function buildUploadForm(buffer, fileName, metadata) {
+  const form = new FormData();
+  const view = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  form.append("file", new Blob([view], { type: "application/pdf" }), fileName);
+  form.append("name", fileName);
+  if (metadata) {
+    form.append("metadata", JSON.stringify(metadata));
+  }
+  return form;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resources/signers.ts
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var SignerResource = class extends BaseResource {
+  /**
+   * Create a signer in the workspace.
+   *
+   * `email` is optional — the API also accepts whatsapp-only signers — but at
+   * least one of `email` / `whatsapp_phone_number` (or the `phone` alias) is
+   * required. When an `email` is supplied the call is idempotent by email:
+   * an existing signer with that address is reused instead of duplicated.
+   */
+  async create(payload, accountId) {
+    const id = this.accountId(accountId);
+    const phone = payload.whatsapp_phone_number ?? payload.phone;
+    if (!payload.email && !phone) {
+      throw new ValidationError(
+        "A signer requires at least an email or a whatsapp_phone_number"
+      );
+    }
+    if (payload.email) this.assertEmail(payload.email);
+    if (payload.email) {
+      const existing = await this.findByEmail(payload.email, id);
+      if (existing) {
+        this.logger.info("Using existing signer", { email: payload.email });
+        return existing;
+      }
+    }
+    this.logger.info("Creating signer", { email: payload.email });
+    try {
+      return await this.call(
+        "Failed to create signer",
+        () => this.http.post(`/accounts/${id}/signers`, normaliseSignerPayload(payload))
+      );
+    } catch (err) {
+      if (err instanceof ApiError && err.statusCode === 409 && payload.email) {
+        const duplicate = await this.findByEmail(payload.email, id);
+        if (duplicate) {
+          this.logger.info("Signer already exists, using existing signer", {
+            email: payload.email
+          });
+          return duplicate;
+        }
+      }
+      throw err;
+    }
+  }
+  /** Get a signer by ID. */
+  async get(signerId, accountId) {
+    const id = this.accountId(accountId);
+    const sid = this.requireId(signerId, "Signer ID");
+    return this.call(
+      "Failed to fetch signer",
+      () => this.http.get(`/accounts/${id}/signers/${sid}`)
+    );
+  }
+  /** List signers for the workspace (supports `page`, `per_page`, `search`, `sort`). */
+  async list(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.callList(
+      "Failed to list signers",
+      () => this.http.get(`/accounts/${id}/signers`, { params: cleanParams(params) })
+    );
+  }
+  /** Update a signer. Fails if the signer has active assignments. */
+  async update(signerId, payload, accountId) {
+    const id = this.accountId(accountId);
+    const sid = this.requireId(signerId, "Signer ID");
+    return this.call(
+      "Failed to update signer",
+      () => this.http.put(`/accounts/${id}/signers/${sid}`, normaliseSignerPayload(payload))
+    );
+  }
+  /** Delete a signer. */
+  async delete(signerId, accountId) {
+    const id = this.accountId(accountId);
+    const sid = this.requireId(signerId, "Signer ID");
+    return this.callVoid(
+      "Failed to delete signer",
+      () => this.http.delete(`/accounts/${id}/signers/${sid}`)
+    );
+  }
+  /** Find a signer by email via the API's `search` parameter. Returns `null` if none match. */
+  async findByEmail(email, accountId) {
+    this.assertEmail(email);
+    try {
+      const { data } = await this.list({ search: email, per_page: 100 }, accountId);
+      const lower = email.toLowerCase();
+      return data.find((s) => (s.email ?? "").toLowerCase() === lower) ?? null;
+    } catch (err) {
+      if (err instanceof ApiError && err.statusCode === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  assertEmail(email) {
+    if (!email || !EMAIL_RE.test(email)) {
+      throw new ValidationError("Invalid email address", { email });
+    }
+  }
+};
+function normaliseSignerPayload(payload) {
+  const normalised = {
+    full_name: payload.full_name,
+    email: payload.email,
+    whatsapp_phone_number: payload.whatsapp_phone_number ?? payload.phone
+  };
+  if (payload.cpf) {
+    normalised["cpf"] = payload.cpf.replace(/\D/g, "");
+  }
+  if ("metadata" in payload && payload.metadata !== void 0) {
+    normalised["metadata"] = payload.metadata;
+  }
+  return cleanParams(normalised);
+}
+
+// src/resources/workspaces.ts
+var WorkspaceResource = class extends BaseResource {
+  /** Create a new workspace. */
+  async create(payload) {
+    return this.call("Failed to create workspace", () => this.http.post("/accounts", payload));
+  }
+  /** List workspaces the authenticated user can access. */
+  async list() {
+    return this.callList(
+      "Failed to list workspaces",
+      () => this.http.get("/accounts")
+    );
+  }
+  /** Fetch a single workspace. */
+  async get(accountId) {
+    const id = this.requireId(accountId, "Account ID");
+    return this.call("Failed to fetch workspace", () => this.http.get(`/accounts/${id}`));
+  }
+  /** Update a workspace. */
+  async update(accountId, payload) {
+    const id = this.requireId(accountId, "Account ID");
+    return this.call("Failed to update workspace", () => this.http.put(`/accounts/${id}`, payload));
+  }
+  /** Delete a workspace. */
+  async delete(accountId) {
+    const id = this.requireId(accountId, "Account ID");
+    return this.callVoid("Failed to delete workspace", () => this.http.delete(`/accounts/${id}`));
+  }
+};
+
+// src/resources/assignments.ts
+function buildAssignmentPayload(payload, options = {}) {
+  const signers = extractSignerRefs(payload);
+  if (signers.length === 0) {
+    throw new ValidationError("At least one signer is required", {
+      signers: payload.signers ?? payload.signer_ids ?? payload.signerIds
+    });
+  }
+  return cleanParams({
+    method: payload.method ?? "virtual",
+    signers: signers.map((ref) => normaliseSignerRef(ref, options)),
+    message: payload.message,
+    expires_at: payload.expires_at,
+    copy_receivers: payload.copy_receivers,
+    entries: payload.entries
+  });
+}
+function extractSignerRefs(payload) {
+  if (Array.isArray(payload.signers) && payload.signers.length > 0) {
+    return payload.signers;
+  }
+  const legacy = payload.signer_ids ?? payload.signerIds;
+  return Array.isArray(legacy) ? legacy : [];
+}
+function normaliseSignerRef(ref, options) {
+  if (typeof ref === "string") {
+    if (!ref) throw new ValidationError("Signer ID cannot be empty");
+    return { id: ref };
+  }
+  if (ref && typeof ref === "object") {
+    const input = ref;
+    const id = input.id ?? input.signer_id;
+    const normalised = cleanParams({
+      id,
+      verification_method: input.verification_method,
+      notification_methods: input.notification_methods,
+      step: input.step
+    });
+    if (typeof id === "string" && id.length > 0) {
+      return normalised;
+    }
+    if (options.allowSignersWithoutId && Object.keys(normalised).length > 0) {
+      return normalised;
+    }
+    if (options.allowSignersWithoutId && Object.keys(normalised).length === 0) {
+      return {};
+    }
+  }
+  throw new ValidationError("Invalid signer reference", { ref });
+}
+var AssignmentResource = class extends BaseResource {
+  /** Create a signing assignment for a document. */
+  async create(documentId, payload) {
+    const docId = this.requireId(documentId, "Document ID");
+    const signers = extractSignerRefs(payload);
+    const body = buildAssignmentPayload(payload);
+    this.logger.info("Creating assignment", {
+      documentId: docId,
+      signers: signers.length
+    });
+    return this.call(
+      "Failed to create assignment",
+      () => this.http.post(`/documents/${docId}/assignments`, body)
+    );
+  }
+  /** Estimate the cost (in credits) of creating the assignment. */
+  async estimateCost(documentId, payload) {
+    const docId = this.requireId(documentId, "Document ID");
+    return this.call(
+      "Failed to estimate assignment cost",
+      () => this.http.post(
+        `/documents/${docId}/assignments/estimate-cost`,
+        buildAssignmentPayload(payload, { allowSignersWithoutId: true })
+      )
+    );
+  }
+  /**
+   * Update the expiration date of an existing assignment.
+   * Pass `null` to remove the expiration entirely.
+   */
+  async resetExpiration(documentId, assignmentId, expiresAt) {
+    const docId = this.requireId(documentId, "Document ID");
+    const asgId = this.requireId(assignmentId, "Assignment ID");
+    return this.call(
+      "Failed to update assignment expiration",
+      () => this.http.put(`/documents/${docId}/assignments/${asgId}/reset-expiration`, {
+        expires_at: expiresAt
+      })
+    );
+  }
+  /** Resend the signing notification to a single signer. */
+  async resendNotification(documentId, assignmentId, signerId) {
+    const docId = this.requireId(documentId, "Document ID");
+    const asgId = this.requireId(assignmentId, "Assignment ID");
+    const sid = this.requireId(signerId, "Signer ID");
+    return this.call(
+      "Failed to resend signer notification",
+      () => this.http.put(`/documents/${docId}/assignments/${asgId}/signers/${sid}/resend`)
+    );
+  }
+  /** Estimate the cost of resending a signer notification. */
+  async estimateResendCost(documentId, assignmentId, signerId) {
+    const docId = this.requireId(documentId, "Document ID");
+    const asgId = this.requireId(assignmentId, "Assignment ID");
+    const sid = this.requireId(signerId, "Signer ID");
+    return this.call(
+      "Failed to estimate resend cost",
+      () => this.http.post(
+        `/documents/${docId}/assignments/${asgId}/signers/${sid}/estimate-resend-cost`
+      )
+    );
+  }
+  /**
+   * `GET /documents/{documentId}/assignments/{assignmentId}/whatsapp-notifications`
+   * — list every WhatsApp notification rendered + sent for an assignment.
+   */
+  async listWhatsAppNotifications(documentId, assignmentId) {
+    const docId = this.requireId(documentId, "Document ID");
+    const asgId = this.requireId(assignmentId, "Assignment ID");
+    return this.call(
+      "Failed to list WhatsApp notifications",
+      () => this.http.get(`/documents/${docId}/assignments/${asgId}/whatsapp-notifications`)
+    );
+  }
+  /**
+   * Cancel a signature request. This endpoint is not listed in the public
+   * Swagger but is exposed by the platform.
+   */
+  async cancel(documentId, reason, accountId) {
+    const docId = this.requireId(documentId, "Document ID");
+    const accId = this.accountId(accountId);
+    this.logger.info("Cancelling signature request", { documentId: docId, reason });
+    return this.call(
+      "Failed to cancel signature request",
+      () => this.http.post(
+        `/accounts/${accId}/signature-requests/${docId}/cancel`,
+        { document_id: docId, reason }
+      )
+    );
+  }
+};
+
+// src/resources/webhooks.ts
+var DEFAULT_EVENTS = [
+  "document_ready",
+  "document_prepared",
+  "signer_signed_document",
+  "signer_rejected_document",
+  "document_processing_failed"
+];
+var WebhookResource = class extends BaseResource {
+  /** Register (or replace) the webhook subscription for the workspace. */
+  async register(payload, accountId) {
+    if (!payload.url) throw new ValidationError("Webhook URL is required");
+    if (!payload.email) throw new ValidationError("Webhook email is required");
+    const id = this.accountId(accountId);
+    const body = {
+      url: payload.url,
+      email: payload.email,
+      events: payload.events && payload.events.length > 0 ? payload.events : DEFAULT_EVENTS,
+      is_active: payload.is_active ?? true
+    };
+    this.logger.info("Registering webhook", { url: payload.url });
+    return this.call(
+      "Failed to register webhook",
+      () => this.http.put(`/accounts/${id}/webhooks/subscriptions`, body)
+    );
+  }
+  /** Fetch the current webhook subscription. Returns `null` if none exists. */
+  async get(accountId) {
+    const id = this.accountId(accountId);
+    return this.callOptional(
+      "Failed to fetch webhook subscription",
+      () => this.http.get(`/accounts/${id}/webhooks/subscriptions`)
+    );
+  }
+  /** Delete the current webhook subscription. */
+  async delete(accountId) {
+    const id = this.accountId(accountId);
+    this.logger.info("Deleting webhook subscription");
+    return this.callVoid(
+      "Failed to delete webhook subscription",
+      () => this.http.delete(`/accounts/${id}/webhooks/subscriptions`)
+    );
+  }
+  /** Inactivate the current webhook subscription without deleting it. */
+  async inactivate(accountId) {
+    const id = this.accountId(accountId);
+    this.logger.info("Inactivating webhook subscription");
+    return this.call(
+      "Failed to inactivate webhook subscription",
+      () => this.http.put(`/accounts/${id}/webhooks/inactivate`)
+    );
+  }
+  /** List currently supported webhook event types. */
+  async listEventTypes() {
+    return this.call(
+      "Failed to list webhook event types",
+      () => this.http.get("/webhooks/event-types")
+    );
+  }
+  /** List webhook delivery history for the workspace. */
+  async listDispatches(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.callList(
+      "Failed to list webhook dispatches",
+      () => this.http.get(`/accounts/${id}/webhooks`, {
+        params: cleanParams(params)
+      })
+    );
+  }
+  /** Retry delivery of a specific webhook dispatch. */
+  async retryDispatch(dispatchId, accountId) {
+    const id = this.accountId(accountId);
+    const did = this.requireId(dispatchId, "Dispatch ID");
+    return this.call(
+      "Failed to retry webhook dispatch",
+      () => this.http.post(`/accounts/${id}/webhooks/${did}/retry`)
+    );
+  }
+};
+
+// src/resources/templates.ts
+var TemplateResource = class extends BaseResource {
+  /** List templates for the workspace. */
+  async list(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.callList(
+      "Failed to list templates",
+      () => this.http.get(`/accounts/${id}/templates`, { params: cleanParams(params) })
+    );
+  }
+  /**
+   * Get a template by ID.
+   *
+   * Note: the swagger only documents the list endpoint; this single-resource
+   * `GET /accounts/{id}/templates/{id}` is exposed by the platform and used
+   * by the official PHP SDK.
+   */
+  async get(templateId, accountId) {
+    const id = this.accountId(accountId);
+    const tmplId = this.requireId(templateId, "Template ID");
+    return this.call(
+      "Failed to fetch template",
+      () => this.http.get(`/accounts/${id}/templates/${tmplId}`)
+    );
+  }
+  /**
+   * `GET /accounts/{id}/templates/{template_id}/pages/{page_id}/download` —
+   * download a template page as a JPEG (used by template editors to render
+   * thumbnails on the client).
+   */
+  async downloadPage(templateId, pageId, accountId) {
+    const id = this.accountId(accountId);
+    const tmplId = this.requireId(templateId, "Template ID");
+    const pid = this.requireId(pageId, "Page ID");
+    return this.callBinary(
+      "Failed to download template page",
+      () => this.http.get(
+        `/accounts/${id}/templates/${tmplId}/pages/${pid}/download`,
+        { responseType: "arraybuffer" }
+      )
+    );
+  }
+};
+
+// src/resources/tags.ts
+var TagResource = class extends BaseResource {
+  /** List the workspace's tags, ordered alphabetically. Optional case-insensitive `search`. */
+  async list(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.call(
+      "Failed to list tags",
+      () => this.http.get(`/accounts/${id}/tags`, {
+        params: cleanParams(params)
+      })
+    );
+  }
+  /** Create a tag. Throws `ApiError` (409) if the name already exists (case-insensitive). */
+  async create(payload, accountId) {
+    if (!payload.name) throw new ValidationError("Tag name is required");
+    const id = this.accountId(accountId);
+    return this.call(
+      "Failed to create tag",
+      () => this.http.post(`/accounts/${id}/tags`, cleanParams({ ...payload }))
+    );
+  }
+  /**
+   * Update a tag's name and/or color. Omit a field to leave it unchanged;
+   * pass `color: null` to clear the color. Throws `ApiError` (409) if another
+   * tag already uses the new name.
+   */
+  async update(tagId, payload, accountId) {
+    const id = this.accountId(accountId);
+    const tid = this.requireId(tagId, "Tag ID");
+    const body = {};
+    if (payload.name !== void 0) body["name"] = payload.name;
+    if ("color" in payload) body["color"] = payload.color;
+    return this.call(
+      "Failed to update tag",
+      () => this.http.put(`/accounts/${id}/tags/${tid}`, body)
+    );
+  }
+  /**
+   * Delete a tag. By default fails with `ApiError` (409) if the tag is still
+   * attached to anything; pass `{ force: true }` to detach everywhere first.
+   */
+  async delete(tagId, options = {}) {
+    const id = this.accountId(options.accountId);
+    const tid = this.requireId(tagId, "Tag ID");
+    const params = options.force ? { force: "true" } : void 0;
+    return this.callVoid(
+      "Failed to delete tag",
+      () => this.http.delete(`/accounts/${id}/tags/${tid}`, { params })
+    );
+  }
+};
+
+// src/resources/authentication.ts
+var AuthenticationResource = class extends BaseResource {
+  /** `POST /login` — exchange email + password for a JWT access token. */
+  async login(email, password) {
+    if (!email) throw new ValidationError("email is required");
+    if (!password) throw new ValidationError("password is required");
+    return this.call(
+      "Login failed",
+      () => this.http.post("/login", { email, password })
+    );
+  }
+  /** `POST /authentication/social-login` — exchange a provider token for an Assinafy JWT. */
+  async socialLogin(payload) {
+    if (!payload.provider) throw new ValidationError("provider is required");
+    if (!payload.token) throw new ValidationError("token is required");
+    return this.call(
+      "Social login failed",
+      () => this.http.post("/authentication/social-login", payload)
+    );
+  }
+  /** `POST /users/api-keys` — generate (and rotate) the current user's API key. */
+  async createApiKey(password) {
+    if (!password) throw new ValidationError("password is required");
+    return this.call(
+      "Failed to create API key",
+      () => this.http.post("/users/api-keys", { password })
+    );
+  }
+  /**
+   * `GET /users/api-keys` — fetch a masked version of the current API key, or
+   * `null` if no key has been generated yet.
+   */
+  async getApiKey() {
+    const result = await this.call(
+      "Failed to fetch API key",
+      () => this.http.get("/users/api-keys")
+    );
+    return result ?? null;
+  }
+  /** `DELETE /users/api-keys` — revoke the current API key. */
+  async deleteApiKey() {
+    return this.callVoid(
+      "Failed to delete API key",
+      () => this.http.delete("/users/api-keys")
+    );
+  }
+  /** `PUT /authentication/change-password` — change the authenticated user's password. */
+  async changePassword(payload) {
+    if (!payload.email) throw new ValidationError("email is required");
+    if (!payload.password) throw new ValidationError("password is required");
+    if (!payload.new_password) throw new ValidationError("new_password is required");
+    return this.call(
+      "Failed to change password",
+      () => this.http.put("/authentication/change-password", payload)
+    );
+  }
+  /** `PUT /authentication/request-password-reset` — email a reset link to the user. */
+  async requestPasswordReset(email) {
+    if (!email) throw new ValidationError("email is required");
+    return this.call(
+      "Failed to request password reset",
+      () => this.http.put("/authentication/request-password-reset", { email })
+    );
+  }
+  /** `PUT /authentication/reset-password` — complete a password reset using the emailed token. */
+  async resetPassword(payload) {
+    if (!payload.email) throw new ValidationError("email is required");
+    if (!payload.new_password) throw new ValidationError("new_password is required");
+    return this.call(
+      "Failed to reset password",
+      () => this.http.put("/authentication/reset-password", payload)
+    );
+  }
+};
+
+// src/resources/fields.ts
+var FieldsResource = class extends BaseResource {
+  /** Create a field definition. */
+  async create(payload, accountId) {
+    if (!payload.type) throw new ValidationError("field type is required");
+    if (!payload.name) throw new ValidationError("field name is required");
+    const id = this.accountId(accountId);
+    return this.call(
+      "Failed to create field definition",
+      () => this.http.post(`/accounts/${id}/fields`, payload)
+    );
+  }
+  /**
+   * List field definitions for the workspace.
+   *
+   * @param params.include_inactive  return inactive fields too
+   * @param params.include_standard  also return `signature`, `initial`, `signatureDate`
+   */
+  async list(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.call(
+      "Failed to list field definitions",
+      () => this.http.get(`/accounts/${id}/fields`, {
+        params: cleanParams(params)
+      })
+    );
+  }
+  /** Get a single field definition by ID. */
+  async get(fieldId, accountId) {
+    const id = this.accountId(accountId);
+    const fid = this.requireId(fieldId, "Field ID");
+    return this.call(
+      "Failed to fetch field definition",
+      () => this.http.get(`/accounts/${id}/fields/${fid}`)
+    );
+  }
+  /** Update a field definition. */
+  async update(fieldId, payload, accountId) {
+    const id = this.accountId(accountId);
+    const fid = this.requireId(fieldId, "Field ID");
+    return this.call(
+      "Failed to update field definition",
+      () => this.http.put(`/accounts/${id}/fields/${fid}`, payload)
+    );
+  }
+  /** Delete a field definition. Fails if the field has been used. */
+  async delete(fieldId, accountId) {
+    const id = this.accountId(accountId);
+    const fid = this.requireId(fieldId, "Field ID");
+    return this.callVoid(
+      "Failed to delete field definition",
+      () => this.http.delete(`/accounts/${id}/fields/${fid}`)
+    );
+  }
+  /**
+   * Validate a single value against a field definition.
+   *
+   * Pass `signerAccessCode` for signer-side validation (the typical use case);
+   * omit it when the caller is authenticated via API key.
+   */
+  async validate(fieldId, value, options = {}) {
+    const id = this.accountId(options.accountId);
+    const fid = this.requireId(fieldId, "Field ID");
+    const params = options.signerAccessCode ? { "signer-access-code": options.signerAccessCode } : void 0;
+    return this.call(
+      "Failed to validate field value",
+      () => this.http.post(`/accounts/${id}/fields/${fid}/validate`, { value }, { params })
+    );
+  }
+  /** Validate multiple values at once. */
+  async validateMultiple(entries, options = {}) {
+    if (!Array.isArray(entries) || entries.length === 0) {
+      throw new ValidationError("entries must be a non-empty array");
+    }
+    const id = this.accountId(options.accountId);
+    const params = options.signerAccessCode ? { "signer-access-code": options.signerAccessCode } : void 0;
+    return this.call(
+      "Failed to validate field values",
+      () => this.http.post(`/accounts/${id}/fields/validate-multiple`, entries, { params })
+    );
+  }
+  /** List the platform's supported field types. */
+  async listTypes() {
+    return this.call("Failed to list field types", () => this.http.get("/field-types"));
+  }
+};
+
+// src/resources/signer-documents.ts
+var SignerDocumentsResource = class extends BaseResource {
+  /** `GET /signers/{signer_id}/document?signer-access-code=…` */
+  async getCurrent(signerId, signerAccessCode) {
+    const sid = this.requireId(signerId, "Signer ID");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.call(
+      "Failed to fetch current signer document",
+      () => this.http.get(`/signers/${sid}/document`, {
+        params: { "signer-access-code": code }
+      })
+    );
+  }
+  /** `GET /signers/{signer_id}/documents?signer-access-code=…` */
+  async list(signerId, signerAccessCode, params = {}) {
+    const sid = this.requireId(signerId, "Signer ID");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.callList(
+      "Failed to list signer documents",
+      () => this.http.get(`/signers/${sid}/documents`, {
+        params: { "signer-access-code": code, ...cleanParams(params) }
+      })
+    );
+  }
+  /** `GET /signers/{signer_id}/documents/{document_id}/download/{artifact}?signer-access-code=…` */
+  async download(signerId, documentId, artifactName, signerAccessCode) {
+    const sid = this.requireId(signerId, "Signer ID");
+    const did = this.requireId(documentId, "Document ID");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.callBinary(
+      "Failed to download signer document",
+      () => this.http.get(
+        `/signers/${sid}/documents/${did}/download/${artifactName}`,
+        { responseType: "arraybuffer", params: { "signer-access-code": code } }
+      )
+    );
+  }
+  /** `PUT /signers/documents/sign-multiple?signer-access-code=…` */
+  async signMultiple(documentIds, signerAccessCode) {
+    if (!Array.isArray(documentIds) || documentIds.length === 0) {
+      throw new ValidationError("documentIds must be a non-empty array");
+    }
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.call(
+      "Failed to sign multiple documents",
+      () => this.http.put(
+        "/signers/documents/sign-multiple",
+        { document_ids: documentIds },
+        { params: { "signer-access-code": code } }
+      )
+    );
+  }
+  /** `PUT /signers/documents/decline-multiple?signer-access-code=…` */
+  async declineMultiple(documentIds, declineReason, signerAccessCode) {
+    if (!Array.isArray(documentIds) || documentIds.length === 0) {
+      throw new ValidationError("documentIds must be a non-empty array");
+    }
+    if (!declineReason) throw new ValidationError("declineReason is required");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.call(
+      "Failed to decline multiple documents",
+      () => this.http.put(
+        "/signers/documents/decline-multiple",
+        { document_ids: documentIds, decline_reason: declineReason },
+        { params: { "signer-access-code": code } }
+      )
+    );
+  }
+  /** `GET /signers/self?signer-access-code=…` — fetch the signer's own profile. */
+  async self(signerAccessCode) {
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.call(
+      "Failed to fetch signer profile",
+      () => this.http.get("/signers/self", { params: { "signer-access-code": code } })
+    );
+  }
+  /** `PUT /signers/accept-terms` — accept the platform terms as the signer. */
+  async acceptTerms(signerAccessCode) {
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.call(
+      "Failed to accept terms",
+      () => this.http.put("/signers/accept-terms", { "signer-access-code": code })
+    );
+  }
+  /** `POST /verify` — verify the email OTP for a signer. */
+  async verifyEmail(payload) {
+    const code = this.requireId(payload.signerAccessCode, "signer-access-code");
+    const otp = this.requireId(payload.verificationCode, "verification-code");
+    return this.call(
+      "Failed to verify signer email",
+      () => this.http.post("/verify", {
+        "signer-access-code": code,
+        "verification-code": otp
+      })
+    );
+  }
+  /** `PUT /documents/{documentId}/signers/confirm-data?signer-access-code=…` */
+  async confirmData(documentId, signerAccessCode, payload) {
+    const did = this.requireId(documentId, "Document ID");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.call(
+      "Failed to confirm signer data",
+      () => this.http.put(`/documents/${did}/signers/confirm-data`, cleanParams(payload), {
+        params: { "signer-access-code": code }
+      })
+    );
+  }
+  /**
+   * `POST /signature?signer-access-code=…&type=…` — upload the signer's
+   * signature or initial image. `imageType` defaults to `signature`.
+   */
+  async uploadSignature(signerAccessCode, image, options = {}) {
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    if (!Buffer.isBuffer(image) || image.byteLength === 0) {
+      throw new ValidationError("image buffer is required");
+    }
+    return this.call(
+      "Failed to upload signer signature",
+      () => this.http.post("/signature", image, {
+        params: {
+          "signer-access-code": code,
+          type: options.imageType ?? "signature"
+        },
+        headers: { "Content-Type": options.contentType ?? "image/png" }
+      })
+    );
+  }
+  /** `GET /signature/{type}?signer-access-code=…` — download the signer's signature/initial. */
+  async downloadSignature(signerAccessCode, imageType = "signature") {
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.callBinary(
+      "Failed to download signer signature",
+      () => this.http.get(`/signature/${imageType}`, {
+        responseType: "arraybuffer",
+        params: { "signer-access-code": code }
+      })
+    );
+  }
+  /** `GET /sign?signer-access-code=…` — fetch the assignment as the signer sees it. */
+  async getAssignment(signerAccessCode, hasAcceptedTerms) {
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.call(
+      "Failed to fetch signer assignment",
+      () => this.http.get("/sign", {
+        params: cleanParams({
+          "signer-access-code": code,
+          has_accepted_terms: hasAcceptedTerms
+        })
+      })
+    );
+  }
+  /** `POST /documents/{documentId}/assignments/{assignmentId}?signer-access-code=…` — sign. */
+  async sign(documentId, assignmentId, signerAccessCode, entries) {
+    const did = this.requireId(documentId, "Document ID");
+    const aid = this.requireId(assignmentId, "Assignment ID");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    if (!Array.isArray(entries) || entries.length === 0) {
+      throw new ValidationError("entries must be a non-empty array");
+    }
+    return this.call(
+      "Failed to sign document",
+      () => this.http.post(`/documents/${did}/assignments/${aid}`, entries, {
+        params: { "signer-access-code": code }
+      })
+    );
+  }
+  /**
+   * `PUT /documents/{documentId}/assignments/{assignmentId}/reject?signer-access-code=…`
+   * — signer-side decline. (Distinct from `assignments.cancel`, which is the
+   * workspace-side cancellation flow.)
+   */
+  async decline(documentId, assignmentId, signerAccessCode, declineReason) {
+    const did = this.requireId(documentId, "Document ID");
+    const aid = this.requireId(assignmentId, "Assignment ID");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    if (!declineReason) throw new ValidationError("declineReason is required");
+    return this.call(
+      "Failed to decline assignment",
+      () => this.http.put(
+        `/documents/${did}/assignments/${aid}/reject`,
+        { decline_reason: declineReason },
+        { params: { "signer-access-code": code } }
+      )
+    );
+  }
+};
+
+// src/support/webhook-verifier.ts
+var import_node_crypto = require("crypto");
+var WebhookVerifier = class {
+  constructor(webhookSecret) {
+    this.webhookSecret = webhookSecret;
+  }
+  /** Returns `true` if `signature` is a valid HMAC-SHA256 of `payload`. */
+  verify(payload, signature) {
+    if (!this.webhookSecret || !signature) return false;
+    const buf = typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+    const expected = (0, import_node_crypto.createHmac)("sha256", this.webhookSecret).update(buf).digest("hex");
+    const provided = signature.trim();
+    const a = Buffer.from(expected, "utf8");
+    const b = Buffer.from(provided, "utf8");
+    if (a.length !== b.length) return false;
+    try {
+      return (0, import_node_crypto.timingSafeEqual)(a, b);
+    } catch {
+      return false;
+    }
+  }
+  /** Parse the raw webhook body into a JSON event envelope. */
+  extractEvent(payload) {
+    try {
+      const text = typeof payload === "string" ? payload : payload.toString("utf8");
+      const parsed = JSON.parse(text);
+      return parsed && typeof parsed === "object" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  /** Extract the event name (`event` or `type`) from an event envelope. */
+  getEventType(event) {
+    if (!event || typeof event !== "object") return null;
+    const e = event;
+    return e.event ?? e.type ?? null;
+  }
+  /** Extract the event data (`data` or `object`) from an event envelope. */
+  getEventData(event) {
+    if (!event || typeof event !== "object") return {};
+    const e = event;
+    return e.data ?? e.object ?? {};
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.assinafy.com.br/v1";
+var AssinafyClient = class _AssinafyClient {
+  constructor(options) {
+    if (!options.apiKey && !options.token) {
+      throw new ValidationError(
+        "An API key (options.apiKey) or legacy access token (options.token) is required."
+      );
+    }
+    this.defaultAccountId = options.accountId;
+    this.logger = options.logger ?? createNoopLogger();
+    this.webhookSecret = options.webhookSecret;
+    const baseURL = normaliseBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": "assinafy-typescript-sdk"
+    };
+    if (options.apiKey) {
+      headers["X-Api-Key"] = options.apiKey;
+    } else if (options.token) {
+      headers["Authorization"] = `Bearer ${options.token}`;
+    }
+    this.axiosInstance = import_axios2.default.create({
+      baseURL,
+      timeout: options.timeout ?? 3e4,
+      headers
+    });
+    this.documents = new DocumentResource(this.axiosInstance, this.defaultAccountId, this.logger);
+    this.signers = new SignerResource(this.axiosInstance, this.defaultAccountId, this.logger);
+    this.workspaces = new WorkspaceResource(this.axiosInstance, void 0, this.logger);
+    this.assignments = new AssignmentResource(
+      this.axiosInstance,
+      this.defaultAccountId,
+      this.logger
+    );
+    this.webhooks = new WebhookResource(this.axiosInstance, this.defaultAccountId, this.logger);
+    this.templates = new TemplateResource(this.axiosInstance, this.defaultAccountId, this.logger);
+    this.tags = new TagResource(this.axiosInstance, this.defaultAccountId, this.logger);
+    this.auth = new AuthenticationResource(this.axiosInstance, void 0, this.logger);
+    this.fields = new FieldsResource(this.axiosInstance, this.defaultAccountId, this.logger);
+    this.signerDocuments = new SignerDocumentsResource(
+      this.axiosInstance,
+      this.defaultAccountId,
+      this.logger
+    );
+    this.webhookVerifier = new WebhookVerifier(this.webhookSecret);
+  }
+  /** Convenience factory for the common apiKey + accountId setup. */
+  static create(apiKey, accountId, options = {}) {
+    return new _AssinafyClient({ apiKey, accountId, ...options });
+  }
+  /** Build a client from a plain object (supports snake_case and camelCase keys). */
+  static fromConfig(config) {
+    const opts = {};
+    const apiKey = config.api_key ?? config.apiKey;
+    const token = config.token ?? config.access_token ?? config.accessToken;
+    const accountId = config.account_id ?? config.accountId;
+    const baseUrl = config.base_url ?? config.baseUrl;
+    const webhookSecret = config.webhook_secret ?? config.webhookSecret;
+    if (apiKey !== void 0) opts.apiKey = apiKey;
+    if (token !== void 0) opts.token = token;
+    if (accountId !== void 0) opts.accountId = accountId;
+    if (baseUrl !== void 0) opts.baseUrl = baseUrl;
+    if (webhookSecret !== void 0) opts.webhookSecret = webhookSecret;
+    if (config.timeout !== void 0) opts.timeout = config.timeout;
+    if (config.logger !== void 0) opts.logger = config.logger;
+    return new _AssinafyClient(opts);
+  }
+  /**
+   * High-level helper that uploads a PDF, ensures it's processed, creates any
+   * missing signers, and kicks off a virtual signature assignment.
+   */
+  async uploadAndRequestSignatures(options) {
+    if (!options.signers || options.signers.length === 0) {
+      throw new ValidationError("At least one signer is required");
+    }
+    this.logger.info("Starting upload + signature workflow", {
+      signerCount: options.signers.length
+    });
+    const uploadOpts = {};
+    if (options.metadata !== void 0) uploadOpts.metadata = options.metadata;
+    if (options.accountId !== void 0) uploadOpts.accountId = options.accountId;
+    const document = await this.documents.upload(options.source, uploadOpts);
+    if (options.waitForReady !== false) {
+      await this.documents.waitUntilReady(document.id);
+    }
+    const signerIds = [];
+    for (const signer of options.signers) {
+      const payload = { full_name: signer.name };
+      if (signer.email !== void 0) {
+        payload.email = signer.email;
+      }
+      const phone = signer.whatsapp_phone_number ?? signer.phone;
+      if (phone !== void 0) {
+        payload.whatsapp_phone_number = phone;
+      }
+      if (signer.cpf !== void 0) {
+        payload.cpf = signer.cpf;
+      }
+      if (signer.metadata !== void 0) {
+        payload.metadata = signer.metadata;
+      }
+      const created = await this.signers.create(payload, options.accountId);
+      signerIds.push(created.id);
+    }
+    const assignmentPayload = {
+      method: "virtual",
+      signers: signerIds
+    };
+    if (options.message !== void 0) assignmentPayload.message = options.message;
+    if (options.expiresAt !== void 0) assignmentPayload.expires_at = options.expiresAt;
+    if (options.copyReceivers !== void 0) assignmentPayload.copy_receivers = options.copyReceivers;
+    const assignment = await this.assignments.create(document.id, assignmentPayload);
+    this.logger.info("Upload + signature workflow completed", { documentId: document.id });
+    return { document, assignment, signer_ids: signerIds };
+  }
+  /** Expose the underlying axios instance for advanced use cases (interceptors, custom endpoints). */
+  getAxiosInstance() {
+    return this.axiosInstance;
+  }
+};
+function normaliseBaseUrl(raw) {
+  return raw.endsWith("/") ? raw.slice(0, -1) : raw;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AssignmentResource,
+  AssinafyClient,
+  AssinafyError,
+  AuthenticationResource,
+  DocumentResource,
+  FieldsResource,
+  NetworkError,
+  SignerDocumentsResource,
+  SignerResource,
+  TagResource,
+  TemplateResource,
+  ValidationError,
+  WebhookResource,
+  WebhookVerifier,
+  WorkspaceResource,
+  buildAssignmentPayload
+});