@assinafy/sdk 2.0.0 → 2.1.1

package/dist/index.d.ts

@@ -36,20 +36,26 @@ interface AssinafyClientOptions {
     /** Assinafy API key. Preferred authentication method (sends `X-Api-Key` header). */
     apiKey?: string;
     /**
-     * Legacy access token. If provided (and `apiKey` is not), the client will send
-     * `Authorization: Bearer <token>` instead. Kept for backwards compatibility.
+     * Access token. If provided (and `apiKey` is not), the client will send
+     * `Authorization: Bearer <token>` instead.
      */
     token?: string;
     /** Default account (workspace) ID applied to account-scoped endpoints. */
     accountId?: string;
     /** Override the API base URL. Defaults to https://api.assinafy.com.br/v1. */
     baseUrl?: string;
-    /** Secret used to verify webhook payload signatures (HMAC-SHA256). */
+    /**
+     * Secret for an opt-in HMAC-SHA256 convention implemented by your own
+     * gateway. The public Assinafy contract does not currently define a
+     * platform webhook-signature header or shared-secret exchange.
+     */
     webhookSecret?: string;
     /** Request timeout in milliseconds. Defaults to 30_000. */
     timeout?: number;
     /**
      * Max automatic retries on HTTP 429 (rate limit), honoring `Retry-After`.
+     * Automatic retries are limited to idempotent GET, HEAD, OPTIONS, PUT, and
+     * DELETE requests, plus requests carrying an explicit `Idempotency-Key`.
      * Defaults to `2`. Set to `0` to disable retrying.
      */
     maxRetries?: number;
@@ -59,17 +65,18 @@ interface AssinafyClientOptions {
 /**
  * Payload for creating a signer.
  *
- * `email` is optional: the API accepts a signer with only a
- * `whatsapp_phone_number`. At least one of the two must be supplied.
+ * The official schema requires only `full_name`. Contact fields are optional;
+ * name-only signers cannot receive a signing notification until updated.
  */
 interface ICreateSignerPayload {
     full_name: string;
     email?: string;
     whatsapp_phone_number?: string;
-    /** PHP SDK compatibility alias for `whatsapp_phone_number`. */
+    /** Compatibility alias normalized to `whatsapp_phone_number` before sending. */
     phone?: string;
-    /** Brazilian tax ID (CPF). Non-digits are stripped before sending. */
+    /** Unverified request extension. Brazilian CPF; non-digits are stripped. */
     cpf?: string;
+    /** Unverified request extension retained for existing integrations. */
     metadata?: Record<string, unknown>;
 }
 /** Payload for updating a signer. */
@@ -77,9 +84,9 @@ interface IUpdateSignerPayload {
     full_name?: string;
     email?: string;
     whatsapp_phone_number?: string;
-    /** PHP SDK compatibility alias for `whatsapp_phone_number`. */
+    /** Compatibility alias normalized to `whatsapp_phone_number` before sending. */
     phone?: string;
-    /** Brazilian tax ID (CPF). Non-digits are stripped before sending. */
+    /** Unverified request extension. Brazilian CPF; non-digits are stripped. */
     cpf?: string;
 }
 /** Signer object as returned by the API. */
@@ -99,8 +106,56 @@ interface ISigner {
     has_signature?: boolean;
     /** Only returned by `GET /signers/self`. */
     has_initial?: boolean;
+    /** Only returned by `GET /signers/self`. */
+    is_signature_reusable?: boolean;
     metadata?: Record<string, unknown>;
 }
+/** Signer profile returned by the signer-code-authenticated `GET /signers/self`. */
+interface ISignerSelf extends ISigner {
+    has_signature: boolean;
+    has_initial: boolean;
+    is_signature_reusable: boolean;
+}
+/** Official identity fields accepted by the signer `confirm-data` operation. */
+interface IConfirmSignerDataPayload {
+    /** Signer's full name as it should appear on the signed document. */
+    full_name?: string;
+    email?: string;
+    /** Government-issued identifier recorded with the signature. */
+    government_id?: string;
+}
+/**
+ * Compatibility input retained for integrations written against older
+ * Assinafy deployments. Neither extra property belongs to the current
+ * `confirm-data` request schema.
+ */
+interface ILegacyConfirmSignerDataPayload extends IConfirmSignerDataPayload {
+    /**
+     * @deprecated Unverified legacy field. Prefer updating the account signer
+     * record before starting the signing flow.
+     */
+    whatsapp_phone_number?: string;
+    /**
+     * @deprecated Unverified legacy pass-through. It does not replace the
+     * official `acceptTerms()` operation and must not be treated as proof of
+     * legal consent.
+     */
+    has_accepted_terms?: boolean;
+}
+/** Official options for uploading the PNG signature image described by OpenAPI. */
+interface IUploadSignatureOptions {
+    imageType?: 'signature' | 'initial';
+    /** Persist this image so it is reused on future documents. */
+    reuse?: boolean;
+}
+/** Source-compatible options for older deployments that accepted other media types. */
+interface ILegacyUploadSignatureOptions extends IUploadSignatureOptions {
+    /**
+     * @deprecated The current API contract accepts only `image/png`. Non-PNG
+     * values are retained as an unverified compatibility escape hatch.
+     */
+    contentType?: string;
+}
 type ICreateSignerResponse = ISigner;
 /** Pagination metadata extracted from `X-Pagination-*` response headers. */
 interface PaginationMeta {
@@ -137,8 +192,7 @@ interface ICreateAssignmentPayload {
     method?: AssignmentMethod;
     /**
      * List of signers. Each entry may be a signer id string, or an object with
-     * `id` / `signer_id`. For cost estimation, entries may omit the ID and
-     * specify only `verification_method` / `notification_methods`.
+     * `id` / `signer_id`.
      *
      * The SDK normalises them to the docs-sanctioned `signers: [{ ... }]`
      * shape before sending.
@@ -166,17 +220,60 @@ interface ICreateAssignmentPayload {
      */
     copy_receivers?: string[];
     /** Field placement entries used when `method` is `collect`. */
-    entries?: unknown[];
+    entries?: IAssignmentEntry[];
+}
+/**
+ * A field-placement entry for a `collect`-method assignment: one page and the
+ * per-signer fields positioned on it.
+ */
+interface IAssignmentEntry {
+    page_id: string;
+    fields: Array<{
+        signer_id: string;
+        field_id: string;
+        /**
+         * Opaque, server-defined placement settings (position, size, …). Left
+         * loosely typed: the spec models it as a bare object and the live API
+         * returns an unstable shape (an empty array on assignment items).
+         */
+        display_settings?: Record<string, unknown>;
+    }>;
+}
+/** Channel descriptor accepted by assignment cost estimation. */
+interface IAssignmentCostSigner {
+    verification_method?: AssignmentVerificationMethod;
+    notification_methods?: AssignmentNotificationMethod[];
+}
+/**
+ * Official request body for
+ * `POST /documents/{documentId}/assignments/estimate-cost`.
+ */
+interface IEstimateAssignmentCostPayload {
+    method?: AssignmentMethod;
+    /** Required for `virtual`; `{}` prices the default Email channel. */
+    signers?: IAssignmentCostSigner[];
+    /** Required for `collect`; signer descriptors are optional in that mode. */
+    entries?: IAssignmentEntry[];
 }
 /** A signer as embedded inside an assignment (richer than the bare {@link ISigner}). */
 interface IAssignmentSigner extends ISigner {
-    completed: boolean;
-    notification_history: unknown[];
-    verification_method: AssignmentVerificationMethod;
-    notification_methods: AssignmentNotificationMethod[];
+    /** Only present in account-owner contexts; omitted from signer-code responses. */
+    completed?: boolean | null;
+    notification_history: INotificationHistoryEntry[] | null;
+    verification_method: AssignmentVerificationMethod | null;
+    notification_methods: AssignmentNotificationMethod[] | null;
     /** 1-based signing order. See {@link SignerReference.step}. */
-    step: number;
-    notified: boolean;
+    step: number | null;
+    notified: boolean | null;
+}
+/** Per-channel notification delivery history embedded in an assignment signer. */
+interface INotificationHistoryEntry {
+    event: string;
+    status: 'sent' | 'failed';
+    error_code: string | null;
+    error_message: string | null;
+    sent_at: string | null;
+    failed_at: string | null;
 }
 /** A placed field/item within an assignment (one row per signer × field). */
 interface IAssignmentItem {
@@ -189,8 +286,9 @@ interface IAssignmentItem {
         download_url: string;
     } | null;
     signer: ISigner;
-    field: IFieldDefinition;
-    value: string | null;
+    field: IFieldDefinition | null;
+    /** Captured field value; its wire type depends on the field definition. */
+    value: unknown | null;
     completed?: boolean;
     [key: string]: unknown;
 }
@@ -202,9 +300,10 @@ interface IAssignment {
     method: AssignmentMethod;
     expires_at?: string | null;
     expiration?: string;
-    message?: string;
+    message?: string | null;
     signers: IAssignmentSigner[];
-    copy_receivers?: string[];
+    /** Expanded copy-receiver objects returned by the API. */
+    copy_receivers?: Array<Record<string, unknown>>;
     items?: IAssignmentItem[];
     summary?: {
         signer_count: number;
@@ -221,9 +320,9 @@ interface IAssignment {
 }
 type ICreateAssignmentResponse = IAssignment;
 interface IResendEmailResponse {
-    is_sent?: boolean;
-    document_id?: string;
-    signer_id?: string;
+    is_sent: boolean;
+    document_id: string;
+    signer_id: string;
 }
 /**
  * Credit/document cost estimate returned by `assignments.estimateCost` and
@@ -249,8 +348,15 @@ interface ICostEstimate {
     blocking_reason: string | null;
     message: string | null;
 }
-/** Cost estimate returned by `assignments.estimateResendCost`. */
-interface IResendCostEstimate {
+/**
+ * Legacy resend-cost payload still returned by some Assinafy environments.
+ *
+ * The current OpenAPI contract declares {@link ICostEstimate} for this route,
+ * while the sandbox has also returned this smaller, resend-specific shape.
+ * The SDK models both wire formats instead of promising fields that may be
+ * absent at runtime.
+ */
+interface ILegacyResendCostEstimate {
     total: number;
     breakdown: Array<{
         code: string;
@@ -260,17 +366,23 @@ interface IResendCostEstimate {
     credit_balance: number;
     has_sufficient_credits: boolean;
 }
+/** Cost estimate returned by `assignments.estimateResendCost`. */
+type IResendCostEstimate = ICostEstimate | ILegacyResendCostEstimate;
 /** Webhook payload envelope. */
 interface IWebhookPayload {
+    /** Internal activity id; use it as an idempotency/deduplication key. */
     id?: number;
-    event?: string;
+    event?: WebhookEventType | AnyString;
     type?: string;
     message?: string | null;
     payload?: Record<string, unknown> | null;
     origin?: Record<string, unknown> | null;
+    /** Unix timestamp in seconds. */
+    created_at?: number;
     subject?: Record<string, unknown>;
     object?: Record<string, unknown>;
     account_id?: string;
+    /** Legacy envelope accepted by the verifier for backwards compatibility. */
     data?: {
         document_uuid?: string;
         document_id?: string;
@@ -360,6 +472,8 @@ interface IDocumentUploadResponse {
         bundle?: string;
         thumbnail?: string;
     };
+    /** Public signing-portal URL for the document (always returned by the upload endpoint). */
+    signing_url?: string;
     /** Empty (`[]`) on fresh upload (status `uploaded`); populated once `metadata_ready`. */
     pages: Array<{
         id: string;
@@ -374,7 +488,8 @@ interface IDocumentUploadResponse {
     updated_at: string;
     is_closed: boolean;
     decline_reason: string | null;
-    declined_by: string | null;
+    /** The signer who declined, once one has (matches the sibling document response types); `null` otherwise. */
+    declined_by: ISigner | null;
 }
 /** Detailed document response. */
 interface IDocumentDetailsResponse {
@@ -410,8 +525,8 @@ interface IDocumentActivity {
     id: number;
     event: string;
     message: string;
-    /** Event-specific payload snapshot. Object for most events, occasionally `[]`. */
-    payload?: Record<string, unknown> | unknown[];
+    /** Event-specific payload snapshot. Object for most events, occasionally `[]` or `null`. */
+    payload?: Record<string, unknown> | unknown[] | null;
     /** Request origin (`ip` / `user-agent`) when available; `null` for system events. */
     origin: {
         ip?: string;
@@ -435,37 +550,93 @@ interface IListParams {
     sort?: string;
     [key: string]: string | number | boolean | undefined;
 }
-/** Workspace creation payload. */
+/**
+ * Workspace creation payload.
+ *
+ * Colours are persisted and echoed back on the workspace object. Unlike tags —
+ * which accept a leading `#` and strip it — the account endpoints require an
+ * **exactly 6-character hex string with NO leading `#`** (`'ff0066'`, not
+ * `'#ff0066'`); a 7-character `#`-prefixed value is rejected with `400`
+ * ("Primary Color" deve conter 6 caracteres). Verified live against the API.
+ */
 interface ICreateWorkspacePayload {
     name: string;
+    /** Who signers see as the notification sender (`User` is the API default). */
+    notification_sender_type?: NotificationSenderType;
+    /** 6-char hex, no leading `#` (e.g. `'ff0066'`). */
     primary_color?: string;
+    /** 6-char hex, no leading `#` (e.g. `'0066ff'`). */
     secondary_color?: string;
 }
+/** Workspace update payload. Colours follow the same 6-char-no-`#` rule as {@link ICreateWorkspacePayload}. */
 interface IUpdateWorkspacePayload {
     name?: string;
+    /** Who signers see as the notification sender. */
+    notification_sender_type?: NotificationSenderType;
+    /** 6-char hex, no leading `#`. */
     primary_color?: string | null;
+    /** 6-char hex, no leading `#`. */
     secondary_color?: string | null;
 }
 interface IWorkspaceResponse {
+    resource?: string;
     id: string;
     name: string;
     primary_color?: string | null;
     secondary_color?: string | null;
+    notification_sender_type?: NotificationSenderType;
+    roles?: string[];
+    is_delete_allowed?: boolean;
     created_at: string;
 }
-interface IWorkspaceListItem {
-    id: string;
-    name: string;
+/** Notification sender identity accepted by account create/update operations. */
+type NotificationSenderType = 'User' | 'Account';
+interface IWorkspaceListItem extends IWorkspaceResponse {
     is_delete_allowed: boolean;
     roles: string[];
-    created_at: string;
 }
 type IWorkspaceListResponse = PaginatedResult<IWorkspaceListItem>;
+/** Branding returned by `GET /accounts/{accountId}/theme`. */
+interface IAccountTheme {
+    account_name: string;
+    /** Six-character hex colour without a leading `#`. */
+    primary_color: string;
+    secondary_color: string | null;
+    /** Absolute URL of the account logo. */
+    logo: string;
+}
+/** Granularity accepted by account/user document-statistics endpoints. */
+type DocumentStatsGranularity = 'monthly' | 'daily';
+/** Query for account/user document-statistics endpoints. */
+interface IDocumentStatsParams {
+    /** Defaults to `monthly`. */
+    granularity?: DocumentStatsGranularity;
+    /** Target `YYYY-MM`; required when `granularity` is `daily`. */
+    month?: string;
+}
+/** One zero-filled document-funnel KPI period. */
+interface IDocumentStatsRow {
+    /** `YYYY-MM` for monthly results or `YYYY-MM-DD` for daily results. */
+    period: string;
+    documents_uploaded: number;
+    documents_sent: number;
+    signature_requests: number;
+    signature_requests_email: number;
+    signature_requests_whatsapp: number;
+    signature_requests_viewed: number;
+    signature_requests_completed: number;
+    documents_certified: number;
+}
 /** Webhook subscription payload. */
 interface IWebhookRegisterPayload {
     url: string;
     email: string;
-    events?: WebhookEventType[] | string[];
+    /**
+     * Events to subscribe to. Known {@link WebhookEventType} literals are
+     * suggested in editors while any server-controlled string is still accepted
+     * (via {@link AnyString}), matching the open-enum convention used elsewhere.
+     */
+    events?: (WebhookEventType | AnyString)[];
     is_active?: boolean;
 }
 /**
@@ -474,17 +645,18 @@ interface IWebhookRegisterPayload {
  * `{ events, is_active, url, email, updated_at }` (no `id` / `created_at`).
  */
 interface IWebhookSubscription {
-    url: string;
-    email: string;
+    url: string | null;
+    email: string | null;
     events: string[];
     is_active: boolean;
-    updated_at?: string;
+    updated_at?: string | null;
 }
 interface IWebhookEventTypeInfo {
     id: WebhookEventType | AnyString;
     description: string;
 }
 interface IWebhookDispatch {
+    resource?: string;
     id: string;
     event: WebhookEventType | AnyString;
     activity_id: number;
@@ -507,7 +679,14 @@ interface IWebhookDispatchListParams extends IListParams {
 }
 /** Shape of the high-level `uploadAndRequestSignatures` helper result. */
 interface IUploadAndRequestSignaturesResult {
-    document: IDocumentUploadResponse;
+    /**
+     * The document. When `waitForReady` is enabled (the default) this is the
+     * fully-processed {@link IDocumentDetailsResponse} re-fetched after the
+     * assignment is created — so `status`, `pages` and the embedded `assignment`
+     * are current. When `waitForReady` is `false` it is the raw
+     * {@link IDocumentUploadResponse} upload snapshot (`status: 'uploaded'`).
+     */
+    document: IDocumentUploadResponse | IDocumentDetailsResponse;
     assignment: IAssignment;
     signer_ids: string[];
 }
@@ -547,10 +726,9 @@ interface ITemplateListItem {
     status: string;
     /**
      * Rendered pages, each with a `download_url`. Empty until the template
-     * finishes processing (`status: 'Ready'`).
-     *
-     * The list endpoint does return `pages` — contrary to what
-     * `templates.get`'s documentation implies.
+     * finishes processing (`status: 'Ready'`). Both the list and get endpoints
+     * return `pages`, so there is no need to fetch a template again just to read
+     * them.
      */
     pages?: IPage[];
     roles?: ITemplateRole[];
@@ -591,7 +769,18 @@ interface IPage {
     /** Absolute URL of the page's JPEG rendering. */
     download_url?: string;
     /** Fields positioned on this page. Present on templates; absent on documents. */
-    fields?: unknown[];
+    fields?: ITemplateFieldPlacement[];
+}
+/** A field placement returned on a rendered template page. */
+interface ITemplateFieldPlacement {
+    id?: string;
+    field_id?: string;
+    role_id?: string;
+    label?: string;
+    /** Opaque rendering metadata; the current schema intentionally leaves it untyped. */
+    display_settings?: unknown;
+    created_at?: string;
+    updated_at?: string;
 }
 interface ITemplateDetailsResponse {
     resource?: string;
@@ -620,12 +809,24 @@ interface ITemplateSigner {
     /** Positive integer controlling signing order (see {@link SignerReference}). */
     step?: number;
 }
+/**
+ * Role/channel descriptor used only for template cost estimation. The official
+ * schema intentionally omits signer `id` and sequential-signing `step`.
+ */
+interface ITemplateCostSigner {
+    role_id: string;
+    verification_method?: string;
+    notification_methods?: string[];
+}
 /** Options for creating a document from a template. */
 interface ICreateDocumentFromTemplateOptions {
     name?: string;
     message?: string;
     expires_at?: string;
-    editor_fields?: unknown[];
+    editor_fields?: Array<{
+        field_id: string;
+        value: string;
+    }>;
     /**
      * Tag names to attach to the new document. Names that don't exist yet are
      * auto-created; the template's default-document-tags are always merged in.
@@ -644,30 +845,49 @@ interface IDocumentStatusInfo {
     description?: string;
 }
 /** Item returned by `GET /public/documents/{id}`. */
-interface IPublicDocumentInfo {
+interface IPublicDocumentInfo extends Partial<Omit<IDocumentDetailsResponse, 'id' | 'name'>> {
     resource?: string;
     id: string;
     name: string;
+    /** Observed legacy/public response field; not present in the current schema. */
     page_count?: string | number;
+    /** Observed legacy/public response field; not present in the current schema. */
     created_by?: string;
     [key: string]: unknown;
 }
+/** Result returned by public document signature-hash verification. */
+interface IDocumentVerification {
+    hash: string;
+    id: string | null;
+    status: DocumentStatus | AnyString | null;
+    page_count: string | null;
+    signer_count: string | null;
+    completed_count: number | null;
+    completed_at: string | null;
+    verified_at: string;
+    is_valid: boolean;
+    message: string;
+}
 /** Channel accepted by the `send-token` endpoint. */
 type SendTokenChannel = 'email' | 'whatsapp' | AnyString;
 /** Authentication: login response (also returned by social login). */
+/** Authenticated user profile returned by login and `users.getCurrent()`. */
+interface IAuthenticatedUser {
+    id: string;
+    name: string;
+    email: string;
+    telephone: string | null;
+    government_id: string | null;
+    is_email_verified: boolean;
+    has_accepted_terms: boolean;
+    /** Live compatibility field; absent from the current OpenAPI `AuthUser` schema. */
+    is_password_set?: boolean;
+    created_at: string;
+    to_be_deleted_at: string | null;
+}
 interface ILoginResponse {
     access_token: string;
-    user: {
-        id: string;
-        name: string;
-        email: string;
-        telephone?: string;
-        government_id?: string;
-        is_email_verified?: boolean;
-        has_accepted_terms?: boolean;
-        created_at?: string;
-        to_be_deleted_at?: string | null;
-    };
+    user: IAuthenticatedUser;
     accounts: Array<{
         id: string;
         name: string;
@@ -678,11 +898,11 @@ interface ILoginResponse {
 }
 /** Authentication: API key payload returned by `POST /users/api-keys`. */
 interface IApiKeyResponse {
-    api_key: string;
+    api_key: string | null;
 }
-/** Authentication: masked API key returned by `GET /users/api-keys` (or null when never generated). */
+/** Authentication: masked API key returned by `GET /users/api-keys`. */
 type IMaskedApiKeyResponse = {
-    api_key: string;
+    api_key: string | null;
 } | null;
 /** Field definition object. */
 interface IFieldDefinition {
@@ -702,15 +922,18 @@ interface IFieldDefinition {
 interface ICreateFieldPayload {
     type: string;
     name: string;
-    regex?: string;
+    regex?: string | null;
     is_required?: boolean;
+    /** Live compatibility extension; absent from the current create schema. */
     is_active?: boolean;
 }
 /** Payload for updating a field definition. */
 interface IUpdateFieldPayload {
+    /** Live compatibility extension; absent from the current update schema. */
     type?: string;
     name?: string;
     regex?: string | null;
+    /** Live compatibility extension; absent from the current update schema. */
     is_required?: boolean;
     is_active?: boolean;
 }
@@ -783,14 +1006,16 @@ interface IUpdateTagPayload {
 
 /** Maximum upload size accepted by the API (hard limit, 25 MB). */
 declare const MAX_UPLOAD_BYTES: number;
-/** Input for an upload: either an on-disk file or an in-memory buffer. */
-type DocumentUploadSource = {
+/** Input for a file upload: either an on-disk file or an in-memory buffer. */
+type FileUploadSource = {
     filePath: string;
     fileName?: string;
 } | {
     buffer: Buffer;
     fileName: string;
 };
+/** Input accepted by PDF document/template uploads. */
+type DocumentUploadSource = FileUploadSource;
 
 /**
  * Shared plumbing for every Assinafy resource:
@@ -813,6 +1038,8 @@ declare abstract class BaseResource {
     protected accountId(explicit?: string): string;
     /** Guard required path arguments (documentId, signerId, …). */
     protected requireId<T extends string>(value: T | undefined | null, name: string): T;
+    /** Validate and encode a value that will occupy one URL path segment. */
+    protected pathSegment(value: string | undefined | null, name: string): string;
     /** Execute an HTTP call and return the unwrapped envelope body. */
     protected call<T>(label: string, request: RequestFn): Promise<T>;
     /** Like {@link call} but returns `null` when the API responds with 404. */
@@ -864,26 +1091,39 @@ interface IDocumentUploadOptions {
     accountId?: string;
 }
 declare class DocumentResource extends BaseResource {
+    private readonly publicHttp;
+    constructor(http: AxiosInstance, defaultAccountId?: string, logger?: Logger, publicHttp?: AxiosInstance);
     /**
      * 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
+     * The document is created in `uploaded` status and progresses through the
+     * lifecycle `uploading` → `uploaded` → `metadata_processing` →
+     * `metadata_ready`, becoming 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:
+     * @returns The created document, freshly uploaded (`status: 'uploaded'`,
+     * empty `pages` until `metadata_ready`). Response shape:
      * ```jsonc
      * {
      *   "resource": "document",
-     *   "id": "c3d4e5f6a7b8c9d0e1f2a3b4c5d6",
+     *   "id": "103ad216846e6b90710cb9acef59",
+     *   "account_id": "acc_example",
+     *   "template_id": null,
      *   "name": "Service agreement.pdf",
-     *   "status": "metadata_processing",
-     *   "created_at": "2026-07-15T16:15:33Z",
-     *   "updated_at": "2026-07-15T16:15:33Z"
+     *   "status": "uploaded",               // NOT metadata_processing yet
+     *   "artifacts": { "original": "https://…/documents/103ad216…/download/original" },
+     *   "is_closed": false,
+     *   "signing_url": "https://app-sandbox.assinafy.com.br/sign/103ad216…",
+     *   "decline_reason": null,
+     *   "declined_by": null,
+     *   "tags": [],
+     *   "pages": [],                          // populated once metadata_ready
+     *   "created_at": "2026-07-19T17:24:43Z",
+     *   "updated_at": "2026-07-19T17:24:44Z"
      * }
      * ```
      * @throws {ValidationError} If the file is empty, not a `.pdf`, exceeds
@@ -902,8 +1142,60 @@ declare class DocumentResource extends BaseResource {
      */
     upload(source: DocumentUploadSource, options?: IDocumentUploadOptions): Promise<IDocumentUploadResponse>;
     /**
-     * List workspace documents. Pagination info (if any) is attached in `meta`.
-     * Supports `status`, `method`, `tags`, `search`, `sort`, `page`, `per-page`.
+     * List workspace documents
+     * (`GET /accounts/{accountId}/documents`).
+     *
+     * The full listing: unlike {@link DocumentResource.search}, each item also
+     * carries the expanded `assignment` (or `null`) and the rendered `pages`,
+     * so prefer it when you need signing state or page geometry. Pagination
+     * info (if any) is attached in `meta`.
+     *
+     * @param params - Filters and pagination: `status`, `method`, `tags`
+     * (comma-separated tag IDs), `search`, `sort`, `page`, `per-page`.
+     * @param accountId - Override the client's default account ID.
+     * @returns Matching documents, with pagination in `meta`. Each item:
+     * ```jsonc
+     * {
+     *   "id": "103acccd24234c07858ffddf6d84",
+     *   "account_id": "acc_example",
+     *   "template_id": null,
+     *   "name": "sdk-smoke-rename-7b006e52.pdf",
+     *   "status": "metadata_ready",
+     *   "artifacts": {
+     *     "original": "https://…/documents/103acccd…/download/original",
+     *     "thumbnail": "https://…/documents/103acccd…/thumbnail"
+     *   },
+     *   "is_closed": false,
+     *   "signing_url": "https://app-sandbox.assinafy.com.br/sign/103acccd…",
+     *   "decline_reason": null,
+     *   "declined_by": null,
+     *   "tags": [],
+     *   "assignment": null,                  // an IAssignment once signatures are requested
+     *   "pages": [
+     *     {
+     *       "id": "103acccd5c73af8009c3644af591",
+     *       "number": 1,
+     *       "height": 1651,
+     *       "width": 1275,
+     *       "download_url": "https://…/documents/103acccd…/pages/103acccd…/download"
+     *     }
+     *   ],
+     *   "created_at": "2026-07-19T14:56:54Z",
+     *   "updated_at": "2026-07-19T14:56:56Z"
+     * }
+     * ```
+     * @throws {ValidationError} If no account ID is available.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const { data, meta } = await client.documents.list({
+     *   status: 'pending_signature',
+     *   method: 'virtual',
+     *   'per-page': 50,
+     * });
+     * console.log(data[0]?.pages.length, meta?.total);
+     * ```
      */
     list(params?: IDocumentListParams, accountId?: string): Promise<IDocumentListResponse>;
     /**
@@ -978,551 +1270,3385 @@ declare class DocumentResource extends BaseResource {
      * ```
      */
     rename(documentId: string, name: string): Promise<IRenameDocumentResponse>;
-    /** Get document details. */
+    /**
+     * Get document details (`GET /documents/{documentId}`).
+     *
+     * The full single-document view, including the embedded `assignment` (or
+     * `null`), rendered `pages`, and `artifacts`.
+     *
+     * @param documentId - The document to fetch.
+     * @returns The document. Response shape (once `metadata_ready`):
+     * ```jsonc
+     * {
+     *   "resource": "document",
+     *   "id": "103ad216846e6b90710cb9acef59",
+     *   "account_id": "acc_example",
+     *   "template_id": null,
+     *   "name": "audit-test.pdf",
+     *   "status": "metadata_ready",
+     *   "artifacts": {
+     *     "original": "https://…/documents/103ad216…/download/original",
+     *     "thumbnail": "https://…/documents/103ad216…/thumbnail"
+     *   },
+     *   "is_closed": false,
+     *   "signing_url": "https://app-sandbox.assinafy.com.br/sign/103ad216…",
+     *   "decline_reason": null,
+     *   "declined_by": null,
+     *   "tags": [],
+     *   "assignment": null,
+     *   "pages": [
+     *     {
+     *       "id": "103ad216be62159d3087452d7cf8",
+     *       "number": 1,
+     *       "height": 1651,
+     *       "width": 1275,
+     *       "download_url": "https://…/documents/103ad216…/pages/103ad216…/download"
+     *     }
+     *   ],
+     *   "created_at": "2026-07-19T17:24:43Z",
+     *   "updated_at": "2026-07-19T17:24:46Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `404` if the document does not exist.
+     *
+     * @example
+     * ```ts
+     * const doc = await client.documents.details('103ad216846e6b90710cb9acef59');
+     * console.log(doc.status, doc.pages.length);
+     * ```
+     */
     details(documentId: string): Promise<IDocumentDetailsResponse>;
-    /** Alias for {@link details}. */
+    /**
+     * Alias for {@link DocumentResource.details}
+     * (`GET /documents/{documentId}`).
+     *
+     * @param documentId - The document to fetch.
+     * @returns The document details (see {@link DocumentResource.details} for
+     * the response shape).
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `404` if the document does not exist.
+     *
+     * @example
+     * ```ts
+     * const doc = await client.documents.get('103ad216846e6b90710cb9acef59');
+     * ```
+     */
     get(documentId: string): Promise<IDocumentDetailsResponse>;
-    /** Poll document status until ready (or a terminal status / timeout). */
+    /**
+     * Poll {@link DocumentResource.details} until the document reaches a ready
+     * status (`metadata_ready`, `pending_signature`, or `certificated`),
+     * throwing on a terminal failure status or timeout.
+     *
+     * Transient errors are tolerated — a `5xx` or `429` is retried on the next
+     * poll — but a non-retryable `4xx` (bad key, wrong account, deleted
+     * document) is surfaced immediately rather than masked as a timeout.
+     *
+     * @param documentId - The document to wait on.
+     * @param options - `maxWaitMs` (default `30_000`) and `pollIntervalMs`
+     * (default `2_000`).
+     * @returns The document details once it reaches a ready status (see
+     * {@link DocumentResource.details} for the shape).
+     * @throws {ValidationError} If `documentId` is missing, the document enters
+     * a terminal failure status (`failed`, `rejected_by_signer`,
+     * `rejected_by_user`, `expired` — message
+     * `Document processing failed with status: <status>`), or the wait times
+     * out (`Timeout waiting for document to be ready`).
+     * @throws {ApiError} On a non-retryable `4xx` other than `429`.
+     *
+     * @example
+     * ```ts
+     * const doc = await client.documents.upload({ filePath: './c.pdf' });
+     * const ready = await client.documents.waitUntilReady(doc.id, {
+     *   maxWaitMs: 60_000,
+     *   pollIntervalMs: 3_000,
+     * });
+     * console.log(ready.status); // 'metadata_ready'
+     * ```
+     */
     waitUntilReady(documentId: string, options?: {
         maxWaitMs?: number;
         pollIntervalMs?: number;
     }): Promise<IDocumentDetailsResponse>;
-    /** Download a document artifact. Defaults to the certificated (signed) PDF. */
-    download(documentId: string, artifactName?: DocumentArtifactName): Promise<Buffer>;
-    /** Download the document thumbnail. */
-    thumbnail(documentId: string): Promise<Buffer>;
-    /** Download a single page as a JPEG. */
-    downloadPage(documentId: string, pageId: string): Promise<Buffer>;
-    /** Fetch the document activity log. */
-    activities(documentId: string): Promise<IDocumentActivity[]>;
-    /** Delete a document. */
-    delete(documentId: string): Promise<void>;
-    /** List the tags attached to a document. */
-    listTags(documentId: string, accountId?: string): Promise<ITag[]>;
     /**
-     * Replace the document's tag set with `tags` (an array of tag names).
-     * Unknown names are auto-created; an empty array detaches all tags.
+     * Download a document artifact as raw bytes
+     * (`GET /documents/{documentId}/download/{artifactName}`).
+     *
+     * @param documentId - The document to download from.
+     * @param artifactName - Which artifact to fetch: `original`,
+     * `certificated` (the default — the signed PDF), `certificate-page`, or
+     * `bundle`.
+     * @returns A {@link Buffer} of the artifact's bytes (PDF).
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `404` if the document or artifact does not exist (e.g.
+     * requesting `certificated` before signing completes).
+     *
+     * @example
+     * ```ts
+     * const pdf = await client.documents.download('doc-1'); // signed PDF
+     * const original = await client.documents.download('doc-1', 'original');
+     * await fs.promises.writeFile('signed.pdf', pdf);
+     * ```
      */
-    replaceTags(documentId: string, tags: string[], accountId?: string): Promise<ITag[]>;
-    /** Attach additional tags (by name) without removing existing ones. Idempotent. */
-    addTags(documentId: string, tags: string[], accountId?: string): Promise<ITag[]>;
-    /** Detach a single tag from a document (the tag itself is not deleted). */
-    detachTag(documentId: string, tagId: string, accountId?: string): Promise<void>;
+    download(documentId: string, artifactName?: DocumentArtifactName): Promise<Buffer>;
     /**
-     * Create a document from a template.
+     * Download the document thumbnail image
+     * (`GET /documents/{documentId}/thumbnail`).
+     *
+     * @param documentId - The document whose thumbnail to fetch.
+     * @returns A {@link Buffer} of the thumbnail image bytes.
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `404` if the document or its thumbnail does not exist.
      *
      * @example
      * ```ts
-     * await client.documents.createFromTemplate('tmpl_id', [
-     *   { role_id: 'role_id', id: 'signer_id', verification_method: 'Email', notification_methods: ['Email'] },
-     * ], { name: 'My Contract' });
+     * const thumb = await client.documents.thumbnail('doc-1');
+     * await fs.promises.writeFile('thumb.jpg', thumb);
      * ```
      */
-    createFromTemplate(templateId: string, signers: ITemplateSigner[], options?: ICreateDocumentFromTemplateOptions, accountId?: string): Promise<IDocumentDetailsResponse>;
+    thumbnail(documentId: string): Promise<Buffer>;
     /**
-     * Estimate the credit cost of creating a document from a template.
+     * Download a single rendered page as a JPEG
+     * (`GET /documents/{documentId}/pages/{pageId}/download`).
+     *
+     * The `pageId` comes from a page's `id` in {@link DocumentResource.details}
+     * or {@link DocumentResource.list} (`pages[].id`).
+     *
+     * @param documentId - The document the page belongs to.
+     * @param pageId - The page to download.
+     * @returns A {@link Buffer} of the page's JPEG bytes.
+     * @throws {ValidationError} If `documentId` or `pageId` is missing.
+     * @throws {ApiError} `404` if the document or page does not exist.
      *
-     * @returns an {@link ICostEstimate}: `total_credits`, balances, and a
-     * per-line `breakdown` of what the operation would consume.
+     * @example
+     * ```ts
+     * const doc = await client.documents.details('doc-1');
+     * const page = await client.documents.downloadPage('doc-1', doc.pages[0].id);
+     * await fs.promises.writeFile('page-1.jpg', page);
+     * ```
      */
-    estimateCostFromTemplate(templateId: string, signers: ITemplateSigner[], accountId?: string): Promise<ICostEstimate>;
-    /** Verify a document by its signature hash. */
-    verify(hash: string): Promise<Record<string, unknown>>;
+    downloadPage(documentId: string, pageId: string): Promise<Buffer>;
     /**
-     * `GET /documents/statuses` — list every possible document status with
-     * its description and whether documents in that status can be deleted.
+     * Fetch the document activity log
+     * (`GET /documents/{documentId}/activities`).
+     *
+     * Returns a chronological audit trail of lifecycle events. Normalises an
+     * absent body to `[]`.
+     *
+     * @param documentId - The document whose activity log to fetch.
+     * @returns The activity entries (newest first), or `[]`:
+     * ```jsonc
+     * [
+     *   {
+     *     "id": 15272,
+     *     "event": "document_metadata_ready",
+     *     "message": "Documento processado.",
+     *     "payload": [],
+     *     "origin": null,                    // system event
+     *     "created_at": "2026-07-19T14:56:56Z"
+     *   },
+     *   {
+     *     "id": 15271,
+     *     "event": "document_uploaded",
+     *     "message": "Documento criado.",
+     *     "payload": [],
+     *     "origin": { "ip": "99.75.13.162", "user-agent": "assinafy-webforms-java-client-sdk" },
+     *     "created_at": "2026-07-19T14:56:55Z"
+     *   }
+     * ]
+     * ```
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const events = await client.documents.activities('doc-1');
+     * console.log(events.map((e) => e.event));
+     * ```
      */
-    statuses(): Promise<IDocumentStatusInfo[]>;
+    activities(documentId: string): Promise<IDocumentActivity[]>;
     /**
-     * `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).
+     * Delete a document (`DELETE /documents/{documentId}`).
+     *
+     * Only documents in a deletable status can be removed — the API returns
+     * `400` while the document is still `uploading` / `metadata_processing`
+     * (await {@link DocumentResource.waitUntilReady} first) or once it has been
+     * certificated.
+     *
+     * @param documentId - The document to delete.
+     * @returns Nothing on success.
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `400` if the document is not in a deletable status;
+     * `404` if it does not exist.
+     *
+     * @example
+     * ```ts
+     * await client.documents.delete('doc-1');
+     * ```
      */
-    getPublic(documentId: string): Promise<IPublicDocumentInfo>;
+    delete(documentId: string): Promise<void>;
     /**
-     * `PUT /public/documents/{document_id}/send-token` — send the 6-digit
-     * verification token to the signer's email / WhatsApp.
+     * List the tags attached to a document
+     * (`GET /accounts/{accountId}/documents/{documentId}/tags`).
+     *
+     * @param documentId - The document whose tags to list.
+     * @param accountId - Override the client's default account ID.
+     * @returns The attached tags:
+     * ```jsonc
+     * [
+     *   {
+     *     "resource": "tag",
+     *     "id": "103aa252123d3bf1843a317ee0e6",
+     *     "name": "urgent",
+     *     "color": "ff8800",
+     *     "created_at": "2026-07-18T19:09:03Z",
+     *     "updated_at": "2026-07-18T19:09:03Z"
+     *   }
+     * ]
+     * ```
+     * @throws {ValidationError} If `documentId` is missing or no account ID is
+     * available.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const tags = await client.documents.listTags('doc-1');
+     * ```
      */
-    sendToken(documentId: string, recipient: string, channel?: SendTokenChannel): Promise<unknown>;
-    /** Quick check: has every signer completed their assignment? */
-    isFullySigned(documentId: string): Promise<boolean>;
-    /** Summarise signing progress for UI display. */
-    getSigningProgress(documentId: string): Promise<ISigningProgress>;
-}
-
-declare class SignerResource extends BaseResource {
+    listTags(documentId: string, accountId?: string): Promise<ITag[]>;
     /**
-     * Create a signer in the workspace.
+     * Replace the document's tag set
+     * (`PUT /accounts/{accountId}/documents/{documentId}/tags`).
+     *
+     * The official contract defines `tags` as an array of tag **IDs**. An empty
+     * array detaches all tags. Some environments have also accepted names and
+     * auto-created missing tags, but that is an undocumented extension and
+     * should not be relied on. This overwrites the existing set — use
+     * {@link DocumentResource.addTags} to append.
+     *
+     * @param documentId - The document to retag.
+     * @param tags - The complete desired set of tag IDs (`[]` clears all).
+     * @param accountId - Override the client's default account ID.
+     * @returns The document's tags after the replace:
+     * ```jsonc
+     * [
+     *   { "resource": "tag", "id": "103aa252…", "name": "signed", "color": null,
+     *     "created_at": "2026-07-18T19:09:03Z", "updated_at": "2026-07-18T19:09:03Z" }
+     * ]
+     * ```
+     * @throws {ValidationError} If `tags` is not an array, `documentId` is
+     * missing, or no account ID is available.
+     * @throws {ApiError} If the API rejects the request.
      *
-     * `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.
+     * @example
+     * ```ts
+     * await client.documents.replaceTags('doc-1', ['tag-signed', 'tag-archived']);
+     * await client.documents.replaceTags('doc-1', []); // detach all
+     * ```
      */
-    create(payload: ICreateSignerPayload, accountId?: string): Promise<ICreateSignerResponse>;
-    /** Get a signer by ID. */
-    get(signerId: string, accountId?: string): Promise<ISigner>;
-    /** List signers for the workspace (supports `page`, `per-page`, `search`, `sort`). */
-    list(params?: IListParams, accountId?: string): Promise<ISignerListResponse>;
-    /** Update a signer. Fails if the signer has active assignments. */
-    update(signerId: string, payload: IUpdateSignerPayload, accountId?: string): Promise<ICreateSignerResponse>;
-    /** Delete a signer. */
-    delete(signerId: string, accountId?: string): Promise<void>;
+    replaceTags(documentId: string, tags: string[], accountId?: string): Promise<ITag[]>;
     /**
-     * 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.
+     * Attach additional tags without removing existing ones
+     * (`POST /accounts/{accountId}/documents/{documentId}/tags`).
      *
-     * 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.
+     * `tags` is a non-empty array of tag **IDs**. Attaching an ID already
+     * present is a no-op. To replace the whole set instead, use
+     * {@link DocumentResource.replaceTags}.
      *
-     * @param email - Exact email address to look for.
+     * @param documentId - The document to tag.
+     * @param tags - Tag IDs to attach (must be non-empty).
      * @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.
+     * @returns The document's tags after the attach:
+     * ```jsonc
+     * [
+     *   { "resource": "tag", "id": "103aa252…", "name": "urgent", "color": null,
+     *     "created_at": "2026-07-18T19:09:03Z", "updated_at": "2026-07-18T19:09:03Z" }
+     * ]
+     * ```
+     * @throws {ValidationError} If `tags` is empty or not an array,
+     * `documentId` is missing, or no account ID is available.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * await client.documents.addTags('doc-1', ['tag-urgent']);
+     * ```
      */
-    findByEmail(email: string, accountId?: string): Promise<ISigner | null>;
-    private assertEmail;
-}
-
-declare class WorkspaceResource extends BaseResource {
-    /** Create a new workspace. */
-    create(payload: ICreateWorkspacePayload): Promise<IWorkspaceResponse>;
-    /** List workspaces the authenticated user can access. */
-    list(): Promise<IWorkspaceListResponse>;
-    /** Fetch a single workspace. */
-    get(accountId: string): Promise<IWorkspaceResponse>;
-    /** Update a workspace. */
-    update(accountId: string, payload: IUpdateWorkspacePayload): Promise<IWorkspaceResponse>;
-    /** Delete a workspace. */
-    delete(accountId: string): Promise<void>;
-}
-
-/**
- * Normalise an assignment payload into the shape the API expects:
- * `signers: [{ id }]` plus optional docs-level fields.
- */
-declare function buildAssignmentPayload(payload: ICreateAssignmentPayload, options?: {
-    allowSignersWithoutId?: boolean;
-}): Record<string, unknown>;
-declare class AssignmentResource extends BaseResource {
+    addTags(documentId: string, tags: string[], accountId?: string): Promise<ITag[]>;
     /**
-     * List assignments across the workspace (`GET /assignments`).
+     * Detach a single tag from a document
+     * (`DELETE /accounts/{accountId}/documents/{documentId}/tags/{tagId}`).
      *
-     * 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.
+     * Removes the association only — the workspace tag itself is not deleted.
+     * Like {@link DocumentResource.addTags} /
+     * {@link DocumentResource.replaceTags}, this takes the tag's **ID**.
      *
-     * @param params - `page`, `per-page`.
+     * @param documentId - The document to detach from.
+     * @param tagId - The ID of the tag to detach.
+     * @param accountId - Override the client's default account ID.
+     * @returns Nothing on success.
+     * @throws {ValidationError} If `documentId` or `tagId` is missing, or no
+     * account ID is available.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * await client.documents.detachTag('doc-1', 'tag-1');
+     * ```
+     */
+    detachTag(documentId: string, tagId: string, accountId?: string): Promise<void>;
+    /**
+     * Create a document from a template
+     * (`POST /accounts/{accountId}/templates/{templateId}/documents`).
+     *
+     * Instantiates the template, binding each role to a signer, and returns the
+     * new document. The request body is `{ signers, ...options }` — `signers`
+     * maps template `role_id` → signer `id`, and `options` may add `name`,
+     * `message`, `expires_at`, `editor_fields`, and `tags`.
+     *
+     * @param templateId - The template to instantiate.
+     * @param signers - Role-to-signer bindings (each with `role_id` and `id`,
+     * plus optional `verification_method`, `notification_methods`, `step`).
+     * @param options - Optional `name`, `message`, `expires_at`,
+     * `editor_fields`, `tags`.
      * @param accountId - Override the client's default account ID.
-     * @returns Assignments, with pagination in `meta`. Each item:
+     * @returns The created document (an {@link IDocumentDetailsResponse} with
+     * `template_id` set and its `assignment` populated):
      * ```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
-     *     }
-     *   ]
+     *   "resource": "document",
+     *   "id": "19f675b761b392a48b8642503bb",
+     *   "account_id": "acc_example",
+     *   "template_id": "103a0991a5cde83518e5672aa9aa",
+     *   "name": "Audit From Template",
+     *   "status": "pending_signature",
+     *   "artifacts": { "original": "https://…/download/original", "thumbnail": "https://…/thumbnail" },
+     *   "is_closed": false,
+     *   "signing_url": "https://app-sandbox.assinafy.com.br/sign/19f675b7…",
+     *   "tags": [{ "id": "103a0992…", "name": "audit-tmp-fromtmpl", "color": null }],
+     *   "assignment": { "id": "103a09a1…", "method": "virtual", "summary": { "signer_count": 1, "completed_count": 0 } },
+     *   "pages": [{ "id": "103a0992…", "number": 1, "height": 1651, "width": 1275, "download_url": "https://…/download" }],
+     *   "created_at": "2026-07-15T19:57:55Z",
+     *   "updated_at": "2026-07-15T19:59:33Z"
      * }
      * ```
-     * @throws {ValidationError} If no account ID is available.
+     * @throws {ValidationError} If `templateId` is missing or no account ID is
+     * available.
+     * @throws {ApiError} `400` if the signers/roles are invalid or the template
+     * is not ready.
+     *
+     * @example
+     * ```ts
+     * await client.documents.createFromTemplate('tmpl_id', [
+     *   { role_id: 'role_id', id: 'signer_id', verification_method: 'Email', notification_methods: ['Email'] },
+     * ], { name: 'My Contract' });
+     * ```
+     */
+    createFromTemplate(templateId: string, signers: ITemplateSigner[], options?: ICreateDocumentFromTemplateOptions, accountId?: string): Promise<IDocumentDetailsResponse>;
+    /**
+     * Estimate the credit cost of creating a document from a template
+     * (`POST /accounts/{accountId}/templates/{templateId}/documents/estimate-cost`).
+     *
+     * A dry run: sends only `{ signers }` and consumes nothing. Use it to check
+     * balances before calling {@link DocumentResource.createFromTemplate}.
+     *
+     * @param templateId - The template that would be instantiated.
+     * @param signers - One channel descriptor per template role. Cost requests
+     * use only `role_id`, `verification_method`, and `notification_methods`;
+     * they do not send a signer ID or signing-order step.
+     * @param accountId - Override the client's default account ID.
+     * @returns An {@link ICostEstimate}: `total_credits`, balances, and a
+     * per-line `breakdown` of what the operation would consume:
+     * ```jsonc
+     * {
+     *   "documents": 1,
+     *   "credits": 1,
+     *   "needs_extra_document": false,
+     *   "extra_document_cost": 0,
+     *   "total_credits": 1,
+     *   "breakdown": [
+     *     { "code": "signature", "name": "Assinatura", "cost": 1, "quantity": 1, "unit_cost": 1 }
+     *   ],
+     *   "document_balance": 10,
+     *   "credit_balance": 250,
+     *   "has_sufficient_resources": true,
+     *   "blocking_reason": null,
+     *   "message": null
+     * }
+     * ```
+     * @throws {ValidationError} If `templateId` is missing or 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 });
+     * const estimate = await client.documents.estimateCostFromTemplate('tmpl_id', [
+     *   { role_id: 'role_id', verification_method: 'Email' },
+     * ]);
+     * if (!estimate.has_sufficient_resources) throw new Error(estimate.blocking_reason ?? 'insufficient');
      * ```
      */
-    list(params?: IAssignmentListParams, accountId?: string): Promise<IAssignmentListResponse>;
-    /** Create a signing assignment for a document. */
-    create(documentId: string, payload: ICreateAssignmentPayload): Promise<ICreateAssignmentResponse>;
+    estimateCostFromTemplate(templateId: string, signers: ITemplateCostSigner[], accountId?: string): Promise<ICostEstimate>;
     /**
-     * Estimate the cost (in credits/documents) of creating the assignment.
+     * Verify a signed document by its signature hash
+     * (`GET /documents/{documentSignatureHash}/verify`).
      *
-     * Signer entries may omit `id` and supply only `verification_method` /
-     * `notification_methods` when only the channel mix matters for the estimate.
+     * Public authenticity check: given the hash embedded in a certificated
+     * document, returns the API's typed verification record for it. Unknown
+     * hashes still return HTTP 200 with `is_valid: false`.
      *
-     * @returns an {@link ICostEstimate} with `total_credits`, balances, and a
-     * line-item `breakdown`.
+     * @param hash - The document's signature hash (the
+     * `documentSignatureHash` path segment).
+     * @returns `{ hash, id, status, page_count, signer_count, completed_count,
+     * completed_at, verified_at, is_valid, message }`.
+     * @throws {ValidationError} If `hash` is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const result = await client.documents.verify('a7b8c9d0e1f2…');
+     * ```
      */
-    estimateCost(documentId: string, payload: ICreateAssignmentPayload): Promise<ICostEstimate>;
+    verify(hash: string): Promise<IDocumentVerification>;
     /**
-     * Update the expiration date of an existing assignment.
-     * Pass `null` to remove the expiration entirely.
+     * List every possible document status (`GET /documents/statuses`).
+     *
+     * A static catalog (11 entries) of each status `code` and whether documents
+     * in that status can be deleted (`deletable`). This catalog requires the
+     * same API-key or Bearer authentication as other workspace operations.
+     *
+     * @returns The status catalog:
+     * ```jsonc
+     * [
+     *   { "code": "uploading", "deletable": false },
+     *   { "code": "uploaded", "deletable": false },
+     *   { "code": "metadata_processing", "deletable": false },
+     *   { "code": "metadata_ready", "deletable": true },
+     *   { "code": "pending_signature", "deletable": true },
+     *   { "code": "certificated", "deletable": false }
+     *   // …11 total: also expired, certificating, rejected_by_signer,
+     *   //            rejected_by_user, failed
+     * ]
+     * ```
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const statuses = await client.documents.statuses();
+     * const deletable = statuses.filter((s) => s.deletable).map((s) => s.code);
+     * ```
      */
-    resetExpiration(documentId: string, assignmentId: string, expiresAt: string | null): Promise<IAssignment>;
-    /** Resend the signing notification to a single signer. */
-    resendNotification(documentId: string, assignmentId: string, signerId: string): Promise<IResendEmailResponse>;
+    statuses(): Promise<IDocumentStatusInfo[]>;
     /**
-     * Estimate the cost of resending a signer notification.
+     * Public, unauthenticated lookup of basic document info
+     * (`GET /public/documents/{documentId}`).
+     *
+     * Used by the signing portal before the signer authenticates via the access
+     * code, so it returns only non-sensitive fields.
+     *
+     * @param documentId - The document to look up.
+     * @returns Basic public info for the document:
+     * ```jsonc
+     * {
+     *   "resource": "document",
+     *   "id": "103ad216846e6b90710cb9acef59",
+     *   "name": "Service agreement.pdf",
+     *   "page_count": 1,
+     *   "created_by": "Multica Test"
+     * }
+     * ```
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `404` if the document does not exist.
      *
-     * @returns an {@link IResendCostEstimate} (`total`, `breakdown`, balances).
+     * @example
+     * ```ts
+     * const info = await client.documents.getPublic('103ad216846e6b90710cb9acef59');
+     * ```
      */
-    estimateResendCost(documentId: string, assignmentId: string, signerId: string): Promise<IResendCostEstimate>;
+    getPublic(documentId: string): Promise<IPublicDocumentInfo>;
     /**
-     * `GET /documents/{documentId}/assignments/{assignmentId}/whatsapp-notifications`
-     * — list every WhatsApp notification rendered + sent for an assignment.
+     * Send the signer's access token to their email / WhatsApp
+     * (`PUT /public/documents/{documentId}/send-token`).
+     *
+     * Part of the public signing flow: dispatches the 6-digit verification
+     * token the signer enters to view the document. The documented request body
+     * is `{ email }`. For compatibility with Assinafy environments that still
+     * require the older contract, passing an explicit `channel` sends
+     * `{ recipient, channel }`; the two-argument documented call also retries
+     * that legacy shape only when the server explicitly reports that
+     * `channel`/`recipient` is required.
+     *
+     * @param documentId - The document to send the token for.
+     * @param recipient - The signer's email address (or WhatsApp number when an
+     * explicit channel is supplied).
+     * @param channel - Optional legacy delivery channel.
+     * @returns Nothing after the API's empty acknowledgement.
+     * @throws {ValidationError} If `documentId` or `recipient` is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * await client.documents.sendToken('doc-1', 'signer@example.com');
+     * await client.documents.sendToken('doc-1', '+5511999998888', 'whatsapp');
+     * ```
      */
-    listWhatsAppNotifications(documentId: string, assignmentId: string): Promise<IWhatsAppNotification[]>;
-}
-
-/**
- * Default webhook events applied by {@link WebhookResource.register} when the
- * caller omits `events` (or passes an empty array).
- */
-declare const DEFAULT_WEBHOOK_EVENTS: WebhookEventType[];
-declare class WebhookResource extends BaseResource {
+    sendToken(documentId: string, email: string): Promise<void>;
+    sendToken(documentId: string, recipient: string, channel: SendTokenChannel): Promise<void>;
     /**
-     * Register (or replace) the workspace's single webhook subscription
-     * (`PUT /accounts/{id}/webhooks/subscriptions`). There is exactly one
-     * subscription per workspace, keyed by URL.
+     * Quick boolean check: has every signer completed their assignment?
      *
-     * When `events` is omitted or empty, {@link DEFAULT_WEBHOOK_EVENTS} is used
-     * (`document_ready`, `document_prepared`, `signer_signed_document`,
-     * `signer_rejected_document`, `document_processing_failed`).
+     * A computed convenience over {@link DocumentResource.details} (one `GET
+     * /documents/{documentId}`). Returns `true` when the document status is
+     * `certificated`, or when the assignment summary reports at least one signer
+     * and `signer_count === completed_count`. Returns `false` when there is no
+     * assignment summary (nothing to sign yet) or counts disagree.
+     *
+     * @param documentId - The document to check.
+     * @returns `true` if fully signed, otherwise `false`.
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `404` if the document does not exist.
      *
      * @example
      * ```ts
-     * await client.webhooks.register({ url: 'https://example.com/hook', email: 'ops@example.com' });
-     * // → { url, email, events: [...], is_active: true, updated_at: '2026-…' }
+     * if (await client.documents.isFullySigned('doc-1')) {
+     *   const pdf = await client.documents.download('doc-1');
+     * }
      * ```
      */
-    register(payload: IWebhookRegisterPayload, accountId?: string): Promise<IWebhookSubscription>;
-    /** Fetch the current webhook subscription. Returns `null` if none exists. */
-    get(accountId?: string): Promise<IWebhookSubscription | null>;
+    isFullySigned(documentId: string): Promise<boolean>;
     /**
-     * Inactivate the current webhook subscription.
+     * Summarise signing progress for UI display.
      *
-     * 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`.
+     * A computed convenience over {@link DocumentResource.details} (one `GET
+     * /documents/{documentId}`). `total` and `signed` come from the assignment
+     * summary's `signer_count` / `completed_count`; when the summary is absent
+     * `total` falls back to `assignment.signers.length` (and `signed` to `0`).
+     * `percentage` is `signed / total` rounded to two decimals (`0` when
+     * `total` is `0`).
+     *
+     * @param documentId - The document to summarise.
+     * @returns An {@link ISigningProgress}, e.g. one of three signed:
+     * ```jsonc
+     * { "signed": 1, "total": 3, "pending": 2, "percentage": 33.33 }
+     * ```
+     * @throws {ValidationError} If `documentId` is missing.
+     * @throws {ApiError} `404` if the document does not exist.
+     *
+     * @example
+     * ```ts
+     * const { signed, total, percentage } = await client.documents.getSigningProgress('doc-1');
+     * console.log(`${signed}/${total} (${percentage}%)`);
+     * ```
      */
-    inactivate(accountId?: string): Promise<IWebhookSubscription>;
-    /** List currently supported webhook event types. */
-    listEventTypes(): Promise<IWebhookEventTypeInfo[]>;
-    /** List webhook delivery history for the workspace. */
-    listDispatches(params?: IWebhookDispatchListParams, accountId?: string): Promise<PaginatedResult<IWebhookDispatch>>;
-    /** Retry delivery of a specific webhook dispatch. */
-    retryDispatch(dispatchId: string, accountId?: string): Promise<IWebhookDispatch>;
+    getSigningProgress(documentId: string): Promise<ISigningProgress>;
 }
 
-declare class TemplateResource extends BaseResource {
+declare class SignerResource extends BaseResource {
     /**
-     * Create a template by uploading a PDF (`POST /accounts/{id}/templates`).
+     * Create a signer in the workspace (`POST /accounts/{accountId}/signers`).
      *
-     * The template is created in `Uploaded` status and transitions to `Ready`
-     * once the platform finishes processing its pages. Configure roles/fields
-     * afterwards in the Assinafy editor.
+     * `email` and `whatsapp_phone_number` are both optional in the official
+     * schema; a name-only signer is valid. When an `email` is supplied the call
+     * is idempotent by email:
+     * an existing signer with that address is reused instead of duplicated (a
+     * duplicate POST is answered by the API with `400 "Um signatário com este
+     * e-mail já existe."`, which this method recovers from transparently).
+     *
+     * @param payload - The signer to create. Only `full_name` is required.
+     * Optional `email`, `whatsapp_phone_number`/`phone`, and `cpf` are normalized
+     * before sending.
+     * @param accountId - Override the client's default account ID.
+     * @returns The created (or reused) signer. Note the response **never echoes
+     * `cpf` back**, even when one was sent:
+     * ```jsonc
+     * {
+     *   "resource": "signer",
+     *   "id": "19e6b92e7895332ed9708535d8c",
+     *   "full_name": "Ana Souza",
+     *   "email": "ana@example.com",
+     *   "whatsapp_phone_number": null,
+     *   "has_accepted_terms": false
+     * }
+     * ```
+     * @throws {ValidationError} If the name/contact values are malformed or no
+     * account ID is available.
+     * @throws {ApiError} If the API rejects the request for a reason other than a
+     * recoverable duplicate email.
      *
      * @example
      * ```ts
-     * const tmpl = await client.templates.create(
-     *   { filePath: './nda.pdf' },
-     *   { name: 'NDA template' },
-     * );
-     * // → { resource: 'template', id, name, status: 'Uploaded',
-     * //     roles: [{ id, name: 'TemplateEditor', assignment_type: 'Editor' }],
-     * //     pages: [], tags: [], created_at, updated_at }
+     * const signer = await client.signers.create({
+     *   full_name: 'Ana Souza',
+     *   email: 'ana@example.com',
+     *   cpf: '390.533.447-05', // sent as '39053344705', never echoed back
+     * });
+     *
+     * // A whatsapp-only signer (no email):
+     * await client.signers.create({
+     *   full_name: 'Bruno Lima',
+     *   whatsapp_phone_number: '+5548999990000',
+     * });
+     *
+     * // Name-only is also valid (but cannot receive a notification yet):
+     * await client.signers.create({ full_name: 'Carla Sem Contato' });
      * ```
      */
-    create(source: DocumentUploadSource, options?: {
-        name?: string;
-        accountId?: string;
-    }): Promise<ITemplateDetailsResponse>;
-    /** List templates for the workspace. */
-    list(params?: IListParams, accountId?: string): Promise<ITemplateListResponse>;
+    create(payload: ICreateSignerPayload, accountId?: string): Promise<ICreateSignerResponse>;
     /**
-     * Get a template by ID (`GET /accounts/{id}/templates/{template_id}`).
+     * Get a signer by ID (`GET /accounts/{accountId}/signers/{signerId}`).
      *
-     * 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.
+     * @param signerId - The signer to fetch.
+     * @param accountId - Override the client's default account ID.
+     * @returns The signer:
+     * ```jsonc
+     * {
+     *   "resource": "signer",
+     *   "id": "19e6b92e7895332ed9708535d8c",
+     *   "full_name": "Example Signer",
+     *   "email": "signer@example.com",
+     *   "whatsapp_phone_number": null,
+     *   "has_accepted_terms": false
+     * }
+     * ```
+     * @throws {ValidationError} If `signerId` is missing or no account ID is available.
+     * @throws {ApiError} `404` if the signer does not exist.
+     *
+     * @example
+     * ```ts
+     * const signer = await client.signers.get('19e6b92e7895332ed9708535d8c');
+     * ```
      */
-    get(templateId: string, accountId?: string): Promise<ITemplateDetailsResponse>;
+    get(signerId: string, accountId?: string): Promise<ISigner>;
     /**
-     * Update a template's `name` and/or default `message`
-     * (`PUT /accounts/{id}/templates/{template_id}`). Returns the updated template.
+     * List signers for the workspace (`GET /accounts/{accountId}/signers`).
+     * Pagination info (if any) is attached in `meta`.
+     *
+     * @param params - `page`, `per-page`, `search`, `sort`. `per-page` is
+     * clamped to the API maximum of 50.
+     * @param accountId - Override the client's default account ID.
+     * @returns The matching signers, with pagination in `meta`. Each item:
+     * ```jsonc
+     * {
+     *   "id": "19e6b92e7895332ed9708535d8c",
+     *   "full_name": "Example Signer",
+     *   "email": "signer@example.com",
+     *   "whatsapp_phone_number": null,
+     *   "has_accepted_terms": false
+     * }
+     * ```
+     * @throws {ValidationError} If no account ID is available.
+     * @throws {ApiError} If the API rejects the request.
      *
      * @example
      * ```ts
-     * await client.templates.update(templateId, { name: 'NDA v2', message: 'Please sign' });
+     * const { data, meta } = await client.signers.list({
+     *   search: 'ana',
+     *   'per-page': 20,
+     * });
      * ```
      */
-    update(templateId: string, payload: IUpdateTemplatePayload, accountId?: string): Promise<ITemplateDetailsResponse>;
-    /** Delete a template (`DELETE /accounts/{id}/templates/{template_id}`). */
-    delete(templateId: string, accountId?: string): Promise<void>;
+    list(params?: IListParams, accountId?: string): Promise<ISignerListResponse>;
     /**
-     * Download a template page as a JPEG
-     * (`GET /accounts/{id}/templates/{template_id}/pages/{page_id}/download`).
+     * Update a signer (`PUT /accounts/{accountId}/signers/{signerId}`). Fails
+     * if the signer has active assignments.
      *
-     * Used by template editors to render page thumbnails on the client. The
-     * matching `download_url` is also returned on each `template.pages[]` entry.
+     * @param signerId - The signer to update.
+     * @param payload - Fields to change. Any `cpf` is stripped to digits before
+     * sending.
+     * @param accountId - Override the client's default account ID.
+     * @returns The updated signer (as with create, `cpf` is never echoed back):
+     * ```jsonc
+     * {
+     *   "resource": "signer",
+     *   "id": "19e6b92e7895332ed9708535d8c",
+     *   "full_name": "Ana Souza Lima",
+     *   "email": "ana@example.com",
+     *   "whatsapp_phone_number": null,
+     *   "has_accepted_terms": false
+     * }
+     * ```
+     * @throws {ValidationError} If `signerId` is missing or no account ID is available.
+     * @throws {ApiError} `400` if the signer has active assignments; `404` if it
+     * does not exist.
+     *
+     * @example
+     * ```ts
+     * await client.signers.update('19e6b92e7895332ed9708535d8c', {
+     *   full_name: 'Ana Souza Lima',
+     * });
+     * ```
      */
-    downloadPage(templateId: string, pageId: string, accountId?: string): Promise<Buffer>;
+    update(signerId: string, payload: IUpdateSignerPayload, accountId?: string): Promise<ICreateSignerResponse>;
+    /**
+     * Delete a signer (`DELETE /accounts/{accountId}/signers/{signerId}`).
+     *
+     * @param signerId - The signer to delete.
+     * @param accountId - Override the client's default account ID.
+     * @returns Nothing on success (resolves to `void`).
+     * @throws {ValidationError} If `signerId` is missing or no account ID is available.
+     * @throws {ApiError} `404` if the signer does not exist; `400`/`409` if it
+     * still has active assignments.
+     *
+     * @example
+     * ```ts
+     * await client.signers.delete('19e6b92e7895332ed9708535d8c');
+     * ```
+     */
+    delete(signerId: string, accountId?: string): Promise<void>;
+    /**
+     * Find a signer by exact email
+     * (`GET /accounts/{accountId}/signers?search={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.
+     *
+     * A `404` from the underlying list is treated as "no match" and mapped to
+     * `null`; any other {@link ApiError} propagates.
+     *
+     * @param email - Exact email address to look for.
+     * @param accountId - Override the client's default account ID.
+     * @returns The matching {@link ISigner}, or `null` if none match. A hit
+     * looks like:
+     * ```jsonc
+     * {
+     *   "id": "19e6b92e7895332ed9708535d8c",
+     *   "full_name": "Ana Souza",
+     *   "email": "ana@example.com",
+     *   "whatsapp_phone_number": null,
+     *   "has_accepted_terms": false
+     * }
+     * ```
+     * @throws {ValidationError} If `email` is not a valid address.
+     * @throws {ApiError} If the list request fails with a status other than 404.
+     *
+     * @example
+     * ```ts
+     * const signer = await client.signers.findByEmail('ana@example.com');
+     * if (signer) console.log(signer.id);
+     * ```
+     */
+    findByEmail(email: string, accountId?: string): Promise<ISigner | null>;
+    private assertEmail;
 }
 
+/** File accepted by the account-logo upload endpoint. */
+type AccountLogoUploadSource = {
+    filePath: string;
+    fileName?: string;
+    contentType?: string;
+} | {
+    buffer: Buffer;
+    fileName: string;
+    contentType?: string;
+};
 /**
- * Workspace-scoped tags used to label documents and templates.
+ * Manage workspaces — the Assinafy _account_ objects that own every document,
+ * signer, template, tag, field, and webhook. Each endpoint lives under
+ * `/accounts`, and the `accountId` used elsewhere in the SDK is a workspace id.
  *
- * Covers the full Tag section of the API docs:
- *  - `GET    /accounts/{id}/tags`            → {@link list}
- *  - `POST   /accounts/{id}/tags`            → {@link create}
- *  - `PUT    /accounts/{id}/tags/{tag_id}`   → {@link update}
- *  - `DELETE /accounts/{id}/tags/{tag_id}`   → {@link delete}
+ * Colours (`primary_color` / `secondary_color`) are stored on the workspace and
+ * echoed back on the response. They must be an **exactly 6-character hex string
+ * with NO leading `#`** (`'ff0066'`, not `'#ff0066'`); a `#`-prefixed value is
+ * rejected with `400`. Verified live against the API.
  *
- * Document-level attach/detach lives on {@link DocumentResource} (`listTags`,
- * `replaceTags`, `addTags`, `detachTag`).
+ * @example
+ * ```ts
+ * const ws = await client.workspaces.create({ name: 'Acme Legal' });
+ * const { data } = await client.workspaces.list();
+ * ```
  */
-declare class TagResource extends BaseResource {
-    /** List the workspace's tags, ordered alphabetically. Optional case-insensitive `search`. */
-    list(params?: {
-        search?: string;
-    }, accountId?: string): Promise<ITag[]>;
-    /** Create a tag. Throws `ApiError` (409) if the name already exists (case-insensitive). */
-    create(payload: ICreateTagPayload, accountId?: string): Promise<ITag>;
+declare class WorkspaceResource extends BaseResource {
+    /**
+     * Create a new workspace (`POST /accounts`).
+     *
+     * @param payload - The workspace `name` (required) plus optional brand
+     * colours. Colours are 6-char hex **without** a leading `#`.
+     * @returns The created workspace. Response shape:
+     * ```jsonc
+     * {
+     *   "id": "acc_example",
+     *   "name": "Acme Legal",
+     *   "primary_color": "ff0066",
+     *   "secondary_color": "0066ff",
+     *   "created_at": "2026-05-12T18:05:11Z"
+     * }
+     * ```
+     * @throws {ApiError} If the API rejects the request — e.g. `400` when a
+     * colour is not exactly 6 hex characters (or carries a leading `#`).
+     *
+     * @example
+     * ```ts
+     * const ws = await client.workspaces.create({
+     *   name: 'Acme Legal',
+     *   primary_color: 'ff0066',
+     *   secondary_color: '0066ff',
+     * });
+     * ```
+     */
+    create(payload: ICreateWorkspacePayload): Promise<IWorkspaceResponse>;
+    /**
+     * List workspaces the authenticated user can access (`GET /accounts`).
+     *
+     * @returns The workspaces, with any pagination in `meta`. Each item exposes
+     * the caller's `roles` and whether it may be deleted:
+     * ```jsonc
+     * {
+     *   "data": [
+     *     {
+     *       "id": "acc_example",
+     *       "name": "MT",
+     *       "roles": ["owner"],
+     *       "is_delete_allowed": true,
+     *       "created_at": "2026-05-12T18:05:11Z"
+     *     }
+     *   ]
+     * }
+     * ```
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const { data } = await client.workspaces.list();
+     * const owned = data.filter((w) => w.roles.includes('owner'));
+     * ```
+     */
+    list(): Promise<IWorkspaceListResponse>;
+    /**
+     * Fetch a single workspace (`GET /accounts/{accountId}`).
+     *
+     * @param accountId - The workspace to fetch.
+     * @returns The workspace. `primary_color` / `secondary_color` are `null`
+     * until brand colours are set (6-char hex, no `#`, when present):
+     * ```jsonc
+     * {
+     *   "id": "acc_example",
+     *   "name": "MT",
+     *   "primary_color": null,
+     *   "secondary_color": null,
+     *   "created_at": "2026-05-12T18:05:11Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `accountId` is missing.
+     * @throws {ApiError} `404` if the workspace does not exist.
+     *
+     * @example
+     * ```ts
+     * const ws = await client.workspaces.get('acc_example');
+     * ```
+     */
+    get(accountId: string): Promise<IWorkspaceResponse>;
+    /**
+     * Fetch account branding (`GET /accounts/{accountId}/theme`).
+     *
+     * Request body/query: none.
+     *
+     * @param accountId - Account whose public branding should be returned.
+     * @returns The unwrapped theme:
+     * ```jsonc
+     * {
+     *   "account_name": "Acme Inc.",
+     *   "primary_color": "aabbcc",
+     *   "secondary_color": "112233",
+     *   "logo": "https://api.assinafy.com.br/v1/accounts/account-id/logo"
+     * }
+     * ```
+     * @throws {ValidationError} If `accountId` is empty.
+     * @throws {ApiError} `401` for invalid credentials or `500` on failure.
+     *
+     * @example
+     * ```ts
+     * const theme = await client.workspaces.getTheme('acc_example');
+     * ```
+     */
+    getTheme(accountId: string): Promise<IAccountTheme>;
+    /**
+     * Download the account logo (`GET /accounts/{accountId}/logo`).
+     *
+     * @param accountId - Account whose current logo should be downloaded.
+     * @returns Raw image bytes as a Node {@link Buffer}. The endpoint's response
+     * content type is `image/*` and depends on the uploaded file.
+     * @throws {ValidationError} If `accountId` is empty.
+     * @throws {ApiError} `404` when no logo exists.
+     *
+     * @example
+     * ```ts
+     * const logo = await client.workspaces.downloadLogo('acc_example');
+     * ```
+     */
+    downloadLogo(accountId: string): Promise<Buffer>;
+    /**
+     * Upload or replace the account logo (`POST /accounts/{accountId}/logo`).
+     *
+     * The request is `multipart/form-data` with exactly one `file` part. No
+     * response data is defined; the method resolves once the API acknowledges
+     * the update.
+     *
+     * @param accountId - Account whose logo will be replaced.
+     * @param source - File path or `{ buffer, fileName }`; optionally set an
+     * explicit MIME `contentType` for an in-memory image.
+     * @returns Resolves when the API acknowledges the multipart upload.
+     * @throws {ValidationError} If an id/file name is missing or the file is empty.
+     * Unlike PDF uploads, the official logo operation defines no 25 MB cap, so
+     * the SDK does not impose the document limit here.
+     * @throws {ApiError} `400`/`415` if the API rejects the image.
+     *
+     * @example
+     * ```ts
+     * await client.workspaces.uploadLogo('acc_example', {
+     *   buffer: logoPng,
+     *   fileName: 'logo.png',
+     *   contentType: 'image/png',
+     * });
+     * ```
+     */
+    uploadLogo(accountId: string, source: AccountLogoUploadSource): Promise<void>;
+    /**
+     * Delete the current account logo (`DELETE /accounts/{accountId}/logo`).
+     *
+     * Request/response data: none beyond the standard status/message envelope.
+     *
+     * @param accountId - Account whose logo should be removed.
+     * @returns Resolves when the API acknowledges deletion.
+     * @example
+     * ```ts
+     * await client.workspaces.deleteLogo('acc_example');
+     * ```
+     */
+    deleteLogo(accountId: string): Promise<void>;
+    /**
+     * Return this account's document-funnel KPIs
+     * (`GET /accounts/{accountId}/stats`).
+     *
+     * @param accountId - Account to aggregate.
+     * @param params - Omit for 12 monthly rows, or request daily rows with
+     * `{ granularity: 'daily', month: '2026-06' }`.
+     * @returns Zero-filled KPI rows:
+     * ```jsonc
+     * [{
+     *   "period": "2026-06",
+     *   "documents_uploaded": 42,
+     *   "documents_sent": 37,
+     *   "signature_requests": 61,
+     *   "signature_requests_email": 55,
+     *   "signature_requests_whatsapp": 18,
+     *   "signature_requests_viewed": 44,
+     *   "signature_requests_completed": 52,
+     *   "documents_certified": 30
+     * }]
+     * ```
+     * @throws {ValidationError} For an empty account id, missing daily month,
+     * or a month not formatted as `YYYY-MM`.
+     * @throws {ApiError} `401` for invalid credentials or `404` when the route
+     * is not deployed in a lagging environment.
+     *
+     * @example
+     * ```ts
+     * const monthly = await client.workspaces.getStats('acc_example');
+     * const daily = await client.workspaces.getStats('acc_example', {
+     *   granularity: 'daily',
+     *   month: '2026-06',
+     * });
+     * ```
+     */
+    getStats(accountId: string, params?: IDocumentStatsParams): Promise<IDocumentStatsRow[]>;
+    /**
+     * Update a workspace (`PUT /accounts/{accountId}`).
+     *
+     * @param accountId - The workspace to update.
+     * @param payload - The fields to change (`name` and/or brand colours).
+     * Colours are 6-char hex **without** a leading `#`; pass `null` to clear one.
+     * @returns The updated workspace. Response shape:
+     * ```jsonc
+     * {
+     *   "id": "acc_example",
+     *   "name": "Acme Legal (Renamed)",
+     *   "primary_color": "ff0066",
+     *   "secondary_color": "0066ff",
+     *   "created_at": "2026-05-12T18:05:11Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `accountId` is missing.
+     * @throws {ApiError} `400` for an invalid colour; `404` if the workspace
+     * does not exist.
+     *
+     * @example
+     * ```ts
+     * await client.workspaces.update('acc_example', {
+     *   name: 'Acme Legal (Renamed)',
+     *   primary_color: 'ff0066',
+     * });
+     * ```
+     */
+    update(accountId: string, payload: IUpdateWorkspacePayload): Promise<IWorkspaceResponse>;
+    /**
+     * Delete a workspace (`DELETE /accounts/{accountId}`).
+     *
+     * A workspace with restrictions (e.g. remaining documents) is rejected with
+     * `400` and a `restrictions` list; pass `{ force: true }` to override and
+     * delete it anyway. The flag is sent in the request body, per the API.
+     *
+     * @param accountId - The workspace to delete.
+     * @param options - Set `force: true` to delete despite restrictions.
+     * @returns Nothing on success (`200` with no meaningful body).
+     * @throws {ValidationError} If `accountId` is missing.
+     * @throws {ApiError} `400` (with a `restrictions` list) when the workspace
+     * has restrictions and `force` was not set; `404` if it does not exist.
+     *
+     * @example
+     * ```ts
+     * await client.workspaces.delete('acc_example');
+     * // override restrictions:
+     * await client.workspaces.delete('acc_example', { force: true });
+     * ```
+     */
+    delete(accountId: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+}
+
+/**
+ * Normalize a public assignment input into the exact create-request body.
+ * String IDs and legacy `signer_id` aliases become signer objects, omitted
+ * values are removed, and collect assignments must include placement entries.
+ *
+ * @param payload - Assignment method, signer references, and optional message,
+ * expiration, copy receivers, or collect-field placements.
+ * @returns A JSON-ready body shaped as
+ * `{ method, signers: [{ id, verification_method?, notification_methods?, step? }], message?, expires_at?, copy_receivers?, entries? }`.
+ * @throws {ValidationError} If no signer is present, a signer reference is
+ * malformed, or a collect assignment has no field-placement entries.
+ *
+ * @example
+ * ```ts
+ * const body = buildAssignmentPayload({
+ *   method: 'virtual',
+ *   signers: ['signer-1', { signer_id: 'signer-2', step: 2 }],
+ *   message: 'Please sign',
+ * });
+ * // body.signers → [{ id: 'signer-1' }, { id: 'signer-2', step: 2 }]
+ * ```
+ */
+declare function buildAssignmentPayload(payload: ICreateAssignmentPayload): Record<string, unknown>;
+declare class AssignmentResource 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 is a full
+     * {@link IAssignment} (same shape as {@link AssignmentResource.create}
+     * returns):
+     * ```jsonc
+     * {
+     *   "id": "103033c9d2cec233bf65eea04999",
+     *   "sender_email": "sender@example.com",
+     *   "method": "virtual",
+     *   "expires_at": null,
+     *   "message": "Please sign this contract",
+     *   "copy_receivers": [],
+     *   "signers": [
+     *     {
+     *       "id": "19e6b92e7895332ed9708535d8c",
+     *       "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
+     *     }
+     *   ],
+     *   "items": [
+     *     {
+     *       "id": "103033c9d33326458deb74fc3052",
+     *       "page": null,
+     *       "signer": {
+     *         "id": "19e6b92e7895332ed9708535d8c",
+     *         "full_name": "Ana Souza",
+     *         "email": "signer@example.com",
+     *         "whatsapp_phone_number": null,
+     *         "has_accepted_terms": false
+     *       },
+     *       "field": {
+     *         "id": "signer-example",
+     *         "name": "Virtual",
+     *         "type": "virtual",
+     *         "is_active": true
+     *       },
+     *       "value": null,
+     *       "completed": false
+     *     }
+     *   ],
+     *   "summary": {
+     *     "signer_count": 1,
+     *     "completed_count": 0,
+     *     "signers": [
+     *       {
+     *         "id": "19e6b92e7895332ed9708535d8c",
+     *         "full_name": "Ana Souza",
+     *         "email": "signer@example.com",
+     *         "whatsapp_phone_number": null,
+     *         "has_accepted_terms": false,
+     *         "completed": false
+     *       }
+     *     ]
+     *   },
+     *   "signing_urls": [
+     *     {
+     *       "signer_id": "19e6b92e7895332ed9708535d8c",
+     *       "url": "https://app-sandbox.assinafy.com.br/sign/103033c950d865a248a11c5cf96c?email=signer%40example.com"
+     *     }
+     *   ]
+     * }
+     * ```
+     * @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 });
+     * ```
+     */
+    list(params?: IAssignmentListParams, accountId?: string): Promise<IAssignmentListResponse>;
+    /**
+     * Create a signing assignment for a document
+     * (`POST /documents/{documentId}/assignments`).
+     *
+     * Signers may be passed as bare id strings or as objects
+     * (`{ id, verification_method, notification_methods, step }`); the SDK
+     * normalises them to the docs-sanctioned `signers: [{ ... }]` shape via
+     * {@link buildAssignmentPayload}. The document must have reached
+     * `metadata_ready` before an assignment can be created.
+     *
+     * @param documentId - The document to request signatures on.
+     * @param payload - Signers plus optional `method` (defaults to `virtual`),
+     * `message`, `expires_at`, `copy_receivers`, and `collect`-mode `entries`.
+     * @returns The created {@link IAssignment}: `signers` (rich, with `step` /
+     * `notified` / `verification_method`), `items` (one row per signer × field),
+     * a `summary` count block, and per-signer `signing_urls`. Response shape:
+     * ```jsonc
+     * {
+     *   "id": "103033c9d2cec233bf65eea04999",
+     *   "sender_email": "sender@example.com",
+     *   "method": "virtual",
+     *   "expires_at": null,
+     *   "message": "Please sign this contract",
+     *   "copy_receivers": [],
+     *   "signers": [
+     *     {
+     *       "id": "19e6b92e7895332ed9708535d8c",
+     *       "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
+     *     }
+     *   ],
+     *   "items": [
+     *     {
+     *       "id": "103033c9d33326458deb74fc3052",
+     *       "page": null,
+     *       "signer": {
+     *         "id": "19e6b92e7895332ed9708535d8c",
+     *         "full_name": "Ana Souza",
+     *         "email": "signer@example.com"
+     *       },
+     *       "field": {
+     *         "id": "signer-example",
+     *         "name": "Virtual",
+     *         "type": "virtual",
+     *         "is_active": true
+     *       },
+     *       "value": null,
+     *       "completed": false
+     *     }
+     *   ],
+     *   "summary": {
+     *     "signer_count": 1,
+     *     "completed_count": 0,
+     *     "signers": [
+     *       {
+     *         "id": "19e6b92e7895332ed9708535d8c",
+     *         "full_name": "Ana Souza",
+     *         "email": "signer@example.com",
+     *         "whatsapp_phone_number": null,
+     *         "has_accepted_terms": false,
+     *         "completed": false
+     *       }
+     *     ]
+     *   },
+     *   "signing_urls": [
+     *     {
+     *       "signer_id": "19e6b92e7895332ed9708535d8c",
+     *       "url": "https://app-sandbox.assinafy.com.br/sign/103033c950d865a248a11c5cf96c?email=signer%40example.com"
+     *     }
+     *   ]
+     * }
+     * ```
+     * @throws {ValidationError} If `documentId` is missing, no signer is
+     * supplied, or a signer reference is invalid.
+     * @throws {ApiError} If the API rejects the request — e.g. `400`
+     * ("Um signatário com este e-mail já existe.") when a signer email already
+     * exists on the account.
+     *
+     * @example
+     * ```ts
+     * const assignment = await client.assignments.create('doc-1', {
+     *   signers: ['19e6b92e7895332ed9708535d8c'],
+     *   message: 'Please sign this contract',
+     * });
+     * // → wire body: { method: 'virtual', signers: [{ id: '19e6…' }], message: 'Please sign this contract' }
+     * assignment.signing_urls?.forEach((s) => console.log(s.signer_id, s.url));
+     * ```
+     */
+    create(documentId: string, payload: ICreateAssignmentPayload): Promise<ICreateAssignmentResponse>;
+    /**
+     * Estimate the cost (in credits/documents) of creating the assignment
+     * (`POST /documents/{documentId}/assignments/estimate-cost`).
+     *
+     * Unlike {@link AssignmentResource.create}, estimate signer entries contain
+     * only `verification_method` / `notification_methods` (or `{}` for the
+     * default Email channel). {@link buildAssignmentEstimatePayload} projects
+     * exactly the fields permitted by the estimate schema.
+     *
+     * @param documentId - The document the assignment would be created on.
+     * @param payload - `method` plus channel-only signer descriptors and/or
+     * `collect`-mode `entries`. Create-only fields and signer IDs are not part
+     * of this request schema.
+     * @returns an {@link ICostEstimate} with `total_credits`, balances, a
+     * line-item `breakdown`, and a `has_sufficient_resources` gate. Response
+     * shape:
+     * ```jsonc
+     * {
+     *   "documents": 1,
+     *   "credits": 0,
+     *   "needs_extra_document": false,
+     *   "extra_document_cost": 0,
+     *   "total_credits": 0,
+     *   "breakdown": [],
+     *   "document_balance": 67,
+     *   "credit_balance": 0,
+     *   "has_sufficient_resources": true,
+     *   "blocking_reason": null,
+     *   "message": null
+     * }
+     * ```
+     * @throws {ValidationError} If `documentId` is missing, a `virtual` request
+     * has no signer entry, or a `collect` request has no field-placement entry.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const cost = await client.assignments.estimateCost('doc-1', {
+     *   signers: [{ verification_method: 'Whatsapp' }],
+     * });
+     * // → wire body: { method: 'virtual', signers: [{ verification_method: 'Whatsapp' }] }
+     * if (!cost.has_sufficient_resources) console.warn(cost.blocking_reason);
+     * ```
+     */
+    estimateCost(documentId: string, payload: IEstimateAssignmentCostPayload): Promise<ICostEstimate>;
     /**
-     * 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.
+     * Update the expiration date of an existing assignment
+     * (`PUT /documents/{documentId}/assignments/{assignmentId}/reset-expiration`).
+     *
+     * Sends `{ expires_at }` verbatim. The official contract accepts an ISO-8601
+     * date/time string. `null` is retained as a live-unverified compatibility
+     * value used by older integrations and, unlike ordinary nullable inputs, is
+     * intentionally not stripped from the body.
+     *
+     * @param documentId - The document the assignment belongs to.
+     * @param assignmentId - The assignment to update.
+     * @param expiresAt - New expiry as an ISO-8601 date/time string. `null` is
+     * an unverified compatibility value intended to clear it.
+     * @returns The updated {@link IAssignment} — the same full shape
+     * {@link AssignmentResource.create} returns (`signers`, `items`, `summary`,
+     * `signing_urls`), with `expires_at` reflecting the new value:
+     * ```jsonc
+     * {
+     *   "id": "103033c9d2cec233bf65eea04999",
+     *   "sender_email": "sender@example.com",
+     *   "method": "virtual",
+     *   "expires_at": "2026-12-31T23:59:59Z",
+     *   "message": "Please sign this contract",
+     *   "copy_receivers": [],
+     *   "signers": [
+     *     {
+     *       "id": "19e6b92e7895332ed9708535d8c",
+     *       "full_name": "Ana Souza",
+     *       "email": "signer@example.com",
+     *       "completed": false,
+     *       "verification_method": "Email",
+     *       "notification_methods": ["Email"],
+     *       "step": 1,
+     *       "notified": true
+     *     }
+     *   ],
+     *   "summary": { "signer_count": 1, "completed_count": 0 },
+     *   "signing_urls": [
+     *     { "signer_id": "19e6b92e7895332ed9708535d8c", "url": "https://app-sandbox.assinafy.com.br/sign/103033c950d865a248a11c5cf96c" }
+     *   ]
+     * }
+     * ```
+     * @throws {ValidationError} If `documentId` or `assignmentId` is missing.
+     * @throws {ApiError} `400`/`404` if the assignment cannot be updated.
+     *
+     * @example
+     * ```ts
+     * // Extend the deadline …
+     * await client.assignments.resetExpiration('doc-1', 'asg-1', '2026-12-31T23:59:59Z');
+     * // … or remove it entirely (sends { expires_at: null }).
+     * await client.assignments.resetExpiration('doc-1', 'asg-1', null);
+     * ```
+     */
+    resetExpiration(documentId: string, assignmentId: string, expiresAt: string | null): Promise<IAssignment>;
+    /**
+     * Resend the signing notification to a single signer
+     * (`PUT /documents/{documentId}/assignments/{assignmentId}/signers/{signerId}/resend`).
+     *
+     * Sends no request body — the target is fully identified by the path. Use
+     * {@link AssignmentResource.estimateResendCost} first if you need to know
+     * whether the resend will consume credits.
+     *
+     * @param documentId - The document the assignment belongs to.
+     * @param assignmentId - The assignment containing the signer.
+     * @param signerId - The signer to re-notify.
+     * @returns An {@link IResendEmailResponse} confirming dispatch:
+     * ```jsonc
+     * {
+     *   "is_sent": true,
+     *   "document_id": "103acccd24234c07858ffddf6d84",
+     *   "signer_id": "19e6b92e7895332ed9708535d8c"
+     * }
+     * ```
+     * @throws {ValidationError} If any of the three IDs is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * await client.assignments.resendNotification('doc-1', 'asg-1', 'signer-1');
+     * ```
+     */
+    resendNotification(documentId: string, assignmentId: string, signerId: string): Promise<IResendEmailResponse>;
+    /**
+     * Estimate the cost of resending a signer notification
+     * (`POST /documents/{documentId}/assignments/{assignmentId}/signers/{signerId}/estimate-resend-cost`).
+     *
+     * Sends no request body. Pair it with
+     * {@link AssignmentResource.resendNotification} to gate a resend on
+     * available credit.
+     *
+     * @param documentId - The document the assignment belongs to.
+     * @param assignmentId - The assignment containing the signer.
+     * @param signerId - The signer whose notification would be resent.
+     * @returns An {@link IResendCostEstimate}. The published contract returns
+     * the full {@link ICostEstimate}; older deployments may return the compact
+     * `total` / `has_sufficient_credits` shape shown below:
+     * ```jsonc
+     * {
+     *   "total": 0,
+     *   "breakdown": [
+     *     { "code": "NotificationEmailResend", "name": "Email Notification Resend", "cost": 0 }
+     *   ],
+     *   "credit_balance": 0,
+     *   "has_sufficient_credits": true
+     * }
+     * ```
+     * @throws {ValidationError} If any of the three IDs is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const cost = await client.assignments.estimateResendCost('doc-1', 'asg-1', 'signer-1');
+     * const affordable = 'total_credits' in cost
+     *   ? cost.has_sufficient_resources
+     *   : cost.has_sufficient_credits;
+     * if (affordable) {
+     *   await client.assignments.resendNotification('doc-1', 'asg-1', 'signer-1');
+     * }
+     * ```
+     */
+    estimateResendCost(documentId: string, assignmentId: string, signerId: string): Promise<IResendCostEstimate>;
+    /**
+     * List every WhatsApp notification rendered + sent for an assignment
+     * (`GET /documents/{documentId}/assignments/{assignmentId}/whatsapp-notifications`).
+     *
+     * Returns the raw array (this endpoint is not paginated), so there is no
+     * `meta` — each entry is the rendered message the signer received.
+     *
+     * @param documentId - The document the assignment belongs to.
+     * @param assignmentId - The assignment whose WhatsApp notifications to list.
+     * @returns An array of {@link IWhatsAppNotification} (empty when the
+     * assignment used the email channel). Response shape:
+     * ```jsonc
+     * [
+     *   {
+     *     "sent_at": 1784145573,
+     *     "header": "Assinafy",
+     *     "body": "Você tem um documento para assinar.",
+     *     "buttons": [
+     *       { "text": "Assinar documento", "url": "https://app-sandbox.assinafy.com.br/sign/103033c950d865a248a11c5cf96c" }
+     *     ],
+     *     "phone_number": "+5511999998888",
+     *     "signer_id": "19e6b92e7895332ed9708535d8c"
+     *   }
+     * ]
+     * ```
+     * @throws {ValidationError} If `documentId` or `assignmentId` is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const notifications = await client.assignments.listWhatsAppNotifications('doc-1', 'asg-1');
+     * notifications.forEach((n) => console.log(n.phone_number, n.body));
+     * ```
+     */
+    listWhatsAppNotifications(documentId: string, assignmentId: string): Promise<IWhatsAppNotification[]>;
+}
+
+/**
+ * Default webhook events applied by {@link WebhookResource.register} when the
+ * caller omits `events` (or passes an empty array).
+ */
+declare const DEFAULT_WEBHOOK_EVENTS: readonly WebhookEventType[];
+declare class WebhookResource extends BaseResource {
+    /**
+     * Register (or replace) the workspace's single webhook subscription
+     * (`PUT /accounts/{accountId}/webhooks/subscriptions`). There is exactly one
+     * subscription per workspace, keyed by URL.
+     *
+     * When `events` is omitted or empty, {@link DEFAULT_WEBHOOK_EVENTS} is used
+     * (`document_ready`, `document_prepared`, `signer_signed_document`,
+     * `signer_rejected_document`, `document_processing_failed`).
+     *
+     * @param payload - Subscription details. `url` and `email` are required;
+     * `events` defaults to {@link DEFAULT_WEBHOOK_EVENTS} and `is_active`
+     * defaults to `true`.
+     * @param accountId - Override the client's default account ID.
+     * @returns The saved subscription. Response shape:
+     * ```jsonc
+     * {
+     *   "url": "https://example.com/hook",
+     *   "email": "ops@example.com",
+     *   "events": [
+     *     "document_ready",
+     *     "document_prepared",
+     *     "signer_signed_document",
+     *     "signer_rejected_document",
+     *     "document_processing_failed"
+     *   ],
+     *   "is_active": true,
+     *   "updated_at": "2026-07-18T02:36:02Z" // no `id` / `created_at` are returned
+     * }
+     * ```
+     * @throws {ValidationError} If `url` or `email` is missing.
+     * @throws {ApiError} If the API rejects the subscription.
+     *
+     * @example
+     * ```ts
+     * // Subscribe to a specific set of events:
+     * await client.webhooks.register({
+     *   url: 'https://example.com/hook',
+     *   email: 'ops@example.com',
+     *   events: ['signer_signed_document', 'document_ready'],
+     * });
+     *
+     * // Omit `events` to fall back to DEFAULT_WEBHOOK_EVENTS:
+     * await client.webhooks.register({ url: 'https://example.com/hook', email: 'ops@example.com' });
+     * ```
+     */
+    register(payload: IWebhookRegisterPayload, accountId?: string): Promise<IWebhookSubscription>;
+    /**
+     * Fetch the current webhook subscription
+     * (`GET /accounts/{accountId}/webhooks/subscriptions`).
+     *
+     * @param accountId - Override the client's default account ID.
+     * @returns The subscription, or `null` when the workspace has none (the API
+     * responds `404`, which is normalized to `null`). Response shape when
+     * present:
+     * ```jsonc
+     * {
+     *   "url": "https://hooks.zapier.com/hooks/standard/27880178/bbe9b90c.../",
+     *   "email": "ops@example.com",
+     *   "events": [
+     *     "document_ready",
+     *     "document_prepared"
+     *     // …5 more (7 total)
+     *   ],
+     *   "is_active": false,
+     *   "updated_at": "2026-07-18T02:36:02Z"
+     * }
+     * ```
+     * @throws {ApiError} If the API fails for a reason other than `404`.
+     *
+     * @example
+     * ```ts
+     * const sub = await client.webhooks.get();
+     * if (sub === null) {
+     *   // no subscription configured yet
+     * } else if (!sub.is_active) {
+     *   // exists but deliveries are paused
+     * }
+     * ```
+     */
+    get(accountId?: string): Promise<IWebhookSubscription | null>;
+    /**
+     * Inactivate the current webhook subscription
+     * (`PUT /accounts/{accountId}/webhooks/inactivate`).
+     *
+     * 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`.
+     *
+     * @param accountId - Override the client's default account ID.
+     * @returns The subscription with `is_active` flipped to `false`. Response
+     * shape:
+     * ```jsonc
+     * {
+     *   "url": "https://example.com/hook",
+     *   "email": "ops@example.com",
+     *   "events": [
+     *     "document_ready",
+     *     "document_prepared",
+     *     "signer_signed_document",
+     *     "signer_rejected_document",
+     *     "document_processing_failed"
+     *   ],
+     *   "is_active": false,
+     *   "updated_at": "2026-07-18T02:36:02Z"
+     * }
+     * ```
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const sub = await client.webhooks.inactivate();
+     * console.log(sub.is_active); // false
+     * ```
+     */
+    inactivate(accountId?: string): Promise<IWebhookSubscription>;
+    /**
+     * List currently supported webhook event types
+     * (`GET /webhooks/event-types`). This is a global, account-independent
+     * catalog.
+     *
+     * @returns The full list of event types with human-readable descriptions.
+     * Live, the API returns exactly 15 entries (in this order):
+     * `document_uploaded`, `document_metadata_ready`, `document_prepared`,
+     * `assignment_created`, `signature_requested`, `document_ready`,
+     * `signer_created`, `signer_email_verified`, `signer_whatsapp_verified`,
+     * `signer_data_confirmed`, `signer_signed_document`, `signer_viewed_document`,
+     * `signer_rejected_document`, `user_rejected_document`,
+     * `document_processing_failed`. Response shape:
+     * ```jsonc
+     * [
+     *   {
+     *     "id": "document_uploaded",
+     *     "description": "Triggered when the User has uploaded a Document"
+     *   },
+     *   {
+     *     "id": "document_metadata_ready",
+     *     "description": "Triggered when the document is ready to be prepared. The document has been normalized to PDF and its pages are available."
+     *   }
+     *   // …13 more (15 total)
+     * ]
+     * ```
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const types = await client.webhooks.listEventTypes();
+     * const ids = types.map((t) => t.id);
+     * ```
+     */
+    listEventTypes(): Promise<IWebhookEventTypeInfo[]>;
+    /**
+     * List webhook delivery history for the workspace
+     * (`GET /accounts/{accountId}/webhooks`). Pagination info (if any) is
+     * attached in `meta`.
+     *
+     * @param params - Optional filters and pagination:
+     *   - `event` — restrict to a single {@link WebhookEventType}
+     *     (e.g. `'signer_signed_document'`).
+     *   - `delivered` — `true`/`false` to filter by delivery success.
+     *   - `from` / `to` — Unix epoch seconds bounding `created_at`.
+     *   - `page` — 1-based page number.
+     *   - `per-page` — page size (`per_page` is normalized to `per-page`).
+     * @param accountId - Override the client's default account ID.
+     * @returns Delivery records, with pagination in `meta`. Each item:
+     * ```jsonc
+     * {
+     *   "id": "103a09cfce51319dd3b3f72ffcdf",
+     *   "event": "signature_requested",
+     *   "activity_id": 8629,
+     *   "endpoint": "https://example.com/hook",
+     *   "payload": {
+     *     // the full event body that was POSTed to `endpoint`:
+     *     // { id, event, object: <document + assignment>, origin, message,
+     *     //   payload: { signer_email, signer_full_name, notification_method, ... },
+     *     //   subject: <User>, account_id, created_at }
+     *   },
+     *   "delivered": true,
+     *   "http_status": 200,
+     *   "response_body": "{ ... }", // body returned by the receiving endpoint
+     *   "error": null,
+     *   "created_at": "2026-07-15T20:04:36Z",
+     *   "updated_at": "2026-07-15T20:04:36Z"
+     * }
+     * ```
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * // Only failed deliveries, newest page first:
+     * const { data, meta } = await client.webhooks.listDispatches({
+     *   delivered: false,
+     *   'per-page': 20,
+     * });
+     * for (const dispatch of data) {
+     *   if (!dispatch.delivered) await client.webhooks.retryDispatch(dispatch.id);
+     * }
+     * ```
+     */
+    listDispatches(params?: IWebhookDispatchListParams, accountId?: string): Promise<PaginatedResult<IWebhookDispatch>>;
+    /**
+     * Retry delivery of a specific webhook dispatch
+     * (`POST /accounts/{accountId}/webhooks/{historyId}/retry`). Re-sends the
+     * original payload to the subscription's endpoint.
+     *
+     * @param dispatchId - The dispatch (delivery history) ID to re-send, as
+     * returned by {@link WebhookResource.listDispatches}.
+     * @param accountId - Override the client's default account ID.
+     * @returns A newly created delivery-history record for the retry attempt;
+     * its ID is distinct from the original dispatch. Response
+     * shape:
+     * ```jsonc
+     * {
+     *   "id": "103a09cfce51319dd3b3f72ffcdf",
+     *   "event": "signature_requested",
+     *   "activity_id": 8629,
+     *   "endpoint": "https://example.com/hook",
+     *   "payload": { }, // the original event body that was re-POSTed
+     *   "delivered": true,
+     *   "http_status": 200,
+     *   "response_body": "{ ... }",
+     *   "error": null,
+     *   "created_at": "2026-07-15T20:04:36Z",
+     *   "updated_at": "2026-07-15T20:05:10Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `dispatchId` is empty.
+     * @throws {ApiError} If the dispatch is not found (`404`) or the retry fails.
+     *
+     * @example
+     * ```ts
+     * const dispatch = await client.webhooks.retryDispatch('103a09cfce51319dd3b3f72ffcdf');
+     * console.log(dispatch.delivered);
+     * ```
+     */
+    retryDispatch(dispatchId: string, accountId?: string): Promise<IWebhookDispatch>;
+}
+
+/**
+ * Live-API compatibility endpoints for managing reusable templates.
+ *
+ * These CRUD routes are operational in the Assinafy sandbox but are not
+ * described by the current published OpenAPI document. They are retained for
+ * compatibility and should be integration-tested against the target Assinafy
+ * environment before a production rollout.
+ */
+declare class TemplateResource extends BaseResource {
+    /**
+     * Create a template by uploading a PDF (`POST /accounts/{id}/templates`).
+     *
+     * The template is created in `Uploaded` status and transitions to `Ready`
+     * once the platform finishes processing its pages (`pages` stays empty until
+     * then). Configure roles/fields afterwards in the Assinafy editor. As with
+     * document uploads, the API derives the display name from the file part's
+     * filename, so `options.name` is applied as the (`.pdf`-suffixed) filename
+     * rather than a separate form field.
+     *
+     * @param source - The PDF to upload, as a file path or an in-memory buffer.
+     * @param options - `name` (display name) and an optional `accountId` override.
+     * @returns The created template (envelope unwrapped). Response shape:
+     * ```jsonc
+     * {
+     *   "resource": "template",
+     *   "id": "103ad2171db7979468c3e97eb067",
+     *   "name": "NDA template.pdf",
+     *   "document_name": "NDA template.pdf",
+     *   "message": null,
+     *   "status": "Uploaded",
+     *   "pages": [],
+     *   "roles": [
+     *     {
+     *       "id": "19f7b68b811f8d1e1aeaf11178e",
+     *       "name": "TemplateEditor",
+     *       "assignment_type": "Editor",
+     *       "created_at": "2026-07-19T17:24:48Z",
+     *       "updated_at": "2026-07-19T17:24:48Z"
+     *     }
+     *   ],
+     *   "tags": [],
+     *   "created_at": "2026-07-19T17:24:47Z",
+     *   "updated_at": "2026-07-19T17:24:48Z"
+     * }
+     * ```
+     * @throws {ValidationError} If the file is empty, not a `.pdf`, exceeds
+     * 25 MB, no account ID is available, or the API returns no template ID.
+     * @throws {ApiError} If the API rejects the upload.
+     *
+     * @example
+     * ```ts
+     * const tmpl = await client.templates.create(
+     *   { filePath: './nda.pdf' },
+     *   { name: 'NDA template' },
+     * );
+     * // → status: 'Uploaded'; name stored as 'NDA template.pdf'
+     * ```
+     */
+    create(source: DocumentUploadSource, options?: {
+        name?: string;
+        accountId?: string;
+    }): Promise<ITemplateDetailsResponse>;
+    /**
+     * List templates for the workspace (`GET /accounts/{id}/templates`).
+     *
+     * Pagination lives in the response **headers** and is surfaced on `meta`.
+     * Each item is an {@link ITemplateListItem} carrying `pages[]` (each with a
+     * `download_url`), so there is no need to `get()` a template again just to
+     * read its rendered pages.
+     *
+     * @param params - `search`, `page`, and `per-page` (the SDK normalizes
+     * `per_page` → `per-page`, the only spelling the API honors).
+     * @param accountId - Override the client's default account ID.
+     * @returns Matching templates, with pagination in `meta`. Each item:
+     * ```jsonc
+     * {
+     *   "id": "103ad2171db7979468c3e97eb067",
+     *   "name": "NDA template.pdf",
+     *   "document_name": "nda.pdf",
+     *   "message": null,
+     *   "status": "Ready",
+     *   "pages": [
+     *     {
+     *       "id": "103ad217673e1f978cb86179e8f8",
+     *       "number": 1,
+     *       "height": 1651,
+     *       "width": 1275,
+     *       "download_url": "https://api.assinafy.com.br/v1/accounts/…/templates/…/pages/…/download",
+     *       "fields": []
+     *     }
+     *   ],
+     *   "roles": [
+     *     { "id": "19f7b68b811f8d1e1aeaf11178e", "name": "TemplateEditor", "assignment_type": "Editor" }
+     *   ],
+     *   "tags": [],
+     *   "created_at": "2026-07-19T17:24:47Z",
+     *   "updated_at": "2026-07-19T17:24:51Z"
+     * }
+     * ```
+     * @throws {ValidationError} If no account ID is available.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const { data, meta } = await client.templates.list({ search: 'nda', 'per-page': 20 });
+     * ```
+     */
+    list(params?: IListParams, accountId?: string): Promise<ITemplateListResponse>;
+    /**
+     * Get a template by ID (`GET /accounts/{id}/templates/{template_id}`).
+     *
+     * 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.
+     *
+     * @param templateId - The template to fetch.
+     * @param accountId - Override the client's default account ID.
+     * @returns The full template. Response shape (`status: 'Ready'`):
+     * ```jsonc
+     * {
+     *   "resource": "template",
+     *   "id": "103ad2171db7979468c3e97eb067",
+     *   "name": "NDA template.pdf",
+     *   "document_name": "nda.pdf",
+     *   "message": null,
+     *   "status": "Ready",
+     *   "pages": [
+     *     {
+     *       "id": "103ad217673e1f978cb86179e8f8",
+     *       "number": 1,
+     *       "height": 1651,
+     *       "width": 1275,
+     *       "download_url": "https://api.assinafy.com.br/v1/accounts/…/templates/…/pages/…/download",
+     *       "fields": []
+     *     }
+     *   ],
+     *   "roles": [
+     *     {
+     *       "id": "19f7b68b811f8d1e1aeaf11178e",
+     *       "name": "TemplateEditor",
+     *       "assignment_type": "Editor",
+     *       "created_at": "2026-07-19T17:24:48Z",
+     *       "updated_at": "2026-07-19T17:24:48Z"
+     *     }
+     *   ],
+     *   "tags": [],
+     *   "created_at": "2026-07-19T17:24:47Z",
+     *   "updated_at": "2026-07-19T17:24:51Z",
+     *   "default_document_tags": []
+     * }
+     * ```
+     * @throws {ValidationError} If `templateId` is missing or no account ID is available.
+     * @throws {ApiError} `404` if the template does not exist.
+     *
+     * @example
+     * ```ts
+     * const tmpl = await client.templates.get('103ad2171db7979468c3e97eb067');
+     * if (tmpl.status === 'Ready') console.log(tmpl.pages.length);
+     * ```
+     */
+    get(templateId: string, accountId?: string): Promise<ITemplateDetailsResponse>;
+    /**
+     * Update a template's `name` and/or default `message`
+     * (`PUT /accounts/{id}/templates/{template_id}`).
+     *
+     * `message` is the default invitation message applied to documents created
+     * from this template. Omit a field to leave it unchanged — the SDK strips
+     * `undefined` keys before sending. Unlike uploads, `name` here is a plain
+     * display name and is **not** forced to end in `.pdf`.
+     *
+     * @param templateId - The template to update.
+     * @param payload - `name` and/or `message`; both optional.
+     * @param accountId - Override the client's default account ID.
+     * @returns The updated template (full details, same shape as
+     * {@link TemplateResource.get}). Response shape:
+     * ```jsonc
+     * {
+     *   "resource": "template",
+     *   "id": "103ad2171db7979468c3e97eb067",
+     *   "name": "NDA v2",
+     *   "document_name": "nda.pdf",
+     *   "message": "Please sign",
+     *   "status": "Ready",
+     *   "pages": [
+     *     { "id": "103ad217673e1f978cb86179e8f8", "number": 1, "height": 1651, "width": 1275, "download_url": "https://api.assinafy.com.br/v1/…/download", "fields": [] }
+     *   ],
+     *   "roles": [
+     *     { "id": "19f7b68b811f8d1e1aeaf11178e", "name": "TemplateEditor", "assignment_type": "Editor" }
+     *   ],
+     *   "tags": [],
+     *   "created_at": "2026-07-19T17:24:47Z",
+     *   "updated_at": "2026-07-19T17:24:52Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `templateId` is missing or no account ID is available.
+     * @throws {ApiError} `404` if the template does not exist; `400` on an invalid payload.
+     *
+     * @example
+     * ```ts
+     * await client.templates.update(templateId, { name: 'NDA v2', message: 'Please sign' });
+     * ```
+     */
+    update(templateId: string, payload: IUpdateTemplatePayload, accountId?: string): Promise<ITemplateDetailsResponse>;
+    /**
+     * Delete a template (`DELETE /accounts/{id}/templates/{template_id}`).
+     *
+     * The API responds with an empty `data` payload; this method resolves to
+     * `void`.
+     *
+     * @param templateId - The template to delete.
+     * @param accountId - Override the client's default account ID.
+     * @returns Nothing (`Promise<void>`) on success.
+     * @throws {ValidationError} If `templateId` is missing or no account ID is available.
+     * @throws {ApiError} `404` if the template does not exist.
+     *
+     * @example
+     * ```ts
+     * await client.templates.delete('103ad2171db7979468c3e97eb067');
+     * ```
+     */
+    delete(templateId: string, accountId?: string): Promise<void>;
+    /**
+     * Download a template page as a JPEG
+     * (`GET /accounts/{id}/templates/{template_id}/pages/{page_id}/download`).
+     *
+     * Used by template editors to render page thumbnails on the client. The
+     * matching `download_url` is also returned on each `template.pages[]` entry,
+     * so if you already hold the template you can fetch that URL directly.
+     *
+     * @param templateId - The template that owns the page.
+     * @param pageId - The page to download (`pages[].id` from `get()`/`list()`).
+     * @param accountId - Override the client's default account ID.
+     * @returns The page rendering as a {@link Buffer} of JPEG bytes.
+     * @throws {ValidationError} If `templateId` or `pageId` is missing, or no
+     * account ID is available.
+     * @throws {ApiError} `404` if the template or page does not exist.
+     *
+     * @example
+     * ```ts
+     * const tmpl = await client.templates.get('103ad2171db7979468c3e97eb067');
+     * const jpeg = await client.templates.downloadPage(tmpl.id, tmpl.pages[0].id);
+     * await fs.writeFile('page-1.jpg', jpeg);
+     * ```
+     */
+    downloadPage(templateId: string, pageId: string, accountId?: string): Promise<Buffer>;
+}
+
+/**
+ * Workspace-scoped tags used to label documents and templates.
+ *
+ * Covers the full Tag section of the API docs:
+ *  - `GET    /accounts/{id}/tags`            → {@link list}
+ *  - `POST   /accounts/{id}/tags`            → {@link create}
+ *  - `PUT    /accounts/{id}/tags/{tag_id}`   → {@link update}
+ *  - `DELETE /accounts/{id}/tags/{tag_id}`   → {@link delete}
+ *
+ * Document-level attach/detach lives on {@link DocumentResource} (`listTags`,
+ * `replaceTags`, `addTags`, `detachTag`).
+ */
+declare class TagResource extends BaseResource {
+    /**
+     * List the workspace's tags (`GET /accounts/{accountId}/tags`).
+     *
+     * Tags come back ordered alphabetically by name. Pass an optional
+     * case-insensitive `search` substring to filter by name.
+     *
+     * @param params - Optional filters. `search` matches tag names
+     * case-insensitively (substring).
+     * @param accountId - Override the client's default account ID.
+     * @returns The matching tags (list items carry no `resource` field):
+     * ```jsonc
+     * [
+     *   {
+     *     "id": "103aa221874346e6b3de41688526",
+     *     "name": "Contracts",
+     *     "color": "ff8800",              // 6-char hex, no leading '#'
+     *     "created_at": "2026-07-18T19:03:45Z",
+     *     "updated_at": "2026-07-18T19:03:45Z"
+     *   },
+     *   {
+     *     "id": "103aa252123d3bf1843a317ee0e6",
+     *     "name": "Invoices",
+     *     "color": null,                  // no color set
+     *     "created_at": "2026-07-18T19:09:03Z",
+     *     "updated_at": "2026-07-18T19:09:03Z"
+     *   }
+     * ]
+     * ```
+     * @throws {ValidationError} If no account ID is available.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const all = await client.tags.list();
+     * const contracts = await client.tags.list({ search: 'contract' });
+     * ```
+     */
+    list(params?: {
+        search?: string;
+    }, accountId?: string): Promise<ITag[]>;
+    /**
+     * Create a tag (`POST /accounts/{accountId}/tags`).
+     *
+     * `color` is an optional 6-char hex string; the API accepts it **with or
+     * without** a leading `#` and always stores it **without** — `'#ff8800'`
+     * and `'ff8800'` both persist as `'ff8800'` (verified live). Omit `color`
+     * (or pass `null`) for no color.
+     *
+     * @param payload - `name` (required) and optional `color`.
+     * @param accountId - Override the client's default account ID.
+     * @returns The created tag:
+     * ```jsonc
+     * {
+     *   "resource": "tag",
+     *   "id": "103ad216fdc641c8f0465678c813",
+     *   "name": "Contracts",
+     *   "color": "ff8800",
+     *   "created_at": "2026-07-19T17:24:46Z",
+     *   "updated_at": "2026-07-19T17:24:46Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `name` is empty, or no account ID is available.
+     * @throws {ApiError} `409` if a tag with the same name already exists
+     * (case-insensitive).
+     *
+     * @example
+     * ```ts
+     * const tag = await client.tags.create({ name: 'Contracts', color: '#ff8800' });
+     * // → tag.color === 'ff8800'  (the leading '#' is stripped by the API)
+     * ```
+     */
+    create(payload: ICreateTagPayload, accountId?: string): Promise<ITag>;
+    /**
+     * Update a tag's name and/or color (`PUT /accounts/{accountId}/tags/{tagId}`).
+     *
+     * Omit a field to leave it unchanged. Pass `color: null` to clear the color
+     * — that `null` is sent in the request body as the documented "clear color"
+     * signal (an omitted `color` is not sent at all). As with {@link create}, a
+     * leading `#` on `color` is accepted and stripped by the API
+     * (`'#112233'` → `'112233'`).
+     *
+     * @param tagId - The tag to update.
+     * @param payload - `name` and/or `color`. `color: null` clears the color;
+     * omit a field to leave it unchanged.
+     * @param accountId - Override the client's default account ID.
+     * @returns The updated tag:
+     * ```jsonc
+     * {
+     *   "resource": "tag",
+     *   "id": "103ad216fdc641c8f0465678c813",
+     *   "name": "Contracts",
+     *   "color": "112233",
+     *   "created_at": "2026-07-19T17:24:46Z",
+     *   "updated_at": "2026-07-19T17:24:47Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `tagId` is missing, or no account ID is available.
+     * @throws {ApiError} `404` if the tag does not exist; `409` if another tag
+     * already uses the new name.
+     *
+     * @example
+     * ```ts
+     * // rename + recolor
+     * await client.tags.update('103ad216fdc641c8f0465678c813', {
+     *   name: 'Signed contracts',
+     *   color: '112233',
+     * });
+     * // clear the color, keep the name
+     * await client.tags.update('103ad216fdc641c8f0465678c813', { color: null });
+     * ```
+     */
+    update(tagId: string, payload: IUpdateTagPayload, accountId?: string): Promise<ITag>;
+    /**
+     * Delete a tag (`DELETE /accounts/{accountId}/tags/{tagId}`).
+     *
+     * By default the API returns `409` if the tag is still attached to any
+     * document or template. Pass `{ force: true }` to detach it everywhere
+     * first — that adds a `?force=true` query param. Resolves to `void` on
+     * success (the endpoint's `{ "deleted": true }` body is discarded).
+     *
+     * @param tagId - The tag to delete.
+     * @param options - `force` to detach-and-delete when the tag is still in
+     * use, and `accountId` to override the client's default account ID.
+     * @returns Nothing; resolves once the tag is deleted.
+     * @throws {ValidationError} If `tagId` is missing, or no account ID is available.
+     * @throws {ApiError} `404` if the tag does not exist; `409` if the tag is
+     * still in use and `force` was not set.
+     *
+     * @example
+     * ```ts
+     * await client.tags.delete('103ad216fdc641c8f0465678c813');
+     * // detach from every document/template, then delete
+     * await client.tags.delete('103ad216fdc641c8f0465678c813', { force: true });
+     * ```
+     */
+    delete(tagId: string, options?: {
+        force?: boolean;
+        accountId?: string;
+    }): Promise<void>;
+}
+
+/**
+ * Authentication endpoints (login, social login, password management) and
+ * personal API key management (`/users/api-keys`).
+ *
+ * Most of these endpoints are intended to bootstrap an authenticated session
+ * for a human user. Production server-to-server integrations should use
+ * `X-Api-Key` and skip this resource entirely.
+ */
+declare class AuthenticationResource extends BaseResource {
+    private readonly publicHttp;
+    constructor(http: AxiosInstance, defaultAccountId?: string, logger?: Logger, publicHttp?: AxiosInstance);
+    /**
+     * Build the browser-facing OAuth start URL
+     * (`GET /auth/authenticate?authclient=…`).
+     *
+     * This endpoint responds with `302` to the provider consent screen, so the
+     * SDK returns the URL for your web framework to redirect to instead of
+     * following the redirect inside the Node process.
+     *
+     * @param authClient - Provider key; currently `google`.
+     * @returns An absolute URL, for example
+     * `https://api.assinafy.com.br/v1/auth/authenticate?authclient=google`.
+     * @throws {ValidationError} If `authClient` is empty.
+     *
+     * @example
+     * ```ts
+     * response.redirect(client.auth.getSocialLoginUrl('google'));
+     * ```
+     */
+    getSocialLoginUrl(authClient?: 'google' | AnyString): string;
+    /**
+     * Return the Assinafy browser callback URL (`GET /login-callback`).
+     *
+     * The callback response payload is intentionally unspecified by the API;
+     * OAuth providers call it in a browser. Use this URL when a provider setup
+     * asks for Assinafy's callback/redirect URI.
+     *
+     * @returns The absolute Assinafy callback URL for the configured API host.
+     *
+     * @example
+     * ```ts
+     * console.log(client.auth.getSocialLoginCallbackUrl());
+     * ```
+     */
+    getSocialLoginCallbackUrl(): string;
+    /**
+     * Log in with email + password (`POST /login`).
+     *
+     * Exchanges credentials for a JWT `access_token` plus the authenticated
+     * user and the accounts they can act on. The token authenticates
+     * subsequent requests; long-lived integrations should prefer an
+     * `X-Api-Key` (see {@link AuthenticationResource.createApiKey}) instead of
+     * storing a password.
+     *
+     * @param email - The user's email address, e.g. `'user@example.com'`.
+     * @param password - The user's password.
+     * @returns An {@link ILoginResponse} with the access token, user, and
+     * accounts. Response shape:
+     * ```jsonc
+     * {
+     *   "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9…",
+     *   "user": {
+     *     "id": "md3j6p9w8b7y6qvqaoy5er42",
+     *     "name": "Multica Test",
+     *     "email": "user@example.com",
+     *     "telephone": null,
+     *     "government_id": "",
+     *     "is_email_verified": true,
+     *     "has_accepted_terms": true,
+     *     "created_at": "2026-05-12T13:45:11Z",
+     *     "to_be_deleted_at": null
+     *   },
+     *   "accounts": [
+     *     {
+     *       "id": "acc_example",
+     *       "name": "Multica Test",
+     *       "roles": ["Owner"],
+     *       "is_delete_allowed": true,
+     *       "created_at": "2026-05-12T13:45:11Z"
+     *     }
+     *   ]
+     * }
+     * ```
+     * @throws {ValidationError} If `email` or `password` is missing.
+     * @throws {ApiError} `400` if the credentials are rejected.
+     *
+     * @example
+     * ```ts
+     * const { access_token, accounts } = await client.auth.login(
+     *   'user@example.com',
+     *   's3cret',
+     * );
+     * ```
+     */
+    login(email: string, password: string): Promise<ILoginResponse>;
+    /**
+     * Log in with a social provider (`POST /authentication/social-login`).
+     *
+     * Exchanges a provider-issued OAuth token (currently Google) for an
+     * Assinafy JWT. Returns the same {@link ILoginResponse} shape as
+     * {@link AuthenticationResource.login}.
+     *
+     * @param payload - The social-login body.
+     * @param payload.provider - OAuth provider. The API currently accepts
+     * `'google'`; the type is left open for forward-compatibility.
+     * @param payload.token - The provider-issued OAuth/ID token.
+     * @param payload.has_accepted_terms - Whether the user has accepted the
+     * terms of service.
+     * @returns An {@link ILoginResponse} with the access token, user, and
+     * accounts. Response shape:
+     * ```jsonc
+     * {
+     *   "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9…",
+     *   "user": {
+     *     "id": "md3j6p9w8b7y6qvqaoy5er42",
+     *     "name": "Multica Test",
+     *     "email": "user@example.com",
+     *     "is_email_verified": true,
+     *     "has_accepted_terms": true
+     *   },
+     *   "accounts": [
+     *     {
+     *       "id": "acc_example",
+     *       "name": "Multica Test",
+     *       "roles": ["Owner"],
+     *       "is_delete_allowed": true,
+     *       "created_at": "2026-05-12T13:45:11Z"
+     *     }
+     *   ]
+     * }
+     * ```
+     * @throws {ValidationError} If `provider` or `token` is missing.
+     * @throws {ApiError} `400` if the provider token is rejected.
+     *
+     * @example
+     * ```ts
+     * const session = await client.auth.socialLogin({
+     *   provider: 'google',
+     *   token: googleIdToken,
+     *   has_accepted_terms: true,
+     * });
+     * ```
+     */
+    socialLogin(payload: {
+        /** OAuth provider. The API currently accepts `google`; typed open for forward-compat. */
+        provider: 'google' | AnyString;
+        token: string;
+        has_accepted_terms: boolean;
+    }): Promise<ILoginResponse>;
+    /**
+     * Link a Google identity to the authenticated user
+     * (`POST /auth/link-social-login`).
+     *
+     * Request body:
+     * ```jsonc
+     * { "provider": "google", "token": "provider-issued-token" }
+     * ```
+     * The response is the standard status/message acknowledgement with no data,
+     * so this method resolves to `void`.
+     *
+     * @param payload - Social provider and provider-issued access/ID token.
+     * @returns Resolves when the API acknowledges that the identity was linked.
+     * @throws {ValidationError} If either field is empty.
+     * @throws {ApiError} `400` for an invalid provider token or `401` for
+     * missing/invalid Assinafy credentials.
+     *
+     * @example
+     * ```ts
+     * await client.auth.linkSocialLogin({
+     *   provider: 'google',
+     *   token: googleIdToken,
+     * });
+     * ```
+     */
+    linkSocialLogin(payload: {
+        provider: 'google' | AnyString;
+        token: string;
+    }): Promise<void>;
+    /**
+     * Create (or rotate) the current user's API key (`POST /users/api-keys`).
+     *
+     * Returns the **full, unmasked** key exactly once — store it securely, as
+     * subsequent reads via {@link AuthenticationResource.getApiKey} only return
+     * a masked value. Calling this again rotates the key, invalidating the
+     * previous one.
+     *
+     * @param password - The current user's password, required to authorize
+     * key generation.
+     * @returns An {@link IApiKeyResponse} containing the new key. Response
+     * shape:
+     * ```jsonc
+     * {
+     *   "api_key": "Hf8s2Jd9KpQ1mZ4xVn7bLcR3tWy6aEu0oCiSgBvNEWq"
+     * }
+     * ```
+     * @throws {ValidationError} If `password` is missing.
+     * @throws {ApiError} If the API rejects the request (e.g. wrong password).
+     *
+     * @example
+     * ```ts
+     * const { api_key } = await client.auth.createApiKey('s3cret');
+     * if (!api_key) throw new Error('API returned no generated key');
+     * // Persist api_key now — it is not retrievable unmasked later.
+     * ```
+     */
+    createApiKey(password: string): Promise<IApiKeyResponse>;
+    /**
+     * Fetch a masked view of the current API key (`GET /users/api-keys`).
+     *
+     * Only the last few characters are revealed; the leading characters are
+     * masked with asterisks. The documented no-key form is
+     * `{ api_key: null }`; older deployments may return `null` for the entire
+     * data value.
+     * The unmasked key is only ever returned by
+     * {@link AuthenticationResource.createApiKey}.
+     *
+     * @returns An {@link IMaskedApiKeyResponse}: `{ api_key }` with a masked
+     * string or `null`, or the legacy top-level `null`. Response shape:
+     * ```jsonc
+     * {
+     *   "api_key": "************************************************************NEWq"
+     * }
+     * ```
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const masked = await client.auth.getApiKey();
+     * if (masked?.api_key) console.log('Key ends with', masked.api_key.slice(-4));
+     * else console.log('No API key generated yet');
+     * ```
+     */
+    getApiKey(): Promise<IMaskedApiKeyResponse>;
+    /**
+     * Revoke the current API key (`DELETE /users/api-keys`).
+     *
+     * After this call any existing `X-Api-Key` using the deleted key stops
+     * working; generate a new one with
+     * {@link AuthenticationResource.createApiKey}.
+     *
+     * @returns Nothing; resolves once the key is revoked.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * await client.auth.deleteApiKey();
+     * ```
+     */
+    deleteApiKey(): Promise<void>;
+    /**
+     * Change the authenticated user's password
+     * (`PUT /authentication/change-password`).
+     *
+     * Requires the current password as a confirmation. On success the API
+     * echoes back the affected `email`.
+     *
+     * @param payload - The change-password body.
+     * @param payload.email - The user's email address.
+     * @param payload.password - The current password.
+     * @param payload.new_password - The new password to set.
+     * @returns `{ email }` — the address whose password was changed. Response
+     * shape:
+     * ```jsonc
+     * {
+     *   "email": "user@example.com"
+     * }
+     * ```
+     * @throws {ValidationError} If `email`, `password`, or `new_password` is
+     * missing.
+     * @throws {ApiError} `400`/`401` if the current password is wrong or the
+     * new password is rejected.
+     *
+     * @example
+     * ```ts
+     * await client.auth.changePassword({
+     *   email: 'user@example.com',
+     *   password: 'old-s3cret',
+     *   new_password: 'new-s3cret',
+     * });
+     * ```
+     */
+    changePassword(payload: {
+        email: string;
+        password: string;
+        new_password: string;
+    }): Promise<{
+        email: string;
+    }>;
+    /**
+     * Request a password-reset email
+     * (`PUT /authentication/request-password-reset`).
+     *
+     * Triggers Assinafy to email a reset link/token to the given address.
+     * Complete the flow with {@link AuthenticationResource.resetPassword}.
+     *
+     * @param email - The email address to send the reset link to.
+     * @returns `{ email }` — the address the reset link was sent to. Response
+     * shape:
+     * ```jsonc
+     * {
+     *   "email": "user@example.com"
+     * }
+     * ```
+     * @throws {ValidationError} If `email` is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * await client.auth.requestPasswordReset('user@example.com');
+     * ```
+     */
+    requestPasswordReset(email: string): Promise<{
+        email: string;
+    }>;
+    /**
+     * Complete a password reset using the emailed token
+     * (`PUT /authentication/reset-password`).
+     *
+     * Consumes the token delivered by
+     * {@link AuthenticationResource.requestPasswordReset} and sets the new
+     * password. On success the API echoes back the affected `email`.
+     *
+     * @param payload - The reset-password body.
+     * @param payload.email - The user's email address.
+     * @param payload.token - The reset token from the emailed link.
+     * @param payload.new_password - The new password to set.
+     * @returns `{ email }` — the address whose password was reset. Response
+     * shape:
+     * ```jsonc
+     * {
+     *   "email": "user@example.com"
+     * }
+     * ```
+     * @throws {ValidationError} If `email` or `new_password` is missing.
+     * @throws {ApiError} `400` if the token is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * await client.auth.resetPassword({
+     *   email: 'user@example.com',
+     *   token: 'reset-token-from-email',
+     *   new_password: 'new-s3cret',
+     * });
+     * ```
+     */
+    resetPassword(payload: {
+        email: string;
+        token?: string;
+        new_password: string;
+    }): Promise<{
+        email: string;
+    }>;
+    private absoluteUrl;
+}
+
+/**
+ * Custom field definitions used by `collect` assignments.
+ *
+ * Covers the full Field Definition section of the API docs:
+ *  - `POST /accounts/{id}/fields`
+ *  - `GET /accounts/{id}/fields`
+ *  - `GET /accounts/{id}/fields/{id}`
+ *  - `PUT /accounts/{id}/fields/{id}`
+ *  - `DELETE /accounts/{id}/fields/{id}`
+ *  - `POST /accounts/{id}/fields/{id}/validate?signer-access-code=…`
+ *  - `POST /accounts/{id}/fields/validate-multiple?signer-access-code=…`
+ *  - `GET /field-types`
+ */
+declare class FieldsResource extends BaseResource {
+    /**
+     * Create a field definition (`POST /accounts/{accountId}/fields`).
+     *
+     * @param payload - The field to create. `type` and `name` are required;
+     *   `type` must be one of the platform field types (see
+     *   {@link FieldsResource.listTypes}); `regex` may be a string or `null`,
+     *   and `is_required` is optional. `is_active` is a tested live extension.
+     * @param accountId - Override the client's default account ID.
+     * @returns The created field definition. Response shape:
+     * ```jsonc
+     * {
+     *   "resource": "field_definition",
+     *   "id": "103ad21709d15eca8c48085b5b8f",
+     *   "name": "Employee CPF",
+     *   "type": "cpf",
+     *   "regex": null,
+     *   "is_pre_defined": false,
+     *   "is_active": true,
+     *   "is_required": true,
+     *   "is_standard": false,
+     *   "is_read_only": false,
+     *   "is_visible": true
+     * }
+     * ```
+     * @throws {ValidationError} If `type` or `name` is missing, or no account
+     * ID is available.
+     * @throws {ApiError} If the API rejects the request (e.g. `400` invalid type).
+     *
+     * @example
+     * ```ts
+     * const field = await client.fields.create({
+     *   name: 'Employee CPF',
+     *   type: 'cpf',
+     *   is_required: true,
+     * });
+     * ```
+     */
+    create(payload: ICreateFieldPayload, accountId?: string): Promise<IFieldDefinition>;
+    /**
+     * List field definitions for the workspace
+     * (`GET /accounts/{accountId}/fields`).
+     *
+     * @param params - Filters.
+     * @param params.include_inactive - Return inactive fields too.
+     * @param params.include_standard - Also return the built-in standard fields
+     *   (`signature`, `initial`, `signatureDate`).
+     * @param accountId - Override the client's default account ID.
+     * @returns The field definitions (a plain array — this endpoint is not
+     * paginated). Each item:
+     * ```jsonc
+     * {
+     *   "id": "field-example",
+     *   "name": "CPF",
+     *   "type": "cpf",
+     *   "regex": null,
+     *   "is_pre_defined": true,
+     *   "is_active": true,
+     *   "is_required": false,
+     *   "is_standard": false,
+     *   "is_read_only": false,
+     *   "is_visible": true
+     * }
+     * ```
+     * @throws {ValidationError} If no account ID is available.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const fields = await client.fields.list({ include_standard: true });
+     * ```
+     */
+    list(params?: {
+        include_inactive?: boolean;
+        include_standard?: boolean;
+    }, accountId?: string): Promise<IFieldDefinition[]>;
+    /**
+     * Get a single field definition by ID
+     * (`GET /accounts/{accountId}/fields/{fieldId}`).
+     *
+     * @param fieldId - The field definition to fetch.
+     * @param accountId - Override the client's default account ID.
+     * @returns The field definition. Response shape:
+     * ```jsonc
+     * {
+     *   "resource": "field_definition",
+     *   "id": "103ad21709d15eca8c48085b5b8f",
+     *   "name": "Employee CPF",
+     *   "type": "cpf",
+     *   "regex": null,
+     *   "is_pre_defined": false,
+     *   "is_active": true,
+     *   "is_required": true,
+     *   "is_standard": false,
+     *   "is_read_only": false,
+     *   "is_visible": true
+     * }
+     * ```
+     * @throws {ValidationError} If `fieldId` or the account ID is missing.
+     * @throws {ApiError} `404` if the field does not exist.
+     *
+     * @example
+     * ```ts
+     * const field = await client.fields.get('103ad21709d15eca8c48085b5b8f');
+     * ```
+     */
+    get(fieldId: string, accountId?: string): Promise<IFieldDefinition>;
+    /**
+     * Update a field definition
+     * (`PUT /accounts/{accountId}/fields/{fieldId}`).
+     *
+     * @param fieldId - The field definition to update.
+     * @param payload - Official fields are `name`, nullable `regex`, and
+     * `is_active`. The sandbox also accepts `type` and `is_required` as live
+     * compatibility extensions.
+     * @param accountId - Override the client's default account ID.
+     * @returns The updated field definition. Response shape:
+     * ```jsonc
+     * {
+     *   "resource": "field_definition",
+     *   "id": "103ad21709d15eca8c48085b5b8f",
+     *   "name": "Employee CPF (renamed)",
+     *   "type": "cpf",
+     *   "regex": null,
+     *   "is_pre_defined": false,
+     *   "is_active": true,
+     *   "is_required": true,
+     *   "is_standard": false,
+     *   "is_read_only": false,
+     *   "is_visible": true
+     * }
+     * ```
+     * @throws {ValidationError} If `fieldId` or the account ID is missing.
+     * @throws {ApiError} `404` if the field does not exist.
+     *
+     * @example
+     * ```ts
+     * await client.fields.update('103ad21709d15eca8c48085b5b8f', {
+     *   name: 'Employee CPF (renamed)',
+     *   is_active: false,
+     * });
+     * ```
+     */
+    update(fieldId: string, payload: IUpdateFieldPayload, accountId?: string): Promise<IFieldDefinition>;
+    /**
+     * Delete a field definition
+     * (`DELETE /accounts/{accountId}/fields/{fieldId}`).
+     *
+     * Fails if the field has already been used by an assignment; deactivate it
+     * via {@link FieldsResource.update} (`is_active: false`) instead.
+     *
+     * @param fieldId - The field definition to delete.
+     * @param accountId - Override the client's default account ID.
+     * @returns Nothing on success.
+     * @throws {ValidationError} If `fieldId` or the account ID is missing.
+     * @throws {ApiError} If the field is in use or does not exist.
+     *
+     * @example
+     * ```ts
+     * await client.fields.delete('103ad21709d15eca8c48085b5b8f');
+     * ```
+     */
+    delete(fieldId: string, accountId?: string): Promise<void>;
+    /**
+     * Validate a single value against a field definition
+     * (`POST /accounts/{accountId}/fields/{fieldId}/validate`).
+     *
+     * The official operation uses the client's API-key/Bearer authentication.
+     * `signerAccessCode` is retained as a deployment-specific, live-unverified
+     * compatibility query and is sent as `signer-access-code` when supplied.
+     *
+     * @param fieldId - The field definition to validate against.
+     * @param value - The value to check (validated against the field's
+     *   type/regex). Sent as `{ value }` in the request body.
+     * @param options - Account override and optional legacy `signerAccessCode`.
+     * @returns The validation result. Response shape:
+     * ```jsonc
+     * {
+     *   "type": "text",
+     *   "success": true,
+     *   "error_message": ""
+     * }
+     * ```
+     * @throws {ValidationError} If `fieldId` or the account ID is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const result = await client.fields.validate(
+     *   '103ad21709d15eca8c48085b5b8f',
+     *   '123.456.789-09',
+     * );
+     * if (!result.success) console.warn(result.error_message);
+     * ```
+     */
+    validate(fieldId: string, value: unknown, options?: {
+        signerAccessCode?: string;
+        accountId?: string;
+    }): Promise<IFieldValidationResult>;
+    /**
+     * Validate multiple values at once
+     * (`POST /accounts/{accountId}/fields/validate-multiple`).
+     *
+     * The request body is the array of `{ field_id, value }` entries itself
+     * (not wrapped in an object). The optional `signerAccessCode` query is the
+     * same live-unverified compatibility extension described on
+     * {@link FieldsResource.validate}.
+     *
+     * @param entries - Non-empty array of `{ field_id, value }` pairs.
+     * @param options - Account override and optional legacy `signerAccessCode`.
+     * @returns One validation result per entry. Response shape:
+     * ```jsonc
+     * [
+     *   { "type": "cpf", "success": true, "error_message": "" },
+     *   { "type": "text", "success": true, "error_message": "" }
+     * ]
+     * ```
+     * @throws {ValidationError} If `entries` is empty or the account ID is missing.
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const results = await client.fields.validateMultiple(
+     *   [
+     *     { field_id: 'field-cpf', value: '123.456.789-09' },
+     *     { field_id: 'field-name', value: 'Example Signer' },
+     *   ],
+     * );
+     * ```
+     */
+    validateMultiple(entries: IFieldValidateMultipleEntry[], options?: {
+        signerAccessCode?: string;
+        accountId?: string;
+    }): Promise<IFieldValidationResult[]>;
+    /**
+     * List the platform's supported field types (`GET /field-types`).
+     *
+     * @returns The catalogue of field types (11 live entries). Response shape:
+     * ```jsonc
+     * [
+     *   { "type": "personName", "name": "Nome" },
+     *   { "type": "cpf", "name": "CPF" },
+     *   { "type": "email", "name": "E-mail" },
+     *   { "type": "text", "name": "Texto" }
+     * ]
+     * ```
+     * @throws {ApiError} If the API rejects the request.
+     *
+     * @example
+     * ```ts
+     * const types = await client.fields.listTypes();
+     * const cpf = types.find((t) => t.type === 'cpf');
+     * ```
+     */
+    listTypes(): Promise<IFieldType[]>;
+}
+
+/**
+ * Signer-side endpoints for custom signing UIs. Most calls authenticate with
+ * `signer-access-code` (the one-time link emailed/whatsapped to the signer),
+ * never the workspace API key. The artifact-download route is the documented
+ * public exception and can be called without an access code.
+ */
+declare class SignerDocumentsResource extends BaseResource {
+    /**
+     * Fetch the document currently awaiting a given signer
+     * (`GET /signers/{signer_id}/document?signer-access-code=…`).
+     *
+     * The signer-side counterpart of {@link DocumentResource.details}, authorised
+     * by the signer's access code rather than the workspace API key.
+     *
+     * @param signerId - The signer whose current document is fetched.
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @returns The document in the full {@link IDocumentDetailsResponse} shape:
+     * ```jsonc
+     * {
+     *   "resource": "document",
+     *   "id": "103acccd24234c07858ffddf6d84",
+     *   "account_id": "acc_example",
+     *   "template_id": null,
+     *   "name": "Service agreement.pdf",
+     *   "status": "pending_signature",
+     *   "artifacts": {
+     *     "original": "https://sandbox.assinafy.com.br/v1/documents/103acccd.../download/original",
+     *     "thumbnail": "https://sandbox.assinafy.com.br/v1/documents/103acccd.../thumbnail"
+     *   },
+     *   "is_closed": false,
+     *   "signing_url": "https://app-sandbox.assinafy.com.br/sign/103acccd...",
+     *   "decline_reason": null,
+     *   "declined_by": null,
+     *   "tags": [],
+     *   "assignment": null,          // an IAssignment once signing has started
+     *   "pages": [
+     *     { "id": "103acccd5c73...", "number": 1, "height": 1651, "width": 1275,
+     *       "download_url": "https://sandbox.assinafy.com.br/v1/documents/103acccd.../pages/103acccd5c73.../download" }
+     *   ],
+     *   "created_at": "2026-07-19T14:56:54Z",
+     *   "updated_at": "2026-07-19T14:56:56Z"
+     * }
+     * ```
+     * @throws {ValidationError} If `signerId` or `signerAccessCode` is missing.
+     * @throws {ApiError} If the access code is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * const doc = await client.signerDocuments.getCurrent(signerId, accessCode);
+     * console.log(doc.status, doc.pages.length);
+     * ```
+     */
+    getCurrent(signerId: string, signerAccessCode: string): Promise<IDocumentDetailsResponse>;
+    /**
+     * List every document awaiting a given signer
+     * (`GET /signers/{signer_id}/documents?signer-access-code=…`).
+     *
+     * The signer-side counterpart of {@link DocumentResource.list}, scoped to one
+     * signer and authorised by their access code. Pagination is read from the
+     * `X-Pagination-*` response headers and attached in `meta`; the API honours
+     * `page` and `per-page` (the SDK normalises `per_page` → `per-page`).
+     *
+     * @param signerId - The signer whose documents are listed.
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @param params - Pagination: `page`, `per-page` (also accepts `per_page`).
+     * @returns Matching documents in the compact {@link IDocumentListItem} shape,
+     * with pagination in `meta`:
+     * ```jsonc
+     * {
+     *   "data": [
+     *     {
+     *       "id": "103acccd24234c07858ffddf6d84",
+     *       "account_id": "acc_example",
+     *       "template_id": null,
+     *       "name": "Service agreement.pdf",
+     *       "status": "pending_signature",
+     *       "artifacts": { "original": "https://...", "thumbnail": "https://..." },
+     *       "is_closed": false,
+     *       "signing_url": "https://app-sandbox.assinafy.com.br/sign/103acccd...",
+     *       "decline_reason": null,
+     *       "declined_by": null,
+     *       "tags": [],
+     *       "created_at": "2026-07-19T14:56:54Z",
+     *       "updated_at": "2026-07-19T14:56:56Z"
+     *     }
+     *   ],
+     *   "meta": { "current_page": 1, "per_page": 20, "total": 1, "last_page": 1 }
+     * }
+     * ```
+     * @throws {ValidationError} If `signerId` or `signerAccessCode` is missing.
+     * @throws {ApiError} If the access code is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * const { data, meta } = await client.signerDocuments.list(signerId, accessCode, {
+     *   'per-page': 20,
+     * });
+     * ```
+     */
+    list(signerId: string, signerAccessCode: string, params?: IListParams): Promise<IDocumentListResponse>;
+    /**
+     * 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',
+     * );
+     * ```
+     */
+    search(signerId: string, signerAccessCode: string, search?: string): Promise<IDocumentListResponse>;
+    /**
+     * Download one of a signer's document artifacts as raw bytes
+     * (`GET /signers/{signer_id}/documents/{document_id}/download/{artifact}`).
+     *
+     * The signer-side counterpart of {@link DocumentResource.download}: same
+     * artifact names, exposed by the API as a public signer-link endpoint. The
+     * optional access-code argument is retained for compatibility with deployed
+     * environments that still accept or require the legacy query parameter. The
+     * `certificated` and `bundle` artifacts only exist once the document is fully
+     * signed.
+     *
+     * @param signerId - The signer requesting the download.
+     * @param documentId - The document to download.
+     * @param artifactName - Which artifact to fetch (`original`, `certificated`,
+     *   `certificate-page`, or `bundle`).
+     * @param signerAccessCode - Optional legacy signer access code. Omit it for
+     *   the official public request shape.
+     * @returns The artifact bytes as a Node `Buffer` (PDF for `original` /
+     *   `certificated` / `bundle`).
+     * @throws {ValidationError} If `signerId` or `documentId` is missing, or if
+     *   an explicitly supplied legacy `signerAccessCode` is blank.
+     * @throws {ApiError} `404` if the artifact does not exist yet.
+     *
+     * @example
+     * ```ts
+     * const pdf = await client.signerDocuments.download(
+     *   signerId,
+     *   documentId,
+     *   'original',
+     * );
+     * await fs.writeFile('to-sign.pdf', pdf);
+     * ```
+     */
+    download(signerId: string, documentId: string, artifactName: DocumentArtifactName, signerAccessCode?: string): Promise<Buffer>;
+    /**
+     * Sign several documents in one call
+     * (`PUT /signers/documents/sign-multiple?signer-access-code=…`).
+     *
+     * Batch shortcut for a signer who has multiple pending documents under the
+     * same access code — it signs each with their stored signature/initials
+     * rather than field-by-field (contrast {@link SignerDocumentsResource.sign}).
+     * The `document_ids` array goes in the request body; the access code
+     * authenticates via the `signer-access-code` query param.
+     *
+     * @param documentIds - Non-empty array of document IDs to sign.
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @returns Resolves when the API acknowledges the operation. The documented
+     *   empty-array response data is intentionally discarded.
+     * @throws {ValidationError} If `documentIds` is empty/not an array, or
+     *   `signerAccessCode` is missing.
+     * @throws {ApiError} If the access code is invalid/expired or a document is
+     *   not in a signable state.
+     *
+     * @example
+     * ```ts
+     * // body → { document_ids: ['103acccd...', '103aa251...'] }
+     * await client.signerDocuments.signMultiple(
+     *   ['103acccd24234c07858ffddf6d84', '103aa251ccb4ee136e3fd5cc140b'],
+     *   accessCode,
+     * );
+     * ```
+     */
+    signMultiple(documentIds: string[], signerAccessCode: string): Promise<void>;
+    /**
+     * Decline several documents in one call
+     * (`PUT /signers/documents/decline-multiple?signer-access-code=…`).
+     *
+     * The batch counterpart of {@link SignerDocumentsResource.signMultiple}: the
+     * same `decline_reason` is recorded against every document in `documentIds`.
+     * Both `document_ids` and `decline_reason` go in the request body; the access
+     * code authenticates via the `signer-access-code` query param.
+     *
+     * @param documentIds - Non-empty array of document IDs to decline.
+     * @param declineReason - Free-text reason shown to the sender (required).
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @returns Resolves when the API acknowledges the operation. The documented
+     *   empty-array response data is intentionally discarded.
+     * @throws {ValidationError} If `documentIds` is empty/not an array,
+     *   `declineReason` is empty, or `signerAccessCode` is missing.
+     * @throws {ApiError} If the access code is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * // body → { document_ids: ['103acccd...'], decline_reason: 'Wrong counterparty' }
+     * await client.signerDocuments.declineMultiple(
+     *   ['103acccd24234c07858ffddf6d84'],
+     *   'Wrong counterparty',
+     *   accessCode,
+     * );
+     * ```
+     */
+    declineMultiple(documentIds: string[], declineReason: string, signerAccessCode: string): Promise<void>;
+    /**
+     * Fetch the authenticated signer's own profile
+     * (`GET /signers/self?signer-access-code=…`).
+     *
+     * Resolves the signer identity behind an access code, plus whether they have
+     * already stored a signature/initial image — useful for deciding whether to
+     * prompt for {@link SignerDocumentsResource.uploadSignature} before signing.
+     *
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @returns The signer profile. Unlike the workspace-side signer object, this
+     * also reports `has_signature` / `has_initial`:
+     * ```jsonc
+     * {
+     *   "resource": "signer",
+     *   "id": "19e6b92e7895332ed9708535d8c",
+     *   "full_name": "Example Signer",
+     *   "email": "signer@example.com",
+     *   "whatsapp_phone_number": null,
+     *   "has_accepted_terms": false,
+     *   "has_signature": false,
+     *   "has_initial": false,
+     *   "is_signature_reusable": false
+     * }
+     * ```
+     * @throws {ValidationError} If `signerAccessCode` is missing.
+     * @throws {ApiError} If the access code is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * const me = await client.signerDocuments.self(accessCode);
+     * if (!me.has_signature) {
+     *   // prompt the signer to draw/upload a signature first
+     * }
+     * ```
+     */
+    self(signerAccessCode: string): Promise<ISignerSelf>;
+    /**
+     * Accept the platform terms of use as the signer
+     * (`PUT /signers/accept-terms?signer-access-code=…`).
+     *
+     * A signer must accept terms before they can sign. The access code
+     * authenticates via the `signer-access-code` **query param** — this endpoint
+     * takes **no request body** (sending the code in the body leaves the request
+     * unauthenticated → `401`). Pass the resulting acceptance to
+     * {@link SignerDocumentsResource.getAssignment} via its `hasAcceptedTerms`
+     * flag.
+     *
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @returns Resolves when the API acknowledges the operation. The response
+     *   envelope has no `data` field and is intentionally discarded.
+     * @throws {ValidationError} If `signerAccessCode` is missing.
+     * @throws {ApiError} If the access code is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * await client.signerDocuments.acceptTerms(accessCode);
+     * const assignment = await client.signerDocuments.getAssignment(accessCode, true);
+     * ```
+     */
+    acceptTerms(signerAccessCode: string): Promise<void>;
+    /**
+     * Verify the signer's email one-time password
+     * (`POST /verify?signer-access-code=…`).
+     *
+     * Confirms the 6-digit OTP the platform emailed the signer. The access code
+     * authenticates via the `signer-access-code` **query param**; the request
+     * **body carries only `verification-code`** (putting the access code in the
+     * body leaves the request unauthenticated → `401`).
+     *
+     * @param payload - `signerAccessCode` (the signing-link code) and
+     *   `verificationCode` (the OTP the signer received).
+     * @returns Resolves when the API acknowledges the operation. The response
+     *   envelope has no `data` field and is intentionally discarded.
+     * @throws {ValidationError} If `signerAccessCode` or `verificationCode` is
+     *   missing.
+     * @throws {ApiError} `400`/`401` if the OTP is wrong or the access code is
+     *   invalid or expired.
+     *
+     * @example
+     * ```ts
+     * // query → ?signer-access-code=<code>   body → { 'verification-code': '123456' }
+     * await client.signerDocuments.verifyEmail({
+     *   signerAccessCode: accessCode,
+     *   verificationCode: '123456',
+     * });
+     * ```
+     */
+    verifyEmail(payload: {
+        signerAccessCode: string;
+        verificationCode: string;
+    }): Promise<void>;
+    /**
+     * Confirm (and optionally correct) the signer's identity data before signing
+     * (`PUT /documents/{documentId}/signers/confirm-data?signer-access-code=…`).
+     *
+     * Lets the signer confirm the name/e-mail/government ID that will appear on
+     * the signed document. Only the provided fields are sent — `undefined`/`null`
+     * entries are stripped by {@link cleanParams} before the request — so you can
+     * pass just the fields the signer changed. The access code authenticates via
+     * the `signer-access-code` query param. Legal terms are accepted separately
+     * with {@link SignerDocumentsResource.acceptTerms}; they are never asserted
+     * by this identity-data request.
+     *
+     * @param documentId - The document the signer is confirming data for.
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @param payload - Any of the official `full_name`, `email`, or
+     *   `government_id` fields. Fields left out are not sent.
+     * @returns The confirmed signer in the full {@link ISigner} response shape.
+     * @throws {ValidationError} If `documentId` or `signerAccessCode` is missing.
+     * @throws {ApiError} If the access code is invalid/expired or a value fails
+     *   validation.
+     *
+     * @example
+     * ```ts
+     * // body → { full_name: 'Example Signer', government_id: '123.456.789-00' }
+     * await client.signerDocuments.confirmData(documentId, accessCode, {
+     *   full_name: 'Example Signer',
+     *   government_id: '123.456.789-00',
+     * });
+     * await client.signerDocuments.acceptTerms(accessCode);
+     * ```
+     */
+    confirmData(documentId: string, signerAccessCode: string, payload: IConfirmSignerDataPayload): Promise<ISigner>;
+    /**
+     * @deprecated Compatibility overload preserving the previous wire shape.
+     * `whatsapp_phone_number` and `has_accepted_terms` are unverified legacy
+     * pass-through fields. Call `acceptTerms()` explicitly for legal consent.
+     */
+    confirmData(documentId: string, signerAccessCode: string, payload: ILegacyConfirmSignerDataPayload): Promise<ISigner>;
+    /**
+     * Upload the signer's signature or initial image
+     * (`POST /signature?signer-access-code=…&type=…`).
+     *
+     * The image bytes are sent as the raw request body (default
+     * `Content-Type: image/png`); `type` (`signature` or `initial`) and the
+     * optional `reuse` flag are query params, alongside the authenticating
+     * `signer-access-code`. Set `reuse: true` to persist the image so it is
+     * applied automatically to the signer's future documents.
+     *
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @param image - The image bytes as a non-empty `Buffer`.
+     * @param options - `imageType` (`'signature'` default, or `'initial'`) and
+     *   `reuse` (persist for reuse). The official request content type is PNG.
+     * @returns Resolves when the API acknowledges the upload. The response
+     *   envelope has no `data` field and is intentionally discarded.
+     * @throws {ValidationError} If `signerAccessCode` is missing or `image` is not
+     *   a non-empty buffer.
+     * @throws {ApiError} If the access code is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * const png = await fs.readFile('./signature.png');
+     * // query → ?signer-access-code=<code>&type=signature&reuse=true
+     * await client.signerDocuments.uploadSignature(accessCode, png, {
+     *   imageType: 'signature',
+     *   reuse: true,
+     * });
+     * ```
      */
-    update(tagId: string, payload: IUpdateTagPayload, accountId?: string): Promise<ITag>;
+    uploadSignature(signerAccessCode: string, image: Buffer, options?: IUploadSignatureOptions): Promise<void>;
     /**
-     * Delete a tag. By default fails with `ApiError` (409) if the tag is still
-     * attached to anything; pass `{ force: true }` to detach everywhere first.
+     * @deprecated Compatibility overload for non-PNG media types. The current
+     * OpenAPI contract specifies only `image/png`; other values are not certified.
      */
-    delete(tagId: string, options?: {
-        force?: boolean;
-        accountId?: string;
-    }): Promise<void>;
-}
-
-/**
- * Authentication endpoints (login, social login, password management) and
- * personal API key management (`/users/api-keys`).
- *
- * Most of these endpoints are intended to bootstrap an authenticated session
- * for a human user. Production server-to-server integrations should use
- * `X-Api-Key` and skip this resource entirely.
- */
-declare class AuthenticationResource extends BaseResource {
-    /** `POST /login` — exchange email + password for a JWT access token. */
-    login(email: string, password: string): Promise<ILoginResponse>;
-    /** `POST /authentication/social-login` — exchange a provider token for an Assinafy JWT. */
-    socialLogin(payload: {
-        provider: string;
-        token: string;
-        has_accepted_terms: boolean;
-    }): Promise<ILoginResponse>;
-    /** `POST /users/api-keys` — generate (and rotate) the current user's API key. */
-    createApiKey(password: string): Promise<IApiKeyResponse>;
+    uploadSignature(signerAccessCode: string, image: Buffer, options: ILegacyUploadSignatureOptions): Promise<void>;
     /**
-     * `GET /users/api-keys` — fetch a masked version of the current API key, or
-     * `null` if no key has been generated yet.
+     * Download the signer's stored signature or initial image
+     * (`GET /signature/{type}?signer-access-code=…`).
+     *
+     * The read-side counterpart of {@link SignerDocumentsResource.uploadSignature}
+     * — returns the image the signer previously uploaded (e.g. to preview it in a
+     * custom signing UI). Returns bytes, not JSON.
+     *
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @param imageType - Which image to fetch: `'signature'` (default) or
+     *   `'initial'`.
+     * @returns The image bytes as a Node `Buffer` (PNG by default).
+     * @throws {ValidationError} If `signerAccessCode` is missing.
+     * @throws {ApiError} `404` if the signer has no such image stored; `401`/`403`
+     *   if the access code is invalid or expired.
+     *
+     * @example
+     * ```ts
+     * const png = await client.signerDocuments.downloadSignature(accessCode, 'signature');
+     * await fs.writeFile('signature.png', png);
+     * ```
      */
-    getApiKey(): Promise<IMaskedApiKeyResponse>;
-    /** `DELETE /users/api-keys` — revoke the current API key. */
-    deleteApiKey(): Promise<void>;
-    /** `PUT /authentication/change-password` — change the authenticated user's password. */
-    changePassword(payload: {
-        email: string;
-        password: string;
-        new_password: string;
-    }): Promise<{
-        email: string;
-    }>;
-    /** `PUT /authentication/request-password-reset` — email a reset link to the user. */
-    requestPasswordReset(email: string): Promise<{
-        email: string;
-    }>;
-    /** `PUT /authentication/reset-password` — complete a password reset using the emailed token. */
-    resetPassword(payload: {
-        email: string;
-        token?: string;
-        new_password: string;
-    }): Promise<{
-        email: string;
-    }>;
-}
-
-/**
- * Custom field definitions used by `collect` assignments.
- *
- * Covers the full Field Definition section of the API docs:
- *  - `POST /accounts/{id}/fields`
- *  - `GET /accounts/{id}/fields`
- *  - `GET /accounts/{id}/fields/{id}`
- *  - `PUT /accounts/{id}/fields/{id}`
- *  - `DELETE /accounts/{id}/fields/{id}`
- *  - `POST /accounts/{id}/fields/{id}/validate?signer-access-code=…`
- *  - `POST /accounts/{id}/fields/validate-multiple?signer-access-code=…`
- *  - `GET /field-types`
- */
-declare class FieldsResource extends BaseResource {
-    /** Create a field definition. */
-    create(payload: ICreateFieldPayload, accountId?: string): Promise<IFieldDefinition>;
+    downloadSignature(signerAccessCode: string, imageType?: 'signature' | 'initial'): Promise<Buffer>;
     /**
-     * List field definitions for the workspace.
+     * Fetch the assignment (document + fields) as the signer sees it
+     * (`GET /sign?signer-access-code=…`).
+     *
+     * The entry point for a custom signing UI: resolves the access code to the
+     * document, its pages, and the {@link ISignFieldEntry}-addressable items the
+     * signer must fill. Before terms are accepted the server may answer `409`, so
+     * call {@link SignerDocumentsResource.acceptTerms} first (or pass
+     * `hasAcceptedTerms: true` once accepted).
+     *
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @param hasAcceptedTerms - Maps to the `has_accepted_terms` query param
+     *   (server default `false`); pass `true` once the signer has accepted terms.
+     *   `false`/`undefined` is omitted only when `undefined` (an explicit `false`
+     *   is still sent).
+     * @returns The document to sign, including its `assignment` (the
+     *   {@link IAssignment} shape: `signers`, `items`, `summary`, `signing_urls`)
+     *   from which the `itemId` / `fieldId` / `pageId` values for
+     *   {@link SignerDocumentsResource.sign} are read.
+     * @throws {ValidationError} If `signerAccessCode` is missing.
+     * @throws {ApiError} `401`/`403` if the access code is invalid or expired;
+     *   `409` if terms have not yet been accepted.
      *
-     * @param params.include_inactive  return inactive fields too
-     * @param params.include_standard  also return `signature`, `initial`, `signatureDate`
+     * @example
+     * ```ts
+     * // query → ?signer-access-code=<code>&has_accepted_terms=true
+     * const assignment = await client.signerDocuments.getAssignment(accessCode, true);
+     * ```
      */
-    list(params?: {
-        include_inactive?: boolean;
-        include_standard?: boolean;
-    }, accountId?: string): Promise<IFieldDefinition[]>;
-    /** Get a single field definition by ID. */
-    get(fieldId: string, accountId?: string): Promise<IFieldDefinition>;
-    /** Update a field definition. */
-    update(fieldId: string, payload: IUpdateFieldPayload, accountId?: string): Promise<IFieldDefinition>;
-    /** Delete a field definition. Fails if the field has been used. */
-    delete(fieldId: string, accountId?: string): Promise<void>;
+    getAssignment(signerAccessCode: string, hasAcceptedTerms?: boolean): Promise<IDocumentDetailsResponse>;
     /**
-     * Validate a single value against a field definition.
+     * Submit the signer's field values to sign an assignment
+     * (`POST /documents/{documentId}/assignments/{assignmentId}?signer-access-code=…`).
      *
-     * Pass `signerAccessCode` for signer-side validation (the typical use case);
-     * omit it when the caller is authenticated via API key.
+     * The precise, field-by-field counterpart of
+     * {@link SignerDocumentsResource.signMultiple}: the `entries` array is sent as
+     * the request body, each entry addressing one item resolved from
+     * {@link SignerDocumentsResource.getAssignment}. The access code
+     * authenticates via the `signer-access-code` query param.
+     *
+     * @param documentId - The document being signed.
+     * @param assignmentId - The assignment within that document.
+     * @param signerAccessCode - The signer's access code, from their signing link.
+     * @param entries - Non-empty array of {@link ISignFieldEntry}
+     *   (`itemId`, `fieldId`, `pageId`, `value`) — the body sent to the API.
+     * @returns The API's signing result object. Its keys are operation-specific,
+     *   so the SDK preserves them as a {@link Record} without inventing fields.
+     * @throws {ValidationError} If any of `documentId`, `assignmentId`, or
+     *   `signerAccessCode` is missing, or `entries` is empty.
+     * @throws {ApiError} `400`/`409` if a value fails validation or the assignment
+     *   is no longer signable; `401`/`403` if the access code is invalid/expired.
+     *
+     * @example
+     * ```ts
+     * // body → [{ itemId, fieldId, pageId, value: 'Example Signer' }]
+     * await client.signerDocuments.sign(documentId, assignmentId, accessCode, [
+     *   { itemId: 'item-1', fieldId: 'field-1', pageId: 'page-1', value: 'Example Signer' },
+     * ]);
+     * ```
      */
-    validate(fieldId: string, value: unknown, options?: {
-        signerAccessCode?: string;
-        accountId?: string;
-    }): Promise<IFieldValidationResult>;
-    /** Validate multiple values at once. */
-    validateMultiple(entries: IFieldValidateMultipleEntry[], options?: {
-        signerAccessCode?: string;
-        accountId?: string;
-    }): Promise<IFieldValidationResult[]>;
-    /** List the platform's supported field types. */
-    listTypes(): Promise<IFieldType[]>;
-}
-
-/**
- * Signer-side endpoints. Every call here is authenticated by `signer-access-code`
- * (the one-time link emailed/whatsapped to the signer), not by the workspace
- * API key. Use this resource when building a custom signer UI.
- */
-declare class SignerDocumentsResource extends BaseResource {
-    /** `GET /signers/{signer_id}/document?signer-access-code=…` */
-    getCurrent(signerId: string, signerAccessCode: string): Promise<IDocumentDetailsResponse>;
-    /** `GET /signers/{signer_id}/documents?signer-access-code=…` */
-    list(signerId: string, signerAccessCode: string, params?: IListParams): Promise<IDocumentListResponse>;
+    sign(documentId: string, assignmentId: string, signerAccessCode: string, entries: ISignFieldEntry[]): Promise<Record<string, unknown>>;
     /**
-     * Search the documents awaiting a given signer
-     * (`GET /signers/{signer_id}/documents/search?signer-access-code=…`).
+     * Decline (reject) a single assignment as the signer
+     * (`PUT /documents/{documentId}/assignments/{assignmentId}/reject?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.
+     * The single-document counterpart of
+     * {@link SignerDocumentsResource.declineMultiple}. The `decline_reason` is
+     * sent in the request body; the access code authenticates via the
+     * `signer-access-code` query param. (The workspace-side equivalent is to
+     * delete the document via `documents.delete`; there is no workspace "cancel"
+     * endpoint.)
      *
-     * @param signerId - The signer whose documents are searched.
+     * @param documentId - The document being declined.
+     * @param assignmentId - The assignment within that document.
      * @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.
+     * @param declineReason - Free-text reason shown to the sender (required).
+     * @returns Resolves when the API acknowledges the operation. The documented
+     *   empty-array response data is intentionally discarded.
+     * @throws {ValidationError} If any of `documentId`, `assignmentId`, or
+     *   `signerAccessCode` is missing, or `declineReason` is empty.
      * @throws {ApiError} If the access code is invalid or expired.
      *
      * @example
      * ```ts
-     * const { data } = await client.signerDocuments.search(
-     *   signerId,
+     * // body → { decline_reason: 'Terms are unacceptable' }
+     * await client.signerDocuments.decline(
+     *   documentId,
+     *   assignmentId,
      *   accessCode,
-     *   'agreement',
+     *   'Terms are unacceptable',
      * );
      * ```
      */
-    search(signerId: string, signerAccessCode: string, search?: string): Promise<IDocumentListResponse>;
-    /** `GET /signers/{signer_id}/documents/{document_id}/download/{artifact}?signer-access-code=…` */
-    download(signerId: string, documentId: string, artifactName: DocumentArtifactName, signerAccessCode: string): Promise<Buffer>;
-    /** `PUT /signers/documents/sign-multiple?signer-access-code=…` */
-    signMultiple(documentIds: string[], signerAccessCode: string): Promise<unknown>;
-    /** `PUT /signers/documents/decline-multiple?signer-access-code=…` */
-    declineMultiple(documentIds: string[], declineReason: string, signerAccessCode: string): Promise<unknown>;
-    /** `GET /signers/self?signer-access-code=…` — fetch the signer's own profile. */
-    self(signerAccessCode: string): Promise<unknown>;
-    /** `PUT /signers/accept-terms` — accept the platform terms as the signer. */
-    acceptTerms(signerAccessCode: string): Promise<unknown>;
-    /** `POST /verify` — verify the email OTP for a signer. */
-    verifyEmail(payload: {
-        signerAccessCode: string;
-        verificationCode: string;
-    }): Promise<unknown>;
-    /** `PUT /documents/{documentId}/signers/confirm-data?signer-access-code=…` */
-    confirmData(documentId: string, signerAccessCode: string, payload: {
-        email?: string;
-        whatsapp_phone_number?: string;
-        has_accepted_terms?: boolean;
-    }): Promise<unknown>;
-    /**
-     * `POST /signature?signer-access-code=…&type=…` — upload the signer's
-     * signature or initial image. `imageType` defaults to `signature`.
-     */
-    uploadSignature(signerAccessCode: string, image: Buffer, options?: {
-        imageType?: 'signature' | 'initial';
-        contentType?: string;
-    }): Promise<unknown>;
-    /** `GET /signature/{type}?signer-access-code=…` — download the signer's signature/initial. */
-    downloadSignature(signerAccessCode: string, imageType?: 'signature' | 'initial'): Promise<Buffer>;
+    decline(documentId: string, assignmentId: string, signerAccessCode: string, declineReason: string): Promise<void>;
+}
+
+/** Operations for the authenticated Assinafy user. */
+declare class UserResource extends BaseResource {
     /**
-     * `GET /sign?signer-access-code=…` — fetch the assignment as the signer sees it.
+     * Return the authenticated user's profile (`GET /users/self`).
      *
-     * @param hasAcceptedTerms maps to the `has_accepted_terms` query param
-     *   (server default `false`); pass `true` once the signer has accepted terms.
+     * Request body: none. Authentication: `X-Api-Key` or Bearer token.
+     *
+     * @returns The unwrapped user payload:
+     * ```jsonc
+     * {
+     *   "id": "bgjazeo5r9v2lq7l36dx48np",
+     *   "name": "John Smith",
+     *   "email": "john@example.com",
+     *   "telephone": null,
+     *   "government_id": null,
+     *   "is_email_verified": true,
+     *   "has_accepted_terms": true,
+     *   "created_at": "2026-06-03T03:54:16Z",
+     *   "to_be_deleted_at": null
+     * }
+     * ```
+     * @throws {ApiError} `401` when credentials are missing/invalid, or `500`
+     * when the API cannot load the user.
+     *
+     * @example
+     * ```ts
+     * const user = await client.users.getCurrent();
+     * console.log(user.email);
+     * ```
      */
-    getAssignment(signerAccessCode: string, hasAcceptedTerms?: boolean): Promise<unknown>;
-    /** `POST /documents/{documentId}/assignments/{assignmentId}?signer-access-code=…` — sign. */
-    sign(documentId: string, assignmentId: string, signerAccessCode: string, entries: ISignFieldEntry[]): Promise<unknown>;
+    getCurrent(): Promise<IAuthenticatedUser>;
     /**
-     * `PUT /documents/{documentId}/assignments/{assignmentId}/reject?signer-access-code=…`
-     * — signer-side decline. (The workspace-side equivalent is to delete the
-     * document via `documents.delete`; there is no workspace "cancel" endpoint.)
+     * Return document-funnel KPIs summed across all accounts the user currently
+     * belongs to (`GET /users/self/stats`).
+     *
+     * @param params - Omit for the latest 12 monthly rows. For daily rows pass
+     * `{ granularity: 'daily', month: '2026-06' }`.
+     * @returns A zero-filled series, most recent period first:
+     * ```jsonc
+     * [{
+     *   "period": "2026-06",
+     *   "documents_uploaded": 42,
+     *   "documents_sent": 37,
+     *   "signature_requests": 61,
+     *   "signature_requests_email": 55,
+     *   "signature_requests_whatsapp": 18,
+     *   "signature_requests_viewed": 44,
+     *   "signature_requests_completed": 52,
+     *   "documents_certified": 30
+     * }]
+     * ```
+     * @throws {ValidationError} If daily granularity has no month or `month`
+     * does not use `YYYY-MM`.
+     * @throws {ApiError} `400` for an invalid query or `401` for invalid auth.
+     *
+     * @example
+     * ```ts
+     * const monthly = await client.users.getStats();
+     * const daily = await client.users.getStats({
+     *   granularity: 'daily',
+     *   month: '2026-06',
+     * });
+     * ```
      */
-    decline(documentId: string, assignmentId: string, signerAccessCode: string, declineReason: string): Promise<unknown>;
+    getStats(params?: IDocumentStatsParams): Promise<IDocumentStatsRow[]>;
 }
 
 /**
- * Verifier for Assinafy webhook payloads.
+ * Opt-in verifier for deployments that wrap Assinafy webhook bodies in an
+ * HMAC-SHA256 convention of their own.
  *
- * The Assinafy platform signs webhook bodies with HMAC-SHA256 using the
- * workspace webhook secret and sends the hex digest in an `X-Assinafy-Signature`
- * header. Use {@link WebhookVerifier.verify} to confirm the signature before
- * trusting the payload.
+ * The current public Assinafy API contract does not specify a webhook-signature
+ * header or shared-secret exchange. This helper therefore makes no claim about
+ * a platform-provided header: callers must explicitly supply the raw lowercase
+ * or uppercase hexadecimal HMAC digest produced by their own trusted gateway.
  */
 declare class WebhookVerifier {
-    private readonly webhookSecret?;
-    constructor(webhookSecret?: string | undefined);
-    /** Returns `true` if `signature` is a valid HMAC-SHA256 of `payload`. */
+    private readonly webhookSecret;
+    /**
+     * Create an opt-in verifier for a gateway-defined HMAC convention.
+     *
+     * @param webhookSecret - Shared secret configured in both the trusted
+     * gateway and this process. Omit it to keep verification disabled.
+     *
+     * @example
+     * ```ts
+     * const verifier = new WebhookVerifier(process.env.WEBHOOK_SHARED_SECRET);
+     * ```
+     */
+    constructor(webhookSecret?: string);
+    /**
+     * Compare a hexadecimal HMAC-SHA256 digest with the raw request body.
+     *
+     * @param payload - Exact, unparsed request bytes (or their UTF-8 string).
+     * @param signature - 64-character hexadecimal SHA-256 digest supplied by
+     * the caller's trusted gateway.
+     * @returns `true` only for a well-formed, timing-safe match; `false` when
+     * verification is disabled or either input is invalid.
+     *
+     * @example
+     * ```ts
+     * const valid = verifier.verify(rawRequestBody, gatewaySignature);
+     * if (!valid) throw new Error('Invalid webhook signature');
+     * ```
+     */
     verify(payload: string | Buffer, signature: string): boolean;
-    /** Parse the raw webhook body into a JSON event envelope. */
+    /**
+     * Parse the raw webhook body into a JSON object. Inbound webhook bodies are
+     * not described by the current OpenAPI, so this remains deliberately
+     * tolerant of both the observed rich envelope and legacy `{ type, data }`.
+     *
+     * @param payload - Raw UTF-8 JSON request body.
+     * @returns The object envelope, or `null` for malformed JSON, primitives,
+     * arrays, and `null`.
+     *
+     * @example
+     * ```ts
+     * const event = verifier.extractEvent(rawRequestBody);
+     * if (!event) return response.status(400).end();
+     * ```
+     */
     extractEvent(payload: string | Buffer): IWebhookPayload | null;
-    /** Extract the event name (`event` or `type`) from an event envelope. */
+    /**
+     * Extract an event name from the current `event` or legacy `type` field.
+     *
+     * @param event - Parsed webhook envelope, or a nullable parse result.
+     * @returns The event name, or `null` when neither field is a string.
+     *
+     * @example
+     * ```ts
+     * const type = verifier.getEventType(event);
+     * if (type === 'document_ready') await handleReady(event);
+     * ```
+     */
     getEventType(event: IWebhookPayload | null | undefined): string | null;
-    /** Extract the event data (`data` or `object`) from an event envelope. */
+    /**
+     * Extract the event-specific object, falling back to legacy `data`.
+     *
+     * @param event - Parsed webhook envelope, or a nullable parse result.
+     * @returns `event.object`, then `event.data`, or an empty object when no
+     * object payload exists.
+     *
+     * @example
+     * ```ts
+     * const data = verifier.getEventData(event);
+     * console.log(data.document_id);
+     * ```
+     */
     getEventData(event: IWebhookPayload | null | undefined): Record<string, unknown>;
 }
 
@@ -1541,6 +4667,7 @@ interface ClientConfigInput {
     webhookSecret?: string;
     timeout?: number;
     maxRetries?: number;
+    max_retries?: number;
     logger?: Logger;
 }
 /**
@@ -1559,6 +4686,7 @@ interface ClientConfigInput {
  */
 declare class AssinafyClient {
     private readonly axiosInstance;
+    private readonly publicAxiosInstance;
     private readonly defaultAccountId;
     private readonly logger;
     private readonly webhookSecret;
@@ -1572,15 +4700,164 @@ declare class AssinafyClient {
     readonly auth: AuthenticationResource;
     readonly fields: FieldsResource;
     readonly signerDocuments: SignerDocumentsResource;
+    readonly users: UserResource;
     readonly webhookVerifier: WebhookVerifier;
-    constructor(options: AssinafyClientOptions);
-    /** Convenience factory for the common apiKey + accountId setup. */
+    /**
+     * Create a client. Supply `apiKey` (preferred, sent as `X-Api-Key`) or a
+     * Bearer `token` for protected operations. Credentials are optional so the
+     * same client can drive public login, verification, OAuth-URL and
+     * signer-access-code flows; a protected request without credentials receives
+     * the API's normal `401` {@link ApiError}.
+     *
+     * @param options - Credentials and configuration. `apiKey` or `token`
+     * authenticates protected operations; `accountId` sets the default
+     * workspace used by every account-scoped resource; `baseUrl` (default the
+     * production API), `timeout`
+     * (default 30 s), `maxRetries` (default 2, for HTTP 429 on idempotent
+     * requests), `webhookSecret` (enables
+     * {@link AssinafyClient.webhookVerifier}) and `logger` are optional.
+     * Non-idempotent requests are retried only when they explicitly carry an
+     * `Idempotency-Key` header.
+     *
+     * @example
+     * ```ts
+     * const client = new AssinafyClient({
+     *   apiKey: process.env.ASSINAFY_API_KEY!,
+     *   accountId: process.env.ASSINAFY_ACCOUNT_ID!,
+     * });
+     * ```
+     */
+    constructor(options?: AssinafyClientOptions);
+    /**
+     * Convenience factory for the common apiKey + accountId setup.
+     *
+     * @param apiKey - Workspace API key (sent as the `X-Api-Key` header).
+     * @param accountId - Default account ID used by account-scoped calls.
+     * @param options - Extra client options (`baseUrl`, `timeout`, `maxRetries`,
+     * `webhookSecret`, `logger`), minus `apiKey`/`accountId`.
+     * @returns A configured {@link AssinafyClient}.
+     *
+     * @example
+     * ```ts
+     * const client = AssinafyClient.create(
+     *   process.env.ASSINAFY_API_KEY!,
+     *   process.env.ASSINAFY_ACCOUNT_ID!,
+     *   { webhookSecret: process.env.ASSINAFY_WEBHOOK_SECRET },
+     * );
+     * ```
+     */
     static create(apiKey: string, accountId: string, options?: Omit<AssinafyClientOptions, 'apiKey' | 'accountId'>): AssinafyClient;
-    /** Build a client from a plain object (supports snake_case and camelCase keys). */
+    /**
+     * Build a client from a plain object, accepting both snake_case and
+     * camelCase keys (e.g. `api_key`/`apiKey`, `account_id`/`accountId`,
+     * `webhook_secret`/`webhookSecret`). Handy for loading config straight from
+     * environment variables or a JSON file.
+     *
+     * @param config - Loosely-typed configuration ({@link ClientConfigInput}).
+     * @returns A configured {@link AssinafyClient}.
+     *
+     * @example
+     * ```ts
+     * const client = AssinafyClient.fromConfig({
+     *   api_key: process.env.ASSINAFY_API_KEY,
+     *   account_id: process.env.ASSINAFY_ACCOUNT_ID,
+     * });
+     * ```
+     */
     static fromConfig(config: ClientConfigInput): AssinafyClient;
     /**
-     * High-level helper that uploads a PDF, ensures it's processed, creates any
-     * missing signers, and kicks off a virtual signature assignment.
+     * Flagship helper: upload a PDF, wait for it to process, ensure each signer
+     * exists, and open a **virtual** signature assignment — the whole "send this
+     * document for signature" flow in a single call.
+     *
+     * Sequence of API calls:
+     * 1. `POST /accounts/{accountId}/documents` — upload the PDF
+     *    ({@link DocumentResource.upload}).
+     * 2. Poll `GET /documents/{id}` until the document reaches a ready status
+     *    ({@link DocumentResource.waitUntilReady}).
+     * 3. For each signer, reuse an existing signer by email or
+     *    `POST /accounts/{accountId}/signers` to create one
+     *    ({@link SignerResource.create} — idempotent by email).
+     * 4. `POST /documents/{id}/assignments` with `method: 'virtual'` and the
+     *    collected signer IDs ({@link AssignmentResource.create}).
+     * 5. When `waitForReady` is not `false`, re-fetch `GET /documents/{id}` so
+     *    the returned document reflects the just-created assignment; otherwise
+     *    the upload snapshot is returned, avoiding only this final round-trip.
+     *
+     * @param options - Workflow options.
+     * @param options.source - The PDF to upload, as a file path or in-memory
+     * buffer (see {@link DocumentUploadSource}).
+     * @param options.signers - Signers to request signatures from — at least one
+     * is required. Each is `{ name, email?, whatsapp_phone_number? | phone?,
+     * cpf?, metadata? }`; a signer needs an email or a WhatsApp number to be
+     * notified.
+     * @param options.message - Optional invitation message attached to the
+     * assignment.
+     * @param options.metadata - Optional metadata attached to the uploaded
+     * document.
+     * @param options.waitForReady - Controls the final document re-fetch and
+     * return shape. Defaults to `true`. The workflow always waits for
+     * `metadata_ready` before creating an assignment because the API rejects
+     * assignments for documents that are still being processed.
+     * @param options.expiresAt - Optional ISO-8601 assignment expiry, e.g.
+     * `'2026-08-01T00:00:00Z'`.
+     * @param options.copyReceivers - Optional CC recipients (see the caveat on
+     * {@link ICreateAssignmentPayload.copy_receivers} — silently dropped on some
+     * plans).
+     * @param options.accountId - Override the client's default account ID.
+     * @returns `{ document, assignment, signer_ids }`. `document` is the
+     * re-fetched {@link IDocumentDetailsResponse} when `waitForReady` (the
+     * default), otherwise the {@link IDocumentUploadResponse} upload snapshot;
+     * `signer_ids` are the created/reused signer IDs in signer order:
+     * ```jsonc
+     * {
+     *   "document": {
+     *     "resource": "document",
+     *     "id": "103ad216846e6b90710cb9acef59",
+     *     "name": "contract.pdf",
+     *     "status": "pending_signature",   // re-fetched after assignment when waitForReady is true
+     *     "artifacts": { "original": "https://…", "thumbnail": "https://…" },
+     *     "assignment": { "id": "1032c55c58bb00a8dc35db916751" },  // the just-created assignment (same as the top-level `assignment` below)
+     *     "pages": [
+     *       { "id": "103ad216be62159d3087452d7cf8", "number": 1, "height": 1651, "width": 1275, "download_url": "https://…" }
+     *     ]
+     *   },
+     *   "assignment": {
+     *     "id": "1032c55c58bb00a8dc35db916751",
+     *     "method": "virtual",
+     *     "sender_email": "sender@example.com",
+     *     "message": "Please sign the attached agreement.",
+     *     "expires_at": null,
+     *     "signers": [
+     *       { "id": "1032becb82a279550bc3e5df9bbb", "step": 1, "email": "ana@example.com", "full_name": "Ana Souza", "notified": true, "completed": false }
+     *     ],
+     *     "signing_urls": [
+     *       { "signer_id": "1032becb82a279550bc3e5df9bbb", "url": "https://app-sandbox.assinafy.com.br/sign/103ad216846e6b90710cb9acef59?email=ana%40example.com" }
+     *     ]
+     *   },
+     *   "signer_ids": ["1032becb82a279550bc3e5df9bbb"]
+     * }
+     * ```
+     * @throws {ValidationError} If `signers` is empty, the upload fails
+     * validation (empty / non-PDF / larger than 25 MB), or the document never
+     * reaches a ready status before the
+     * {@link DocumentResource.waitUntilReady} timeout.
+     * @throws {ApiError} If any underlying API call is rejected.
+     *
+     * @example
+     * ```ts
+     * const { document, assignment, signer_ids } = await client.uploadAndRequestSignatures({
+     *   source: { filePath: './contract.pdf' },
+     *   signers: [
+     *     { name: 'Ana Souza', email: 'ana@example.com' },
+     *     { name: 'Bruno Lima', whatsapp_phone_number: '+5511999999999' },
+     *   ],
+     *   message: 'Please sign the attached agreement.',
+     * });
+     * console.log(document.status);          // 'metadata_ready'
+     * console.log(signer_ids.length);        // 2
+     * console.log(assignment.signing_urls);  // per-signer signing links
+     * ```
      */
     uploadAndRequestSignatures(options: {
         source: DocumentUploadSource;
@@ -1592,30 +4869,103 @@ declare class AssinafyClient {
         copyReceivers?: string[];
         accountId?: string;
     }): Promise<IUploadAndRequestSignaturesResult>;
-    /** Expose the underlying axios instance for advanced use cases (interceptors, custom endpoints). */
+    /**
+     * Expose the underlying axios instance for advanced use cases: adding
+     * interceptors, inspecting defaults, or calling endpoints not yet wrapped by
+     * a resource.
+     *
+     * @returns The configured `AxiosInstance` — auth headers, base URL, timeout,
+     * and the HTTP 429 retry interceptor are already applied. Automatic retries
+     * are limited to `GET`, `HEAD`, `OPTIONS`, `PUT`, and `DELETE`; add a unique
+     * `Idempotency-Key` header to explicitly permit replay of another method.
+     *
+     * @example
+     * ```ts
+     * client.getAxiosInstance().interceptors.request.use((cfg) => {
+     *   cfg.headers['X-Trace-Id'] = crypto.randomUUID();
+     *   return cfg;
+     * });
+     * ```
+     */
     getAxiosInstance(): AxiosInstance;
 }
 
 /** Base class for all Assinafy SDK errors. */
 declare class AssinafyError extends Error {
     readonly context: Record<string, unknown>;
+    /**
+     * Create a base SDK error with structured diagnostic context.
+     *
+     * @param message - Human-readable error summary.
+     * @param context - Structured details safe for the caller to inspect.
+     * @param options - Standard JavaScript error options, including `cause`.
+     *
+     * @example
+     * ```ts
+     * throw new AssinafyError('Operation failed', { operation: 'upload' });
+     * ```
+     */
     constructor(message: string, context?: Record<string, unknown>, options?: ErrorOptions);
 }
 /** Thrown when the API returns a non-success HTTP status. */
 declare class ApiError extends AssinafyError {
     readonly statusCode: number;
     readonly responseData: unknown;
+    /**
+     * Create an error representing a non-success API response.
+     *
+     * @param message - API-provided or fallback error summary.
+     * @param statusCode - HTTP response status.
+     * @param responseData - Parsed response body, when available.
+     * @param options - Standard JavaScript error options, including `cause`.
+     */
     constructor(message: string, statusCode: number, responseData?: unknown, options?: ErrorOptions);
+    /**
+     * Convert a status/body pair into an {@link ApiError}.
+     *
+     * @param statusCode - Non-success HTTP response status.
+     * @param responseData - Parsed API body. String `message` takes priority,
+     * followed by string `error`, then the stable fallback message.
+     * @returns An `ApiError` retaining the original response body.
+     *
+     * @example
+     * ```ts
+     * const error = ApiError.fromResponse(422, { message: 'Invalid signer' });
+     * console.log(error.statusCode, error.message);
+     * ```
+     */
     static fromResponse(statusCode: number, responseData: unknown): ApiError;
 }
 /** Thrown when client-side validation fails before the request is sent. */
 declare class ValidationError extends AssinafyError {
     readonly errors: Record<string, unknown>;
+    /**
+     * Create a client-side validation failure raised before network I/O.
+     *
+     * @param message - Human-readable validation summary.
+     * @param errors - Field/value diagnostics for programmatic handling.
+     *
+     * @example
+     * ```ts
+     * throw new ValidationError('Signer ID is required', { signerId: '' });
+     * ```
+     */
     constructor(message?: string, errors?: Record<string, unknown>);
 }
 /** Thrown when the HTTP transport itself fails (DNS, timeout, etc.). */
 declare class NetworkError extends AssinafyError {
+    /**
+     * Create a transport-layer failure such as DNS, connection, or timeout.
+     *
+     * @param message - Sanitized transport error summary.
+     * @param options - Standard JavaScript error options carrying a safe cause.
+     *
+     * @example
+     * ```ts
+     * throw new NetworkError('Request timed out', { cause });
+     * ```
+     */
     constructor(message: string, options?: ErrorOptions);
 }
 
-export { type AnyString, ApiError, type AssignmentMethod, type AssignmentNotificationMethod, AssignmentResource, type AssignmentVerificationMethod, AssinafyClient, type AssinafyClientOptions, AssinafyError, AuthenticationResource, type ClientConfigInput, DEFAULT_WEBHOOK_EVENTS, type DocumentArtifactName, DocumentResource, type DocumentStatus, type DocumentUploadSource, FieldsResource, type IApiKeyResponse, type IAssignment, type IAssignmentItem, type IAssignmentListParams, type IAssignmentListResponse, type IAssignmentSigner, type ICostEstimate, type ICreateAssignmentPayload, type ICreateAssignmentResponse, type ICreateDocumentFromTemplateOptions, type ICreateFieldPayload, type ICreateSignerPayload, type ICreateSignerResponse, type ICreateTagPayload, type ICreateWorkspacePayload, type IDocumentActivity, type IDocumentDetailsResponse, type IDocumentListItem, type IDocumentListParams, type IDocumentListResponse, type IDocumentSearchParams, type IDocumentStatusInfo, type IDocumentUploadOptions, type IDocumentUploadResponse, type IFieldDefinition, type IFieldType, type IFieldValidateMultipleEntry, type IFieldValidationResult, type IInlineTag, type IListParams, type ILoginResponse, type IMaskedApiKeyResponse, type IPage, type IPaginatedResponse, type IPublicDocumentInfo, type IRenameDocumentResponse, type IResendCostEstimate, type IResendEmailResponse, type ISignFieldEntry, type ISigner, type ISignerListResponse, type ISigningProgress, type ITag, type ITemplateDetailsResponse, type ITemplateListItem, type ITemplateListResponse, type ITemplateRole, type ITemplateSigner, type IUpdateFieldPayload, type IUpdateSignerPayload, type IUpdateTagPayload, type IUpdateTemplatePayload, type IUpdateWorkspacePayload, type IUploadAndRequestSignaturesResult, type IUploadAndRequestSignaturesSigner, type IWebhookDispatch, type IWebhookDispatchListParams, type IWebhookEventTypeInfo, type IWebhookPayload, type IWebhookRegisterPayload, type IWebhookSubscription, type IWhatsAppNotification, type IWorkspaceListItem, type IWorkspaceListResponse, type IWorkspaceResponse, type Logger, MAX_UPLOAD_BYTES, NetworkError, type PaginatedResult, type PaginationMeta, type SendTokenChannel, SignerDocumentsResource, type SignerReference, SignerResource, TagResource, TemplateResource, ValidationError, type WebhookEventType, WebhookResource, WebhookVerifier, WorkspaceResource, buildAssignmentPayload };
+export { type AccountLogoUploadSource, type AnyString, ApiError, type AssignmentMethod, type AssignmentNotificationMethod, AssignmentResource, type AssignmentVerificationMethod, AssinafyClient, type AssinafyClientOptions, AssinafyError, AuthenticationResource, type ClientConfigInput, DEFAULT_WEBHOOK_EVENTS, type DocumentArtifactName, DocumentResource, type DocumentStatsGranularity, type DocumentStatus, type DocumentUploadSource, FieldsResource, type IAccountTheme, type IApiKeyResponse, type IAssignment, type IAssignmentCostSigner, type IAssignmentEntry, type IAssignmentItem, type IAssignmentListParams, type IAssignmentListResponse, type IAssignmentSigner, type IAuthenticatedUser, type IConfirmSignerDataPayload, type ICostEstimate, type ICreateAssignmentPayload, type ICreateAssignmentResponse, type ICreateDocumentFromTemplateOptions, type ICreateFieldPayload, type ICreateSignerPayload, type ICreateSignerResponse, type ICreateTagPayload, type ICreateWorkspacePayload, type IDocumentActivity, type IDocumentDetailsResponse, type IDocumentListItem, type IDocumentListParams, type IDocumentListResponse, type IDocumentSearchParams, type IDocumentStatsParams, type IDocumentStatsRow, type IDocumentStatusInfo, type IDocumentUploadOptions, type IDocumentUploadResponse, type IDocumentVerification, type IEstimateAssignmentCostPayload, type IFieldDefinition, type IFieldType, type IFieldValidateMultipleEntry, type IFieldValidationResult, type IInlineTag, type ILegacyConfirmSignerDataPayload, type ILegacyResendCostEstimate, type ILegacyUploadSignatureOptions, type IListParams, type ILoginResponse, type IMaskedApiKeyResponse, type INotificationHistoryEntry, type IPage, type IPaginatedResponse, type IPublicDocumentInfo, type IRenameDocumentResponse, type IResendCostEstimate, type IResendEmailResponse, type ISignFieldEntry, type ISigner, type ISignerListResponse, type ISignerSelf, type ISigningProgress, type ITag, type ITemplateCostSigner, type ITemplateDetailsResponse, type ITemplateFieldPlacement, type ITemplateListItem, type ITemplateListResponse, type ITemplateRole, type ITemplateSigner, type IUpdateFieldPayload, type IUpdateSignerPayload, type IUpdateTagPayload, type IUpdateTemplatePayload, type IUpdateWorkspacePayload, type IUploadAndRequestSignaturesResult, type IUploadAndRequestSignaturesSigner, type IUploadSignatureOptions, type IWebhookDispatch, type IWebhookDispatchListParams, type IWebhookEventTypeInfo, type IWebhookPayload, type IWebhookRegisterPayload, type IWebhookSubscription, type IWhatsAppNotification, type IWorkspaceListItem, type IWorkspaceListResponse, type IWorkspaceResponse, type Logger, MAX_UPLOAD_BYTES, NetworkError, type NotificationSenderType, type PaginatedResult, type PaginationMeta, type SendTokenChannel, SignerDocumentsResource, type SignerReference, SignerResource, TagResource, TemplateResource, UserResource, ValidationError, type WebhookEventType, WebhookResource, WebhookVerifier, WorkspaceResource, buildAssignmentPayload };