@assinafy/sdk 1.5.0 → 2.0.0

package/dist/index.mjs

@@ -3,16 +3,16 @@ import axios2 from "axios";
 
 // src/errors.ts
 var AssinafyError = class extends Error {
+  context;
   constructor(message, context = {}, options) {
-    super(message);
+    super(message, options);
     this.name = "AssinafyError";
     this.context = context;
-    if (options?.cause !== void 0) {
-      this.cause = options.cause;
-    }
   }
 };
 var ApiError = class _ApiError extends AssinafyError {
+  statusCode;
+  responseData;
   constructor(message, statusCode, responseData = null, options) {
     super(message, { statusCode, responseData }, options);
     this.name = "ApiError";
@@ -28,6 +28,7 @@ var ApiError = class _ApiError extends AssinafyError {
   }
 };
 var ValidationError = class extends AssinafyError {
+  errors;
   constructor(message = "Validation failed", errors = {}) {
     super(message, { errors });
     this.name = "ValidationError";
@@ -53,6 +54,23 @@ function handleAssinafyResponse(response) {
   }
   return response;
 }
+function decodeBinaryErrorBody(data) {
+  let text;
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+    text = data.toString("utf8");
+  } else if (data instanceof ArrayBuffer) {
+    text = Buffer.from(data).toString("utf8");
+  } else if (ArrayBuffer.isView(data)) {
+    text = Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  } else {
+    return data;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text.length > 0 ? { message: text } : null;
+  }
+}
 function toSdkError(error, fallbackMessage) {
   if (error instanceof AssinafyError) {
     return error;
@@ -60,14 +78,15 @@ function toSdkError(error, fallbackMessage) {
   if (axios.isAxiosError(error)) {
     const status = error.response?.status;
     if (status) {
-      return ApiError.fromResponse(status, error.response?.data ?? null);
+      const body = decodeBinaryErrorBody(error.response?.data ?? null);
+      return ApiError.fromResponse(status, body ?? 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 });
+  return new AssinafyError(fallbackMessage, {}, { cause: error });
 }
 function createNoopLogger() {
   return {
@@ -86,6 +105,14 @@ function cleanParams(params) {
   }
   return out;
 }
+function cleanListParams(params) {
+  const out = cleanParams(params);
+  if (out["per_page"] !== void 0) {
+    out["per-page"] ??= out["per_page"];
+    delete out["per_page"];
+  }
+  return out;
+}
 
 // src/support/retry.ts
 function header(headers, name) {
@@ -122,7 +149,57 @@ function nextRetryDelayMs(headers, attempt, maxDelayMs = 3e4) {
   return Math.min(backoffMs(attempt), maxDelayMs);
 }
 
+// src/resources/upload.ts
+import { promises as fs } from "fs";
+import path from "path";
+var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+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 fs.readFile(source.filePath);
+  return { buffer, fileName: source.fileName ?? path.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 toUploadFileName(name) {
+  return name.toLowerCase().endsWith(".pdf") ? name : `${name}.pdf`;
+}
+function buildUploadForm(buffer, fileName, options = {}) {
+  const form = new FormData();
+  const view = new Uint8Array(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  );
+  const partName = options.name === void 0 ? fileName : toUploadFileName(options.name);
+  form.append("file", new Blob([view], { type: "application/pdf" }), partName);
+  if (options.metadata) {
+    form.append("metadata", JSON.stringify(options.metadata));
+  }
+  return form;
+}
+
 // src/resources/base.ts
+var MULTIPART_CONTENT_TYPE = "multipart/form-data";
 var BaseResource = class {
   constructor(http, defaultAccountId, logger = createNoopLogger()) {
     this.http = http;
@@ -184,6 +261,35 @@ var BaseResource = class {
       throw toSdkError(err, label);
     }
   }
+  /**
+   * Upload a PDF as `multipart/form-data` and assert the API echoed an id.
+   *
+   * Shared by `documents.upload` and `templates.create`, which are the same
+   * sequence over different paths: load → validate → build form → POST →
+   * assert an id came back. Callers keep their own success logging.
+   *
+   * @param path - Account-scoped endpoint to POST to.
+   * @param source - The PDF, as a file path or in-memory buffer.
+   * @param formOptions - `name` (display name) and optional `metadata`.
+   * @param labels - `errorLabel` for the request failure, `missingId` for a
+   * `2xx` that returned no id.
+   */
+  async uploadPdf(path2, source, formOptions, labels) {
+    const { buffer, fileName } = await loadSource(source);
+    validateUpload(buffer, fileName);
+    this.logger.info("Uploading PDF", { path: path2, fileName, size: buffer.byteLength });
+    const form = buildUploadForm(buffer, fileName, formOptions);
+    const result = await this.call(
+      labels.errorLabel,
+      () => this.http.post(path2, form, { headers: { "Content-Type": MULTIPART_CONTENT_TYPE } })
+    );
+    if (!result?.id) {
+      throw new ValidationError(labels.missingId, {
+        response: result
+      });
+    }
+    return result;
+  }
   /** Execute a paginated list call and attach meta from `X-Pagination-*` headers. */
   async callList(label, request) {
     try {
@@ -225,48 +331,6 @@ function toInt(value) {
   return Number.isFinite(n) ? n : void 0;
 }
 
-// src/resources/upload.ts
-import { promises as fs } from "fs";
-import path from "path";
-var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
-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 fs.readFile(source.filePath);
-  return { buffer, fileName: source.fileName ?? path.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, options = {}) {
-  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", options.name ?? fileName);
-  if (options.metadata) {
-    form.append("metadata", JSON.stringify(options.metadata));
-  }
-  return form;
-}
-
 // src/resources/documents.ts
 var READY_STATUSES = /* @__PURE__ */ new Set([
   "metadata_ready",
@@ -281,45 +345,153 @@ var FAILED_STATUSES = /* @__PURE__ */ new Set([
 ]);
 var DocumentResource = class extends BaseResource {
   /**
-   * Upload a PDF to the workspace.
+   * Upload a PDF to the workspace (`POST /accounts/{accountId}/documents`).
+   *
+   * The document is created in `metadata_processing` status and becomes
+   * usable once it reaches `metadata_ready`; use
+   * {@link DocumentResource.waitUntilReady} to await that transition. Note
+   * that {@link DocumentResource.rename} and {@link DocumentResource.delete}
+   * return `400` while the document is still processing.
+   *
+   * @param source - The PDF to upload, as a file path or an in-memory buffer.
+   * @param options - Display name, metadata, and account override.
+   * @returns The created document. Response shape:
+   * ```jsonc
+   * {
+   *   "resource": "document",
+   *   "id": "c3d4e5f6a7b8c9d0e1f2a3b4c5d6",
+   *   "name": "Service agreement.pdf",
+   *   "status": "metadata_processing",
+   *   "created_at": "2026-07-15T16:15:33Z",
+   *   "updated_at": "2026-07-15T16:15:33Z"
+   * }
+   * ```
+   * @throws {ValidationError} If the file is empty, not a `.pdf`, exceeds
+   * 25 MB, or the API returns no document ID.
+   * @throws {ApiError} If the API rejects the upload.
    *
    * @example
    * ```ts
    * await client.documents.upload({ filePath: './contract.pdf' });
-   * await client.documents.upload({ buffer, fileName: 'contract.pdf' }, { metadata });
+   * await client.documents.upload(
+   *   { buffer, fileName: 'contract.pdf' },
+   *   { name: 'Service agreement', metadata: { orderId: 'A-1' } },
+   * );
+   * // → name is stored as 'Service agreement.pdf'
    * ```
    */
   async upload(source, options = {}) {
-    const { buffer, fileName } = await loadSource(source);
-    validateUpload(buffer, fileName);
     const accountId = this.accountId(options.accountId);
     const formOptions = {};
+    if (options.name !== void 0) formOptions.name = options.name;
     if (options.metadata !== void 0) formOptions.metadata = options.metadata;
-    const form = buildUploadForm(buffer, fileName, formOptions);
-    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" }
-      })
+    const document = await this.uploadPdf(
+      `/accounts/${accountId}/documents`,
+      source,
+      formOptions,
+      {
+        errorLabel: "Document upload failed",
+        missingId: "Upload succeeded but no document ID was returned"
+      }
     );
-    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`.
+   * 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) })
+      () => this.http.get(`/accounts/${id}/documents`, { params: cleanListParams(params) })
+    );
+  }
+  /**
+   * Search workspace documents
+   * (`GET /accounts/{accountId}/documents/search`).
+   *
+   * A lighter-weight alternative to {@link DocumentResource.list}: it returns
+   * a compact representation with no expanded `assignment` or `pages`, so
+   * prefer it for name lookups and pickers.
+   *
+   * @param params - `search`, `status`, `page`, `per-page`.
+   * @param accountId - Override the client's default account ID.
+   * @returns Matching documents, with pagination in `meta`. Each item:
+   * ```jsonc
+   * {
+   *   "id": "c3d4e5f6a7b8c9d0e1f2a3b4c5d6",
+   *   "account_id": "d4e5f6a7b8c9d0e1f2a3b4c5d6e7",
+   *   "template_id": null,
+   *   "name": "Service agreement.pdf",
+   *   "status": "pending_signature",
+   *   "artifacts": { "original": "https://…" },
+   *   "is_closed": false,
+   *   "signing_url": "https://…",
+   *   "decline_reason": null,
+   *   "declined_by": null,
+   *   "tags": [],
+   *   "created_at": "2026-07-15T16:15:33Z",
+   *   "updated_at": "2026-07-15T16:15:40Z"
+   * }
+   * ```
+   * @throws {ValidationError} If no account ID is available.
+   * @throws {ApiError} If the API rejects the request.
+   *
+   * @example
+   * ```ts
+   * const { data, meta } = await client.documents.search({
+   *   search: 'agreement',
+   *   status: 'pending_signature',
+   *   'per-page': 20,
+   * });
+   * ```
+   */
+  async search(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.callList(
+      "Failed to search documents",
+      () => this.http.get(`/accounts/${id}/documents/search`, { params: cleanListParams(params) })
+    );
+  }
+  /**
+   * Rename a document (`PATCH /documents/{documentId}`).
+   *
+   * Only valid while the document is still renameable: the API returns `400`
+   * ("Document cannot be renamed after the signature process has started")
+   * both once signing has begun **and** while the document is still in
+   * `metadata_processing` immediately after upload. Await
+   * {@link DocumentResource.waitUntilReady} before renaming a fresh upload.
+   *
+   * To set a name at upload time instead, pass `name` to
+   * {@link DocumentResource.upload} — that avoids the extra round-trip and
+   * the processing race entirely.
+   *
+   * @param documentId - The document to rename.
+   * @param name - The new display name (max 255 chars), e.g.
+   * `'Service agreement.pdf'`.
+   * @returns The updated document — **without** `pages` or `assignment`,
+   * which this endpoint does not return (unlike
+   * {@link DocumentResource.details}). Call `details()` if you need them.
+   * @throws {ValidationError} If `documentId` or `name` is missing.
+   * @throws {ApiError} `400` if the document is processing or already in
+   * signing; `404` if it does not exist.
+   *
+   * @example
+   * ```ts
+   * const doc = await client.documents.upload({ filePath: './c.pdf' });
+   * await client.documents.waitUntilReady(doc.id);   // else 400
+   * await client.documents.rename(doc.id, 'Service agreement.pdf');
+   * ```
+   */
+  async rename(documentId, name) {
+    const id = this.requireId(documentId, "Document ID");
+    const newName = this.requireId(name, "Name");
+    this.logger.info("Renaming document", { documentId: id });
+    return this.call(
+      "Failed to rename document",
+      () => this.http.patch(`/documents/${id}`, { name: newName })
     );
   }
   /** Get document details. */
@@ -353,6 +525,9 @@ var DocumentResource = class extends BaseResource {
         }
       } catch (err) {
         if (err instanceof ValidationError) throw err;
+        if (err instanceof ApiError && err.statusCode < 500 && err.statusCode !== 429) {
+          throw err;
+        }
         this.logger.warn("Error checking document status", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -583,7 +758,8 @@ var SignerResource = class extends BaseResource {
         () => this.http.post(`/accounts/${id}/signers`, normaliseSignerPayload(payload))
       );
     } catch (err) {
-      if (err instanceof ApiError && err.statusCode === 409 && payload.email) {
+      const isDuplicateStatus = err instanceof ApiError && (err.statusCode === 409 || err.statusCode === 400);
+      if (isDuplicateStatus && payload.email) {
         const duplicate = await this.findByEmail(payload.email, id);
         if (duplicate) {
           this.logger.info("Signer already exists, using existing signer", {
@@ -604,12 +780,12 @@ var SignerResource = class extends BaseResource {
       () => this.http.get(`/accounts/${id}/signers/${sid}`)
     );
   }
-  /** List signers for the workspace (supports `page`, `per_page`, `search`, `sort`). */
+  /** 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) })
+      () => this.http.get(`/accounts/${id}/signers`, { params: cleanListParams(params) })
     );
   }
   /** Update a signer. Fails if the signer has active assignments. */
@@ -630,11 +806,28 @@ var SignerResource = class extends BaseResource {
       () => this.http.delete(`/accounts/${id}/signers/${sid}`)
     );
   }
-  /** Find a signer by email via the API's `search` parameter. Returns `null` if none match. */
+  /**
+   * Find a signer by exact email, using the API's `search` filter to narrow
+   * the page first. Returns `null` if none match.
+   *
+   * `search` is a substring match across signer fields, so the result is
+   * re-filtered here for an exact, case-insensitive email match.
+   *
+   * Page size is pinned to the API's maximum of 50: larger values are
+   * silently clamped to 50 by the server, so asking for more is misleading.
+   * An exact address realistically matches one signer, but a search term that
+   * matched more than 50 could in principle miss one — the API exposes no
+   * exact-email filter to rule that out.
+   *
+   * @param email - Exact email address to look for.
+   * @param accountId - Override the client's default account ID.
+   * @returns The matching {@link ISigner}, or `null`.
+   * @throws {ValidationError} If `email` is not a valid address.
+   */
   async findByEmail(email, accountId) {
     this.assertEmail(email);
     try {
-      const { data } = await this.list({ search: email, per_page: 100 }, accountId);
+      const { data } = await this.list({ search: email, "per-page": 50 }, accountId);
       const lower = email.toLowerCase();
       return data.find((s) => (s.email ?? "").toLowerCase() === lower) ?? null;
     } catch (err) {
@@ -746,6 +939,58 @@ function normaliseSignerRef(ref, options) {
   throw new ValidationError("Invalid signer reference", { ref });
 }
 var AssignmentResource = class extends BaseResource {
+  /**
+   * List assignments across the workspace (`GET /assignments`).
+   *
+   * The account is passed as an `accountId` **query parameter** — the API
+   * responds `400` ("Um contexto de conta é necessário e não foi fornecido")
+   * without it. Note the camelCase spelling: `account_id` and an
+   * `X-Account-Id` header are both rejected.
+   *
+   * @param params - `page`, `per-page`.
+   * @param accountId - Override the client's default account ID.
+   * @returns Assignments, with pagination in `meta`. Each item:
+   * ```jsonc
+   * {
+   *   "id": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4",
+   *   "sender_email": "sender@example.com",
+   *   "method": "virtual",
+   *   "expires_at": null,
+   *   "message": "Please sign this contract",
+   *   "signers": [
+   *     {
+   *       "id": "b2c3d4e5f6a7b8c9d0e1f2a3b4c5",
+   *       "full_name": "Ana Souza",
+   *       "email": "signer@example.com",
+   *       "whatsapp_phone_number": null,
+   *       "has_accepted_terms": false,
+   *       "completed": false,
+   *       "notification_history": [],
+   *       "verification_method": "Email",
+   *       "notification_methods": ["Email"],
+   *       "step": 1,
+   *       "notified": true
+   *     }
+   *   ]
+   * }
+   * ```
+   * @throws {ValidationError} If no account ID is available.
+   * @throws {ApiError} If the API rejects the request.
+   *
+   * @example
+   * ```ts
+   * const { data, meta } = await client.assignments.list({ 'per-page': 20 });
+   * ```
+   */
+  async list(params = {}, accountId) {
+    const id = this.accountId(accountId);
+    return this.callList(
+      "Failed to list assignments",
+      () => this.http.get("/assignments", {
+        params: { accountId: id, ...cleanListParams(params) }
+      })
+    );
+  }
   /** Create a signing assignment for a document. */
   async create(documentId, payload) {
     const docId = this.requireId(documentId, "Document ID");
@@ -881,16 +1126,14 @@ var WebhookResource = class extends BaseResource {
       () => 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. */
+  /**
+   * Inactivate the current webhook subscription.
+   *
+   * This is the only supported way to stop deliveries — the API has no
+   * subscription-delete route. The subscription is retained (with its `url`
+   * and `events`) and simply stops firing; re-enable it by calling
+   * {@link WebhookResource.register} again with `is_active: true`.
+   */
   async inactivate(accountId) {
     const id = this.accountId(accountId);
     this.logger.info("Inactivating webhook subscription");
@@ -912,7 +1155,7 @@ var WebhookResource = class extends BaseResource {
     return this.callList(
       "Failed to list webhook dispatches",
       () => this.http.get(`/accounts/${id}/webhooks`, {
-        params: cleanParams(params)
+        params: cleanListParams(params)
       })
     );
   }
@@ -948,24 +1191,18 @@ var TemplateResource = class extends BaseResource {
    * ```
    */
   async create(source, options = {}) {
-    const { buffer, fileName } = await loadSource(source);
-    validateUpload(buffer, fileName);
     const id = this.accountId(options.accountId);
     const formOptions = {};
     if (options.name !== void 0) formOptions.name = options.name;
-    const form = buildUploadForm(buffer, fileName, formOptions);
-    this.logger.info("Creating template", { fileName, size: buffer.byteLength });
-    const template = await this.call(
-      "Failed to create template",
-      () => this.http.post(`/accounts/${id}/templates`, form, {
-        headers: { "Content-Type": "multipart/form-data" }
-      })
+    const template = await this.uploadPdf(
+      `/accounts/${id}/templates`,
+      source,
+      formOptions,
+      {
+        errorLabel: "Failed to create template",
+        missingId: "Template upload succeeded but no template ID was returned"
+      }
     );
-    if (!template?.id) {
-      throw new ValidationError("Template upload succeeded but no template ID was returned", {
-        response: template
-      });
-    }
     this.logger.info("Template created", { templateId: template.id });
     return template;
   }
@@ -974,14 +1211,17 @@ var TemplateResource = class extends BaseResource {
     const id = this.accountId(accountId);
     return this.callList(
       "Failed to list templates",
-      () => this.http.get(`/accounts/${id}/templates`, { params: cleanParams(params) })
+      () => this.http.get(`/accounts/${id}/templates`, { params: cleanListParams(params) })
     );
   }
   /**
    * Get a template by ID (`GET /accounts/{id}/templates/{template_id}`).
    *
-   * Unlike the list endpoint, the single-template response includes `pages`
-   * (with per-page `download_url`) and `default_document_tags`.
+   * Returns the same shape as {@link TemplateResource.list} plus
+   * `default_document_tags` (the tags auto-applied to every document created
+   * from this template) and `resource`. Both endpoints return `pages` with
+   * per-page `download_url`, so fetching a template again purely to read its
+   * pages is unnecessary.
    */
   async get(templateId, accountId) {
     const id = this.accountId(accountId);
@@ -1049,7 +1289,7 @@ var TagResource = class extends BaseResource {
     return this.call(
       "Failed to list tags",
       () => this.http.get(`/accounts/${id}/tags`, {
-        params: cleanParams(params)
+        params: cleanListParams(params)
       })
     );
   }
@@ -1191,7 +1431,7 @@ var FieldsResource = class extends BaseResource {
     return this.call(
       "Failed to list field definitions",
       () => this.http.get(`/accounts/${id}/fields`, {
-        params: cleanParams(params)
+        params: cleanListParams(params)
       })
     );
   }
@@ -1275,7 +1515,44 @@ var SignerDocumentsResource = class extends BaseResource {
     return this.callList(
       "Failed to list signer documents",
       () => this.http.get(`/signers/${sid}/documents`, {
-        params: { "signer-access-code": code, ...cleanParams(params) }
+        params: { "signer-access-code": code, ...cleanListParams(params) }
+      })
+    );
+  }
+  /**
+   * Search the documents awaiting a given signer
+   * (`GET /signers/{signer_id}/documents/search?signer-access-code=…`).
+   *
+   * The signer-side counterpart of {@link DocumentResource.search}, scoped to
+   * one signer and authorised by their access code rather than the API key.
+   * Like {@link SignerDocumentsResource.list}, it requires
+   * `signer-access-code`; the published spec omits that parameter, but the
+   * endpoint is not usable without it.
+   *
+   * @param signerId - The signer whose documents are searched.
+   * @param signerAccessCode - The signer's access code, from their signing link.
+   * @param search - Free-text term matched against the document name.
+   * @returns Matching documents for that signer, in the compact
+   * {@link IDocumentListItem} shape, with pagination in `meta`.
+   * @throws {ValidationError} If `signerId` or `signerAccessCode` is missing.
+   * @throws {ApiError} If the access code is invalid or expired.
+   *
+   * @example
+   * ```ts
+   * const { data } = await client.signerDocuments.search(
+   *   signerId,
+   *   accessCode,
+   *   'agreement',
+   * );
+   * ```
+   */
+  async search(signerId, signerAccessCode, search) {
+    const sid = this.requireId(signerId, "Signer ID");
+    const code = this.requireId(signerAccessCode, "signer-access-code");
+    return this.callList(
+      "Failed to search signer documents",
+      () => this.http.get(`/signers/${sid}/documents/search`, {
+        params: cleanParams({ "signer-access-code": code, search })
       })
     );
   }
@@ -1495,6 +1772,21 @@ var WebhookVerifier = class {
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.assinafy.com.br/v1";
 var AssinafyClient = class _AssinafyClient {
+  axiosInstance;
+  defaultAccountId;
+  logger;
+  webhookSecret;
+  documents;
+  signers;
+  workspaces;
+  assignments;
+  webhooks;
+  templates;
+  tags;
+  auth;
+  fields;
+  signerDocuments;
+  webhookVerifier;
   constructor(options) {
     if (!options.apiKey && !options.token) {
       throw new ValidationError(
@@ -1652,6 +1944,7 @@ export {
   DEFAULT_WEBHOOK_EVENTS,
   DocumentResource,
   FieldsResource,
+  MAX_UPLOAD_BYTES,
   NetworkError,
   SignerDocumentsResource,
   SignerResource,