assinafy 1.11.0 → 1.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97dcce395cbee3bd4a632650550becfd07d6fa291da434678d1a31de4488d103
-  data.tar.gz: 4cde25cfc6221e23378892c4fa19d7779046b65642bc33dc734756f712c2aab8
+  metadata.gz: 4c9d44ba9996ee18372b0c965c691f9a74695b98ffd85ebe5e43ae29a4f3b662
+  data.tar.gz: a0313ec17a476c5439eab8fd004936c337b4b99e14323b8dfd864553b68f22d9
 SHA512:
-  metadata.gz: 437fad120c4ec641767a2241f0e03589e14ea31b3407b603c85e7284476526711cd8d8f8732573d2ab4348aa9387cbfa077e43061ff91e1728eeda766b6c51f2
-  data.tar.gz: 9c2e1b81591e038d449145fa3f97f7b2b90f98fbfede435f01cd14fbfbb6b9d62805df762e39a01c0e9de7a8d9e729371d3b88e63b5049fb7ac29b0c10d01b88
+  metadata.gz: 4a3e1ef28628add0a0e5abfc6f59f09f5ea0fe09c067a6fbb8cb3b767771590479bb8493b525ce389d2a572f15eea8257ed9a1ba47e68e7be1297603777febbd
+  data.tar.gz: 159e300170cd02a74d7668084362b5c80f5e99eea2653e2fd5f9faa0a838446b3987f9d5cd9df131cf0f2feba6a0dd50fdae0de4351ebba213c92e942ea3d529

data/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to the `assinafy` Ruby gem are documented here.
 
+## [1.11.1] - 2026-10-12
+
+### Added
+
+- `Assinafy::ApiError#rate_limit` returns `{ limit:, remaining:, reset: }` from the `X-Rate-Limit-*` headers, and
+  `#retry_after` returns the `Retry-After` seconds of a `429 Too Many Requests`.
+- `SignerDocumentResource#list_as_workspace` and `#search_as_workspace` list and search a signer's documents with
+  the workspace API key or token.
+
+### Changed
+
+- `DocumentResource#send_token` always sends `{ "channel": "email", "recipient": "<signer email>" }`, as the API
+  requires, and returns `{ document, channel, recipient }`. `recipient:` (or the earlier `email:`) must be an email
+  address; calls without a recipient, with a `whatsapp` channel, or with a phone number now raise
+  `ValidationError`.
+- `SignerDocumentResource#list` and `#search` require the signer access code and never send workspace
+  credentials. Calls that relied on omitting the code to use the API key now raise `ValidationError`; switch them
+  to `#list_as_workspace` / `#search_as_workspace`.
+- `FieldResource#validate` and `#validate_multiple` raise `ValidationError` for an explicit `signer_access_code:
+  nil` instead of falling back to workspace credentials. Omitting the keyword still uses workspace credentials.
+- `AssignmentResource#estimate_cost` accepts payloads without `signers` or `entries`, which the API treats as
+  optional.
+- `DocumentResource#search` and `SignerDocumentResource#search` accept a `nil` search term and omit `search`.
+- `FieldResource#create` sends an explicit `regex: nil` as JSON `null`.
+- `DocumentResource#rename` rejects names longer than 255 characters before sending.
+
 ## 1.11.0
 
 ### Added

data/README.en.md

@@ -633,6 +633,7 @@ rescue Assinafy::ValidationError => e
   warn e.errors.inspect
 rescue Assinafy::ApiError => e
   warn "Assinafy returned #{e.status_code}: #{e.message}"
+  sleep(e.retry_after) if e.status_code == 429 && e.retry_after # also e.rate_limit => { limit:, remaining:, reset: }
 rescue Assinafy::NetworkError => e
   warn "Network failure: #{e.message}"
 end
@@ -712,7 +713,7 @@ client.documents.download_page('document-id', 'page-id')
 client.documents.delete('document-id')
 client.documents.verify('signature-hash')
 client.documents.public_info('document-id')
-client.documents.send_token('document-id', email: 'alice@example.com')
+client.documents.send_token('document-id', recipient: 'signer@example.com')
 client.documents.list_tags('document-id')
 client.documents.replace_tags('document-id', ['tag-id-1', 'tag-id-2'])
 client.documents.append_tags('document-id', ['tag-id-3'])
@@ -806,6 +807,8 @@ query parameter.
 client.signer_documents.current('signer-id', signer_access_code: 'code')
 client.signer_documents.list('signer-id', { status: 'pending_signature' }, signer_access_code: 'code')
 client.signer_documents.search('signer-id', 'contract', signer_access_code: 'code')
+client.signer_documents.list_as_workspace('signer-id')                 # same route with your API key
+client.signer_documents.search_as_workspace('signer-id', 'contract')
 client.signer_documents.sign_multiple(%w[document-id-1 document-id-2], signer_access_code: 'code')
 client.signer_documents.decline_multiple(%w[document-id-1 document-id-2], decline_reason: 'No', signer_access_code: 'code')
 client.signer_documents.download('signer-id', 'document-id', 'pades') # public: no access code needed

data/README.md

@@ -964,7 +964,9 @@ Toda exceção do SDK deriva de `Assinafy::Error` e carrega um `#context` com de
 depuração. `ApiError` trata as duas formas de corpo de erro da API — o erro de framework
 (`{"name":..., "code":..., "status":...}`) e o envelope de aplicação
 (`{"status":..., "data":null, "message":...}`) — inclusive quando um `200` traz um `status`
-interno de falha. Num `403`, `e.context[:www_authenticate]` traz o desafio OAuth, quando houver.
+interno de falha. Num `403`, `e.context[:www_authenticate]` traz o desafio OAuth, quando houver. Num `429`,
+`e.retry_after` traz os segundos de `Retry-After` e `e.rate_limit` traz `{ limit:, remaining:, reset: }` dos
+cabeçalhos `X-Rate-Limit-*`.
 
 ---
 

data/docs/API_REFERENCE.md

@@ -1,6 +1,6 @@
 # Assinafy Ruby SDK API Reference
 
-> Contract source: Assinafy API v1 OpenAPI 3.1.0, retrieved 2026-10-07 from
+> Contract source: Assinafy API v1 OpenAPI 3.1.0, retrieved 2026-10-12 from
 > `https://api.assinafy.com.br/v1/docs/openapi.json` (81 paths, 106 operations, 44 schemas).
 > `scripts/check_api_contract.rb` validates contract compatibility weekly.
 
@@ -109,7 +109,7 @@ Required parameters and object properties are marked with `*`.
 | POST | `/v1/documents/{documentId}/assignments/estimate-cost` | `AssignmentResource#estimate_cost` | Bearer token or `X-Api-Key` | path `documentId*`: string | required; `application/json` object { `method`: string; `signers`: Array<object { `verification_method`: string; `notification_methods`: Array<string> }>; `entries`: Array<object> } | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`CostEstimate`](#costestimate) } |
 | POST | `/v1/documents/{documentId}/assignments/{assignmentId}` | `AssignmentResource#sign` | `signer-access-code` query parameter | path `documentId*`: string<br>path `assignmentId*`: string | required; `application/json` Array<object { `itemId*`: string; `fieldId*`: string; `pageId*`: string; `value*`: string }> | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: object } |
 | PUT | `/v1/documents/{documentId}/assignments/{assignmentId}/reject` | `AssignmentResource#decline` | `signer-access-code` query parameter | path `documentId*`: string<br>path `assignmentId*`: string | required; `application/json` object { `decline_reason*`: string } | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: Array<any> } |
-| PUT | `/v1/documents/{documentId}/assignments/{assignmentId}/reset-expiration` | `AssignmentResource#reset_expiration` | Bearer token or `X-Api-Key` | path `documentId*`: string<br>path `assignmentId*`: string | required; `application/json` object { `expires_at`: string (date-time) } | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`Assignment`](#assignment) } |
+| PUT | `/v1/documents/{documentId}/assignments/{assignmentId}/reset-expiration` | `AssignmentResource#reset_expiration` | Bearer token or `X-Api-Key` | path `documentId*`: string<br>path `assignmentId*`: string | required; `application/json` object { `expires_at*`: string (date-time) or `null` to clear } | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`Assignment`](#assignment) } |
 | POST | `/v1/documents/{documentId}/assignments/{assignmentId}/signers/{signerId}/estimate-resend-cost` | `AssignmentResource#estimate_resend_cost` | Bearer token or `X-Api-Key` | path `documentId*`: string<br>path `assignmentId*`: string<br>path `signerId*`: string | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`CostEstimate`](#costestimate) } |
 | PUT | `/v1/documents/{documentId}/assignments/{assignmentId}/signers/{signerId}/resend` | `AssignmentResource#resend_notification` | Bearer token or `X-Api-Key` | path `documentId*`: string<br>path `assignmentId*`: string<br>path `signerId*`: string | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: object { `is_sent`: boolean; `document_id`: string; `signer_id`: string } } |
 | GET | `/v1/documents/{documentId}/assignments/{assignmentId}/whatsapp-notifications` | `AssignmentResource#whatsapp_notifications` | Bearer token or `X-Api-Key` | path `documentId*`: string<br>path `assignmentId*`: string | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: Array<[`WhatsappNotification`](#whatsappnotification)> } |
@@ -124,7 +124,7 @@ Required parameters and object properties are marked with `*`.
 | POST | `/v1/oauth/revoke` | `OAuthResource#revoke` | Public (client authenticates with `client_id` in the body) | None | required; `application/x-www-form-urlencoded` (RFC 7009; also accepts `application/json`) object { `token*`: string; `client_id*`: string; `token_type_hint`: string enum `access_token`, `refresh_token`; `client_secret`: string } | `200` empty body — every token outcome reports success |
 | GET | `/v1/oauth/userinfo` | `OAuthResource#userinfo` | Bearer token or `X-Api-Key`; requires the `openid` scope | None | None | `200` `application/json` **flat** object { `sub`: string; `name`: string (nullable); `email`: string (email, nullable); `email_verified`: boolean (nullable) } — not enveloped |
 | GET | `/v1/public/documents/{documentId}` | `DocumentResource#public_info` | Public | path `documentId*`: string | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`Document`](#document) } |
-| PUT | `/v1/public/documents/{documentId}/send-token` | `DocumentResource#send_token` | Public | path `documentId*`: string | optional; `application/json` object { `email`: string (email) } | `200` `application/json` [`Envelope`](#envelope) |
+| PUT | `/v1/public/documents/{documentId}/send-token` | `DocumentResource#send_token` | Public | path `documentId*`: string | required; `application/json` object { `channel*`: `"email"`; `recipient*`: string (signer email) } | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: object { `document`: object { `resource`, `id`, `name`, `page_count`, `created_by` }; `channel`: string; `recipient`: string } } |
 | GET | `/v1/sign` | `AssignmentResource#signer_document` | `signer-access-code` query parameter | query `has_accepted_terms`: boolean | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`Document`](#document) } |
 | POST | `/v1/signature` | `SignerResource#upload_signature` | `signer-access-code` query parameter | query `type`: string<br>query `reuse`: boolean | required; `image/png` string (binary) | `200` `application/json` [`Envelope`](#envelope) |
 | GET | `/v1/signature/{signatureType}` | `SignerResource#download_signature` | `signer-access-code` query parameter | path `signatureType*`: string | None | `200` `image/*` string (binary) |
@@ -133,8 +133,8 @@ Required parameters and object properties are marked with `*`.
 | PUT | `/v1/signers/documents/sign-multiple` | `SignerDocumentResource#sign_multiple` | `signer-access-code` query parameter | None | required; `application/json` object { `document_ids*`: Array<string> } | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: Array<any> } |
 | GET | `/v1/signers/self` | `SignerResource#self_data` | `signer-access-code` query parameter | None | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`SignerSelf`](#signerself) } |
 | GET | `/v1/signers/{signerId}/document` | `SignerDocumentResource#current` | `signer-access-code` query parameter | path `signerId*`: string | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`Document`](#document) } |
-| GET | `/v1/signers/{signerId}/documents` | `SignerDocumentResource#list` | `signer-access-code` query parameter | path `signerId*`: string<br>query `page`: integer<br>query `per-page`: integer | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: Array<[`Document`](#document)> } |
-| GET | `/v1/signers/{signerId}/documents/search` | `SignerDocumentResource#search` | `signer-access-code` query parameter | path `signerId*`: string<br>query `search`: string | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: Array<[`Document`](#document)> } |
+| GET | `/v1/signers/{signerId}/documents` | `SignerDocumentResource#list` (signer code); `#list_as_workspace` (Bearer token or `X-Api-Key`) | `signer-access-code` query parameter, or workspace credentials | path `signerId*`: string<br>query `page`: integer<br>query `per-page`: integer | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: Array<[`Document`](#document)> } |
+| GET | `/v1/signers/{signerId}/documents/search` | `SignerDocumentResource#search` (signer code); `#search_as_workspace` (Bearer token or `X-Api-Key`) | `signer-access-code` query parameter, or workspace credentials | path `signerId*`: string<br>query `search`: string | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: Array<[`Document`](#document)> } |
 | GET | `/v1/signers/{signerId}/documents/{documentId}/download/{artifactName}` | `SignerDocumentResource#download` | Public | path `signerId*`: string<br>path `documentId*`: string<br>path `artifactName*`: string | None | `200` `application/pdf` string (binary) |
 | GET | `/v1/users/api-keys` | `AuthResource#get_api_key` | Bearer token or `X-Api-Key` | None | None | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`ApiKey`](#apikey) } |
 | POST | `/v1/users/api-keys` | `AuthResource#create_api_key` | Bearer token or `X-Api-Key` | None | required; `application/json` object { `password*`: string (password) } | `200` `application/json` [`Envelope`](#envelope) plus object { `data`: [`ApiKey`](#apikey) } |
@@ -191,6 +191,10 @@ raise `Assinafy::ApiError`:
 - `error_name` and `error_code` expose framework `name` and `code` values when present.
 - `context` contains `status_code` and `response_data` for structured logging or support diagnostics, plus
   `www_authenticate` when the response carries that header.
+- `rate_limit` returns `{ limit:, remaining:, reset: }` from the `X-Rate-Limit-Limit`, `X-Rate-Limit-Remaining`
+  and `X-Rate-Limit-Reset` headers (reset in seconds), and `retry_after` returns the `Retry-After` seconds of a
+  `429 Too Many Requests`; both are `nil` when the headers are absent. Wait at least `retry_after` seconds before
+  retrying. Requests are limited per minute, per user when authenticated and per IP address otherwise.
 
 Transport, timeout, and TLS failures raise `Assinafy::NetworkError`; caller-side validation failures raise
 `Assinafy::ValidationError` before a request is sent.
@@ -351,6 +355,7 @@ return-value, and usage details.
 | `SignerResource#validate_create!` | Validate and normalize a signer-create body without a network request. | [`signer_resource.rb`](../lib/assinafy/resources/signer_resource.rb) |
 | `SignerResource#find_by_email` | Page through a successful search and return a case-insensitive match or `nil`. | [`signer_resource.rb`](../lib/assinafy/resources/signer_resource.rb) |
 | `SignerDocumentResource#document` | Alias for `#current`. | [`signer_document_resource.rb`](../lib/assinafy/resources/signer_document_resource.rb) |
+| `SignerDocumentResource#list_as_workspace`, `#search_as_workspace` | List/search a signer's documents with workspace credentials; `#list`/`#search` require the signer access code and send only it. | [`signer_document_resource.rb`](../lib/assinafy/resources/signer_document_resource.rb) |
 | `AuthResource#api_key` | Alias for `#get_api_key`. | [`auth_resource.rb`](../lib/assinafy/resources/auth_resource.rb) |
 | `WebhookResource#update` | Alias for `#register` (acts on the oldest endpoint). | [`webhook_resource.rb`](../lib/assinafy/resources/webhook_resource.rb) |
 | `AssignmentResource.build_payload` | Validate and normalize virtual or collect assignment bodies locally. | [`assignment_resource.rb`](../lib/assinafy/resources/assignment_resource.rb) |
@@ -359,7 +364,7 @@ return-value, and usage details.
 | `WebhookVerifier::SECRET_PREFIX`, `::DEFAULT_TOLERANCE` | The `whsec_` secret prefix and the default 300-second timestamp tolerance. | [`webhook_verifier.rb`](../lib/assinafy/support/webhook_verifier.rb) |
 | `WebhookVerifier#extract_event`, `#event_type`, `#event_payload`, `#event_object`, `#event_subject`, `#event_data` | Parse and access webhook envelope fields; `event_data` is retained as a compatibility helper. | [`webhook_verifier.rb`](../lib/assinafy/support/webhook_verifier.rb) |
 | `Assinafy::Error.new`, `#context` | Construct/read the SDK base error and its structured context. | [`errors.rb`](../lib/assinafy/errors.rb) |
-| `Assinafy::ApiError.new`, `.from_response`, `#status_code`, `#response_data`, `#error_name`, `#error_code` | Construct/read an API response error. | [`errors.rb`](../lib/assinafy/errors.rb) |
+| `Assinafy::ApiError.new`, `.from_response`, `#status_code`, `#response_data`, `#error_name`, `#error_code`, `#rate_limit`, `#retry_after` | Construct/read an API response error, including its rate-limit headers. | [`errors.rb`](../lib/assinafy/errors.rb) |
 | `Assinafy::ValidationError.new`, `#errors`; `Assinafy::NetworkError` | Represent caller-side validation and transport failures. | [`errors.rb`](../lib/assinafy/errors.rb) |
 | `Assinafy::OAuthError.new`, `.from_response`, `#error`, `#error_description` | Represent an OAuth endpoint failure; subclasses `ApiError`, so existing rescue clauses keep working. | [`errors.rb`](../lib/assinafy/errors.rb) |
 | `Assinafy::OAuth.generate_code_verifier`, `.code_challenge`, `.generate_state`, `.normalize_scope`, `.validate_code_verifier!`, `.authorization_url` | Build the PKCE pair, CSRF state, and authorization URL for the browser half of the OAuth flow. No network request. | [`oauth.rb`](../lib/assinafy/oauth.rb) |

data/lib/assinafy/errors.rb

@@ -52,6 +52,32 @@ module Assinafy
       @error_code = response_data['code']
     end
 
+    # Rate-limit window reported by the `X-Rate-Limit-Limit`, `X-Rate-Limit-Remaining` and
+    # `X-Rate-Limit-Reset` response headers. Only the headers present are included.
+    #
+    # @return [Hash{Symbol=>Integer}, nil] `{ limit:, remaining:, reset: }` (reset in seconds), or nil
+    # @example
+    #   e.rate_limit # => { limit: 60, remaining: 0, reset: 42 }
+    def rate_limit
+      context[:rate_limit]
+    end
+
+    # Seconds to wait before retrying, from the `Retry-After` header of a `429 Too Many Requests`.
+    #
+    # @return [Integer, nil]
+    # @example Back off on a rate-limited request
+    #   begin
+    #     client.documents.list
+    #   rescue Assinafy::ApiError => e
+    #     raise unless e.status_code == 429
+    #
+    #     sleep(e.retry_after || 1)
+    #     retry
+    #   end
+    def retry_after
+      context[:retry_after]
+    end
+
     # Build an {ApiError} from an HTTP status and parsed body. Reads the human
     # message from `message`, `error`, or `name` (in that order).
     #

data/lib/assinafy/resources/assignment_resource.rb

@@ -52,12 +52,14 @@ module Assinafy
         # - `signers: [{ id:, verification_method:, notification_methods:, step: }]`
         # - Legacy `signer_ids:`/`signerIds:` arrays of IDs
         #
-        # @note Both methods require top-level `signers`; `collect` additionally
-        #   requires positioned `entries`.
+        # @note Creation requires top-level `signers` for both methods, and `collect` additionally
+        #   requires positioned `entries`; both are optional in estimate-cost payloads.
         # @param payload [Hash]
         # @param options [Hash]
         # @option options [Boolean] :allow_signers_without_id allow estimate-cost
         #   payloads where method-only signer descriptors carry no id
+        # @option options [Boolean] :require_signers (true) false for estimate-cost payloads, where
+        #   `signers` and `entries` are optional; an empty `signers` list is then omitted
         # @return [Hash] string-keyed body suitable for {#create} / {#estimate_cost}
         # @raise [Assinafy::ValidationError] on missing required fields
         # @example Bare signer IDs are normalised into { id: } hashes (virtual method)
@@ -114,12 +116,13 @@ module Assinafy
           entries = p[:entries]
           method  = (p[:method] || 'virtual').to_s
 
-          validate_method!(method, signers, entries, p)
+          validate_method!(method, signers, entries, p, options.fetch(:require_signers, true))
           validate_optional_fields!(p)
 
           result = { method: method }
-          result[:signers] = signers.map { |ref| normalise_signer_ref(ref, options) }
-          validate_signing_steps!(result[:signers])
+          normalised = signers.map { |ref| normalise_signer_ref(ref, options) }
+          validate_signing_steps!(normalised)
+          result[:signers] = normalised unless normalised.empty?
           OPTIONAL_FIELDS.each { |key| result[key] = p[key] if p[key] }
           result[:entries] = entries if entries
           Utils.body_params(result)
@@ -127,13 +130,13 @@ module Assinafy
 
         private
 
-        def validate_method!(method, signers, entries, payload)
+        def validate_method!(method, signers, entries, payload, require_signers)
           unless METHODS.include?(method)
             raise ValidationError.new("Assignment method must be one of: #{METHODS.join(', ')}")
           end
+          return unless require_signers
 
-          # `signers` is required for both methods: creation needs to know who signs, and the
-          # estimate is priced per signer. Positioned fields do not replace this list.
+          # Creation needs `signers` for both methods; positioned fields do not replace this list.
           if signers.empty?
             raise ValidationError.new(
               'At least one signer is required',
@@ -356,7 +359,7 @@ module Assinafy
       # `id`. An empty descriptor (`{}`) defaults both methods to `Email`.
       #
       # @param document_id [String]
-      # @param payload     [Hash]
+      # @param payload     [Hash] `method`, and optional `signers` (method-only descriptors) and `entries`
       # @return [Hash] cost breakdown (documents, credits, needs_extra_document, extra_document_cost,
       #   total_credits, breakdown[], document_balance, credit_balance, has_sufficient_resources,
       #   blocking_reason, message)
@@ -379,7 +382,7 @@ module Assinafy
       #   # }
       def estimate_cost(document_id, payload)
         doc_id = require_id(document_id, 'Document ID')
-        body   = self.class.build_payload(payload, allow_signers_without_id: true)
+        body   = self.class.build_payload(payload, allow_signers_without_id: true, require_signers: false)
 
         call('Failed to estimate assignment cost') do
           http_post("documents/#{doc_id}/assignments/estimate-cost", body)

data/lib/assinafy/resources/base_resource.rb

@@ -17,6 +17,11 @@ module Assinafy
         total:        'x-pagination-total-count',
         last_page:    'x-pagination-page-count'
       }.freeze
+      RATE_LIMIT_HEADERS = {
+        limit:     'x-rate-limit-limit',
+        remaining: 'x-rate-limit-remaining',
+        reset:     'x-rate-limit-reset'
+      }.freeze
 
       # @param connection         [Faraday::Connection]
       # @param default_account_id [String, nil] used by `account_id` when no override is passed
@@ -297,23 +302,32 @@ module Assinafy
 
       # On a `403` the `WWW-Authenticate` challenge names the scope an OAuth
       # token is missing, which tells "reconnect with more scope" apart from
-      # "wrong workspace or role", so it travels with the error.
+      # "wrong workspace or role", so it travels with the error, as do the
+      # rate-limit headers a `429` needs for backing off.
       def check_status!(response, _label)
         return if (200..299).cover?(response.status)
 
-        raise with_challenge(error_class.from_response(response.status, response.body), response)
+        raise with_response_headers(error_class.from_response(response.status, response.body), response)
       end
 
-      # A 2xx envelope can still carry an error status, with the same challenge.
+      # A 2xx envelope can still carry an error status, with the same headers.
       def unwrap(response)
         Utils.handle_assinafy_response(response.body)
       rescue ApiError => e
-        raise with_challenge(e, response)
+        raise with_response_headers(e, response)
       end
 
-      def with_challenge(error, response)
-        challenge = response.headers&.[]('www-authenticate')
+      def with_response_headers(error, response)
+        headers = response.headers || {}
+        challenge = headers['www-authenticate']
         error.context[:www_authenticate] = challenge if challenge
+        rate_limit = RATE_LIMIT_HEADERS.filter_map do |key, header|
+          value = to_int(headers[header])
+          [key, value] if value
+        end.to_h
+        error.context[:rate_limit] = rate_limit unless rate_limit.empty?
+        retry_after = to_int(headers['retry-after'])
+        error.context[:retry_after] = retry_after if retry_after
         error
       end
 

data/lib/assinafy/resources/document_resource.rb

@@ -131,7 +131,7 @@ module Assinafy
       # Lightweight search over an account's documents (id/name/status/artifacts),
       # without the heavier per-document detail returned by {#list}.
       #
-      # @param query [String] free-text search term
+      # @param query [String, nil] optional free-text search term; nil omits `search`
       # @param params [Hash] extra query parameters (`status`, `page`, `per_page`, ...)
       # @param account_id_override [String, nil]
       # @return [Hash{Symbol=>Array,Hash}] `{ data: [...], meta: {..} | nil }`
@@ -162,10 +162,10 @@ module Assinafy
       #       # ... (one Hash per matching document)
       #     ]
       #   }
-      def search(query, params = {}, account_id_override = nil)
+      def search(query = nil, params = {}, account_id_override = nil)
         acc_id = account_id(account_id_override)
         filters = require_payload(params, 'Document search parameters')
-        require_string(query, 'Search query')
+        require_string(query, 'Search query') unless query.nil?
 
         call_list('Failed to search documents') do
           http_get("accounts/#{acc_id}/documents/search", filters.merge(search: query))
@@ -253,7 +253,7 @@ module Assinafy
       # Rename a document.
       #
       # @param document_id [String]
-      # @param name        [String] the new display name
+      # @param name        [String] the new display name (at most 255 characters)
       # @return [Hash] the updated document object (envelope `data` unwrapped)
       # @raise [Assinafy::ApiError] on an unsuccessful API response
       # @raise [Assinafy::NetworkError] on transport or TLS failure
@@ -281,7 +281,7 @@ module Assinafy
       #   }
       def rename(document_id, name)
         doc_id   = require_id(document_id, 'Document ID')
-        new_name = require_string(name, 'Name')
+        new_name = require_string(name, 'Name', max_length: 255)
 
         call('Failed to rename document') do
           http_patch("documents/#{doc_id}", body_params(name: new_name))
@@ -664,67 +664,41 @@ module Assinafy
         end
       end
 
-      # Send a 6-digit access token for the document to a signer (public endpoint).
-      # The current OpenAPI permits no body or an `{ email: }` body, while the
-      # deployed API requires `{ recipient:, channel: }` when a recipient is supplied.
+      # Email a 6-digit access token for the document to its signer (public endpoint;
+      # no workspace credentials are sent).
       #
       # @param document_id [String]
-      # @param recipient   [String, nil] deployed-API email address or WhatsApp phone number
-      # @param channel     [String, nil] deployed-API `email` or `whatsapp` channel
-      # @param email       [String, nil] email address for the current OpenAPI request shape
-      # @return [nil, Hash] `nil` for the OpenAPI's no-data envelope; the deployed
-      #   API returns `{ 'document' => {..}, 'channel' => String, 'recipient' => String }`
+      # @param recipient   [String] the signer's email address (required)
+      # @param channel     [String] delivery channel; only `"email"` is accepted
+      # @param email       [String, nil] earlier name for `recipient:`; sent as `recipient`
+      # @return [Hash] `{ 'document' => Hash, 'channel' => String, 'recipient' => String }`
       # @raise [Assinafy::ApiError] on an unsuccessful API response
       # @raise [Assinafy::NetworkError] on transport or TLS failure
-      # @raise [Assinafy::ValidationError] on invalid required input
+      # @raise [Assinafy::ValidationError] when the recipient is missing or not an email address,
+      #   when the channel is not `email`, or when both `recipient:` and `email:` are given
       # @see PUT /public/documents/{document_id}/send-token
-      # @example Ask the API to use the document's signer contact (no auth required)
-      #   client.documents.send_token('document-id')
+      # @example Email the access token to the signer (no auth required)
+      #   client.documents.send_token('document-id', recipient: 'signer@example.com')
       #
-      # @example Email a signer using the current OpenAPI request (no auth required)
       #   # Request: PUT /public/documents/{document_id}/send-token
-      #   # Body: { "email": "signer@example.com" }
-      #   client.documents.send_token('document-id', email: 'signer@example.com')
-      #
-      # @example Use the deployed-API request shape
-      #   # Body: { "recipient": "signer@example.com", "channel": "email" }
-      #   client.documents.send_token('document-id', recipient: 'signer@example.com', channel: 'email')
+      #   # Body: { "channel": "email", "recipient": "signer@example.com" }
       #
-      #   # Deployed-API response (unwrapped data payload):
-      #   {
-      #     'document' => {
-      #       'resource' => 'document',
-      #       'id' => 'doc1',
-      #       'name' => '1.pdf',
-      #       'page_count' => '1',
-      #       'created_by' => 'John Smith'
-      #     },
-      #     'channel' => 'email',
-      #     'recipient' => 'signer@example.com'
-      #   }
-      #   # => nil when the API returns the documented no-data envelope
-      def send_token(document_id, recipient: nil, channel: nil, email: nil)
+      #   # => {
+      #   #   'document'  => { 'resource' => 'document', 'id' => 'doc1', 'name' => '1.pdf',
+      #   #                    'page_count' => 1, 'created_by' => 'John Smith' },
+      #   #   'channel'   => 'email',
+      #   #   'recipient' => 'signer@example.com'
+      #   # }
+      def send_token(document_id, recipient: nil, channel: 'email', email: nil)
         doc_id = require_id(document_id, 'Document ID')
-        if email.nil? && recipient.nil? && channel.nil?
-          payload = nil
-        elsif !email.nil?
-          if recipient || channel
-            raise ValidationError.new('Use either email or recipient/channel, not both')
-          end
+        raise ValidationError.new('Use either recipient or email, not both') if recipient && email
+        raise ValidationError.new('Channel must be email') unless channel == 'email'
 
-          payload = { email: Utils.require_email(email) }
-        else
-          require_string(recipient, 'Recipient')
-          delivery_channel = require_present(channel, 'Channel').to_s
-          unless %w[email whatsapp].include?(delivery_channel)
-            raise ValidationError.new('Channel must be email or whatsapp')
-          end
-
-          payload = { recipient: recipient, channel: delivery_channel }
-        end
+        address = Utils.require_email(recipient || email)
 
         call('Failed to send signer token') do
-          http_put("public/documents/#{doc_id}/send-token", payload && body_params(payload), workspace_auth: false)
+          http_put("public/documents/#{doc_id}/send-token", { 'channel' => 'email', 'recipient' => address },
+                   workspace_auth: false)
         end
       end
 

data/lib/assinafy/resources/field_resource.rb

@@ -7,12 +7,17 @@ module Assinafy
     # See https://api.assinafy.com.br/v1/docs#field-definition for the
     # documentation of these endpoints.
     class FieldResource < BaseResource
+      # Default for `signer_access_code:`, telling an omitted keyword (workspace credentials)
+      # apart from an explicit nil (rejected).
+      WORKSPACE = Object.new.freeze
+      private_constant :WORKSPACE
+
       # Create a field definition.
       #
       # @param payload [Hash]
       # @option payload [String]  :type        required — e.g. `text`, `cpf`, `email` — see {#types}
       # @option payload [String]  :name        required — display label
-      # @option payload [String]  :regex       optional validation regex (text fields)
+      # @option payload [String, nil] :regex   optional validation regex (text fields); nil is sent as null
       # @option payload [Boolean] :is_required default `true`
       # @param account_id_override [String, nil]
       # @return [Hash] the created field definition (envelope `data` unwrapped)
@@ -41,7 +46,8 @@ module Assinafy
       #   # }
       def create(payload, account_id_override = nil)
         acc_id = account_id(account_id_override)
-        body   = body_params(require_payload(payload))
+        raw    = require_payload(payload)
+        body   = with_explicit_regex(raw, body_params(raw))
         require_string(body['name'], 'Field name')
         require_string(body['type'], 'Field type')
         require_boolean(body['is_required'], 'is_required') if body.key?('is_required')
@@ -163,9 +169,7 @@ module Assinafy
         acc_id = account_id(account_id_override)
         fid    = require_id(field_id, 'Field ID')
         raw    = require_payload(payload)
-        body   = body_params(raw)
-        body['regex'] = nil if (raw.key?(:regex) && raw[:regex].nil?) ||
-                               (raw.key?('regex') && raw['regex'].nil?)
+        body   = with_explicit_regex(raw, body_params(raw))
         require_string(body['name'], 'Field name') if body.key?('name')
         require_boolean(body['is_active'], 'is_active') if body.key?('is_active')
 
@@ -197,14 +201,15 @@ module Assinafy
 
       # Validate a single value against a field definition.
       #
-      # The OpenAPI declares workspace Authorization. The deployed API also
-      # accepts signer-access-code authentication; pass `signer_access_code:`
-      # to use that compatibility path without sending workspace credentials.
+      # The OpenAPI declares workspace Authorization, which is used when
+      # `signer_access_code:` is omitted. The deployed API also accepts the signer
+      # access code: when the keyword is given it must be a non-blank code, and
+      # only the code is sent (never the workspace credentials).
       #
       # @param field_id             [String]
       # @param value                [Object]
       # @param account_id_override  [String, nil]
-      # @param signer_access_code   [String, nil]
+      # @param signer_access_code   [String] optional keyword; nil or blank raises
       # @return [Hash{String=>Object}] `{ "type" =>, "success" =>, "error_message" => }`
       # @raise [Assinafy::ApiError] on an unsuccessful API response
       # @raise [Assinafy::NetworkError] on transport or TLS failure
@@ -221,12 +226,12 @@ module Assinafy
       # @example Validate as a signer (signer-access-code auth, sent as a query param)
       #   client.fields.validate('field-id', 'Some text', signer_access_code: 'signer-access-code')
       #   # => { "type" => "text", "success" => true, "error_message" => "" }
-      def validate(field_id, value, account_id_override = nil, signer_access_code: nil)
+      def validate(field_id, value, account_id_override = nil, signer_access_code: WORKSPACE)
         acc_id      = account_id(account_id_override)
         fid         = require_id(field_id, 'Field ID')
         raise ValidationError.new('Field value is required') if value.nil?
 
-        access_code = signer_access_code.nil? ? nil : require_signer_access_code(signer_access_code)
+        access_code = field_access_code(signer_access_code)
 
         call('Failed to validate field value') do
           http_post("accounts/#{acc_id}/fields/#{fid}/validate", body_params(value: value),
@@ -236,12 +241,12 @@ module Assinafy
 
       # Validate many `{ field_id:, value: }` pairs in a single call.
       #
-      # As with {#validate}, signer-access-code support is a deployed-API
-      # compatibility extension beyond the current OpenAPI security declaration.
+      # As with {#validate}, omitting `signer_access_code:` uses the workspace
+      # credentials; giving it requires a non-blank code and sends only the code.
       #
       # @param values               [Array<Hash>]
       # @param account_id_override  [String, nil]
-      # @param signer_access_code   [String, nil]
+      # @param signer_access_code   [String] optional keyword; nil or blank raises
       # @return [Array<Hash>] one validation Hash per input, each carrying its `field_id`
       # @raise [Assinafy::ApiError] on an unsuccessful API response
       # @raise [Assinafy::NetworkError] on transport or TLS failure
@@ -265,10 +270,10 @@ module Assinafy
       #   #   { "field_id" => "field-id-2", "type" => "email",
       #   #     "success" => true, "error_message" => "" }
       #   # ]
-      def validate_multiple(values, account_id_override = nil, signer_access_code: nil)
+      def validate_multiple(values, account_id_override = nil, signer_access_code: WORKSPACE)
         acc_id      = account_id(account_id_override)
         list        = require_array(values, 'Field values')
-        access_code = signer_access_code.nil? ? nil : require_signer_access_code(signer_access_code)
+        access_code = field_access_code(signer_access_code)
 
         call_array('Failed to validate field values') do
           http_post("accounts/#{acc_id}/fields/validate-multiple",
@@ -308,6 +313,16 @@ module Assinafy
 
       private
 
+      def field_access_code(signer_access_code)
+        signer_access_code.equal?(WORKSPACE) ? nil : require_signer_access_code(signer_access_code)
+      end
+
+      # `regex` is nullable: an explicit nil is sent as JSON null to clear it.
+      def with_explicit_regex(raw, body)
+        body['regex'] = nil if [:regex, 'regex'].any? { |key| raw.key?(key) && raw[key].nil? }
+        body
+      end
+
       def field_value_payload(item)
         payload = require_payload(item, 'Field value')
         field_id = payload.key?(:field_id) ? payload[:field_id] : payload['field_id']

data/lib/assinafy/resources/signer_document_resource.rb

@@ -8,8 +8,9 @@ module Assinafy
     #
     # - {#current}/{#document}, {#sign_multiple}, {#decline_multiple} require the
     #   `signer-access-code` URL parameter.
-    # - {#list} accepts EITHER the workspace `X-Api-Key` header OR the access
-    #   code; pass `signer_access_code:` only when authenticating as the signer.
+    # - {#list} and {#search} authenticate as the signer: they require the access
+    #   code and never send workspace credentials. The same routes also accept
+    #   workspace credentials; use {#list_as_workspace} / {#search_as_workspace} for that.
     # - {#download} only needs the document/artifact IDs.
     #
     # See https://api.assinafy.com.br/v1/docs#signer for the full
@@ -61,18 +62,16 @@ module Assinafy
 
       alias document current
 
-      # List all documents the signer has access to, with pagination metadata.
-      # This endpoint accepts either the workspace `X-Api-Key` header or the
-      # signer access code, so `signer_access_code:` is optional here; when nil
-      # it is omitted from the query and the header auth is used.
+      # List all documents the signer has access to, with pagination metadata,
+      # authenticated with the signer access code only (no workspace credentials).
       #
       # @param signer_id          [String]
       # @param params             [Hash] documented `page` and `per_page` query parameters
-      # @param signer_access_code [String, nil]
+      # @param signer_access_code [String] required; may also be given as `params[:signer_access_code]`
       # @return [Hash{Symbol=>Array,Hash}] `{ data: [...], meta: { current_page:, per_page:, total:, last_page: } }`
       # @raise [Assinafy::ApiError] on an unsuccessful API response
       # @raise [Assinafy::NetworkError] on transport or TLS failure
-      # @raise [Assinafy::ValidationError] on invalid required input
+      # @raise [Assinafy::ValidationError] on invalid required input, including a nil or blank access code
       # @see GET /signers/{signer_id}/documents
       # @example List the signer's documents with pagination
       #   page = client.signer_documents.list('signer-id',
@@ -103,27 +102,49 @@ module Assinafy
 
         call_list('Failed to list signer documents') do
           http_get("signers/#{sid}/documents", query.merge(signer_access_code: access_code),
-                   workspace_auth: access_code.nil?)
+                   workspace_auth: false)
+        end
+      end
+
+      # List a signer's documents with the workspace credentials (API key or Bearer token)
+      # instead of the signer access code. Same response as {#list}.
+      #
+      # @param signer_id [String]
+      # @param params    [Hash] documented `page` and `per_page` query parameters
+      # @return [Hash{Symbol=>Array,Hash}] `{ data: [...], meta: { current_page:, per_page:, total:, last_page: } }`
+      # @raise [Assinafy::ApiError] on an unsuccessful API response
+      # @raise [Assinafy::NetworkError] on transport or TLS failure
+      # @raise [Assinafy::ValidationError] on invalid input, or when `params` carries a signer access code
+      # @see GET /signers/{signer_id}/documents
+      # @example
+      #   client.signer_documents.list_as_workspace('signer-id', { page: 1, per_page: 15 })
+      #   # Request: GET /signers/{signer_id}/documents?page=1&per-page=15 (X-Api-Key header)
+      #   # => { data: [{ "id" => "document-id", "name" => "contract.pdf", ... }],
+      #   #      meta: { current_page: 1, per_page: 15, total: 1, last_page: 1 } }
+      def list_as_workspace(signer_id, params = {})
+        sid = require_id(signer_id, 'Signer ID')
+
+        call_list('Failed to list signer documents') do
+          http_get("signers/#{sid}/documents", workspace_query(params))
         end
       end
 
-      # Lightweight search over the signer's documents. Like {#list}, this
-      # accepts either the workspace `X-Api-Key` header or the signer access
-      # code, so `signer_access_code:` is optional.
+      # Lightweight search over the signer's documents, authenticated with the
+      # signer access code only (no workspace credentials).
       #
       # @param signer_id          [String]
-      # @param query              [String] free-text search term
+      # @param query              [String, nil] optional free-text search term; nil omits `search`
       # @param params             [Hash] optional deployment-specific query parameters
-      # @param signer_access_code [String, nil]
+      # @param signer_access_code [String] required; may also be given as `params[:signer_access_code]`
       # @return [Hash{Symbol=>Array,Hash}] `{ data: [...], meta: {..} | nil }`
       # @raise [Assinafy::ApiError] on an unsuccessful API response
       # @raise [Assinafy::NetworkError] on transport or TLS failure
-      # @raise [Assinafy::ValidationError] on invalid required input
+      # @raise [Assinafy::ValidationError] on invalid required input, including a nil or blank access code
       # @see GET /signers/{signer_id}/documents/search
       # @example Search the signer's documents
-      #   page = client.signer_documents.search('signer-id', 'contract')
+      #   page = client.signer_documents.search('signer-id', 'contract', signer_access_code: 'signer-access-code')
       #
-      #   # Request: GET /signers/{signer_id}/documents/search?search=contract
+      #   # Request: GET /signers/{signer_id}/documents/search?search=contract&signer-access-code=...
       #   # => {
       #   #   data: [
       #   #     { "id" => "document-id", "account_id" => "account-id", "name" => "contract.pdf",
@@ -134,15 +155,39 @@ module Assinafy
       #   #     }
       #   #   ]
       #   # }
-      def search(signer_id, query, params = {}, signer_access_code: nil)
+      def search(signer_id, query = nil, params = {}, signer_access_code: nil)
         sid                  = require_id(signer_id, 'Signer ID')
         filters, access_code = signer_query(params, signer_access_code)
-        require_string(query, 'Search query')
+        require_string(query, 'Search query') unless query.nil?
 
         call_list('Failed to search signer documents') do
           http_get("signers/#{sid}/documents/search",
                    filters.merge(search: query, signer_access_code: access_code),
-                   workspace_auth: access_code.nil?)
+                   workspace_auth: false)
+        end
+      end
+
+      # Search a signer's documents with the workspace credentials instead of the
+      # signer access code. Same response as {#search}.
+      #
+      # @param signer_id [String]
+      # @param query     [String, nil] optional free-text search term; nil omits `search`
+      # @param params    [Hash] optional deployment-specific query parameters
+      # @return [Hash{Symbol=>Array,Hash}] `{ data: [...], meta: {..} | nil }`
+      # @raise [Assinafy::ApiError] on an unsuccessful API response
+      # @raise [Assinafy::NetworkError] on transport or TLS failure
+      # @raise [Assinafy::ValidationError] on invalid input, or when `params` carries a signer access code
+      # @see GET /signers/{signer_id}/documents/search
+      # @example
+      #   client.signer_documents.search_as_workspace('signer-id', 'contract')
+      #   # Request: GET /signers/{signer_id}/documents/search?search=contract (X-Api-Key header)
+      #   # => { data: [{ "id" => "document-id", "name" => "contract.pdf", ... }] }
+      def search_as_workspace(signer_id, query = nil, params = {})
+        sid = require_id(signer_id, 'Signer ID')
+        require_string(query, 'Search query') unless query.nil?
+
+        call_list('Failed to search signer documents') do
+          http_get("signers/#{sid}/documents/search", workspace_query(params).merge(search: query))
         end
       end
 
@@ -256,7 +301,16 @@ module Assinafy
         ].compact
         raw_code = explicit_code.nil? ? embedded_codes.first : explicit_code
 
-        [query, raw_code.nil? ? nil : require_signer_access_code(raw_code)]
+        [query, require_signer_access_code(raw_code)]
+      end
+
+      def workspace_query(params)
+        query = require_payload(params, 'Signer document query parameters')
+        if query.keys.any? { |key| %w[signer_access_code signer-access-code].include?(key.to_s) }
+          raise ValidationError.new('Workspace requests must not carry a signer access code')
+        end
+
+        query
       end
     end
   end

data/lib/assinafy/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Assinafy
-  VERSION = '1.11.0'
+  VERSION = '1.11.1'
   USER_AGENT = "Assinafy-Ruby-SDK/v#{VERSION}".freeze
 end

data/sig/assinafy.rbs

@@ -50,6 +50,8 @@ module Assinafy
 
     def initialize: (String message, Integer status_code, ?untyped response_data) -> void
     def self.from_response: (Integer status_code, untyped response_data) -> ApiError
+    def rate_limit: () -> Hash[Symbol, Integer]?
+    def retry_after: () -> Integer?
   end
 
   class ValidationError < Error
@@ -150,6 +152,7 @@ module Assinafy
       STATS_GRANULARITIES: Array[String]
       AUTH_HEADERS: Array[String]
       PAGINATION_HEADERS: Hash[Symbol, String]
+      RATE_LIMIT_HEADERS: Hash[Symbol, String]
 
       def initialize: (untyped connection, ?String? default_account_id, ?_Logger? logger) -> void
     end
@@ -238,7 +241,7 @@ module Assinafy
 
       def upload: (upload_source source, ?params options) -> api_object
       def list: (?params params, ?String? account_id_override) -> list_result
-      def search: (String query, ?params params, ?String? account_id_override) -> list_result
+      def search: (?String? query, ?params params, ?String? account_id_override) -> list_result
       def statuses: () -> Array[api_object]
       def details: (String document_id) -> api_object
       def get: (String document_id) -> api_object
@@ -269,9 +272,9 @@ module Assinafy
       def send_token: (
         String document_id,
         ?recipient: String?,
-        ?channel: String?,
+        ?channel: String,
         ?email: String?
-      ) -> api_object?
+      ) -> api_object
       def list_tags: (String document_id, ?String? account_id_override) -> Array[api_object]
       def replace_tags: (String document_id, Array[String] tags, ?String? account_id_override) -> Array[api_object]
       def append_tags: (String document_id, Array[String] tags, ?String? account_id_override) -> Array[api_object]
@@ -309,7 +312,9 @@ module Assinafy
       def current: (String signer_id, signer_access_code: String) -> api_object
       def document: (String signer_id, signer_access_code: String) -> api_object
       def list: (String signer_id, ?params params, ?signer_access_code: String?) -> list_result
-      def search: (String signer_id, String query, ?params params, ?signer_access_code: String?) -> list_result
+      def list_as_workspace: (String signer_id, ?params params) -> list_result
+      def search: (String signer_id, ?String? query, ?params params, ?signer_access_code: String?) -> list_result
+      def search_as_workspace: (String signer_id, ?String? query, ?params params) -> list_result
       def sign_multiple: (Array[String] document_ids, signer_access_code: String) -> Array[api_object]
       def decline_multiple: (
         Array[String] document_ids,
@@ -385,12 +390,12 @@ module Assinafy
         String field_id,
         untyped value,
         ?String? account_id_override,
-        ?signer_access_code: String?
+        ?signer_access_code: String
       ) -> api_object
       def validate_multiple: (
         Array[params] values,
         ?String? account_id_override,
-        ?signer_access_code: String?
+        ?signer_access_code: String
       ) -> Array[api_object]
       def types: () -> Array[api_object]
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: assinafy
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.11.1
 platform: ruby
 authors:
 - Assinafy SDK Contributors
@@ -170,7 +170,7 @@ files:
 - lib/assinafy/utils.rb
 - lib/assinafy/version.rb
 - sig/assinafy.rbs
-homepage: https://github.com/assinafy/ruby-sdk
+homepage: https://www.assinafy.com.br
 licenses:
 - MIT
 metadata: