@beel_es/sdk 2.4.0 → 2.5.0

package/dist/index.d.ts

@@ -1053,6 +1053,10 @@ interface paths {
          *       invoice's registration. An invoice whose registration was rejected before reaching the
          *       AEAT, or that was voided without ever being registered, has no PDF and answers
          *       `400 INVOICE_NOT_REGISTERED_NO_PDF` immediately. Its `verifactu.error_message` says why.
+         *     - **Unavailable on our side:** when the invoice needs its VeriFactu QR and BeeL. cannot
+         *       produce the PDF, the answer is `409 INVOICE_PDF_UNAVAILABLE` immediately instead of a
+         *       `202` that would never end. Asking again does not help: contact support with the
+         *       `meta.request_id`. Once it is solved, the same request returns the PDF.
          *     - **Never modified:** the PDF of an issued invoice is generated once — with its VeriFactu QR
          *       when it applies — and stays the document you delivered. Voiding the invoice or issuing
          *       a corrective against it does not change the PDF: read the invoice's `status` to know it.
@@ -1088,7 +1092,8 @@ interface paths {
          *     PDF does not exist yet — right after issuing (whether or not the invoice goes through
          *     VeriFactu, since the PDF is generated asynchronously) or, for a VeriFactu invoice
          *     specifically, while it waits for the QR of its registration — the answer is `202`, as for
-         *     the PDF download.
+         *     the PDF download. When BeeL. cannot produce that PDF, the answer is
+         *     `409 INVOICE_PDF_UNAVAILABLE`, also as for the PDF download.
          */
         get: operations["getCompanyInvoicePreview"];
         put?: never;
@@ -3628,8 +3633,8 @@ interface paths {
          *       ownership you may keep or lower your access, but only they can raise it.
          *     - **Billing:** the level never affects it — you pay for the account's subscription at any
          *       level.
-         *     - **`OPERATE`:** issuing invoices on the holder's behalf additionally requires a signed
-         *       fiscal representation from them.
+         *     - **`OPERATE`:** issuing invoices on the holder's behalf in Live additionally requires a
+         *       signed fiscal representation from them. In Test you can issue from the start.
          *     - **Entitlement:** requires `manage_accounts`.
          */
         patch: operations["changeManagedAccountAccessLevel"];
@@ -4385,6 +4390,13 @@ interface paths {
          *     - **`legal_name_verified`:** tells those two cases apart.
          *     - **`census_status`:** says whether an identified NIF is also deregistered or revoked.
          *
+         *     ## In sandbox
+         *
+         *     With a `beel_sk_test_` key the AEAT register is not queried. Syntax is still checked: a
+         *     well-formed NIF comes back `VALID` with the `legal_name` you sent, `legal_name_verified: false`
+         *     and no `census_status`; a malformed one comes back `INVALID`. Use a Live key to check the real
+         *     register.
+         *
          *     ## Invalid input
          *
          *     - **Bad syntax is an answer, not an error:** it comes back `200` with `status: INVALID`, so
@@ -4784,7 +4796,8 @@ interface paths {
          *       `GET /v1/companies/{company_id}/representation/document`, sign it digitally and return
          *       it through `POST /v1/companies/{company_id}/representation/submit`.
          *     - **Fiscal identity:** must be complete before the document can be produced. An incomplete
-         *       one is rejected with `400` naming what is missing.
+         *       one is rejected with `422` `PROFILE_INCOMPLETE` naming what is missing. The street number
+         *       is not required.
          *     - **Existing representation:** a company that already holds an active one is rejected too.
          *       Cancel it first.
          */
@@ -4932,6 +4945,109 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/companies/{company_id}/email-configuration": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Unique identifier (UUID) of the company the operation acts on: its identifier, not its NIF. It is the only source of context: the account that owns it is derived from it, and the `BeeL-Active-Company` header plays no part. A company you do not reach answers `403`, and so does a company that does not exist, so the existence of a company in another account is never disclosed. */
+                company_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get the email configuration of a company
+         * @description Returns the address the invoice emails of the company are sent from and the defaults that
+         *     apply when an invoice is sent by email. It applies only to invoice emails.
+         *
+         *     - **`sender.source`, `sender.email_domain_id` and `sender.local_part`:** what the company
+         *       chose. A `local_part` that is `null` means `facturas`.
+         *     - **`sender.effective`:** the address the next invoice email will go out from, and why
+         *       (`reason`). With `source` `BEEL` it is the address of BeeL. Otherwise it is resolved in
+         *       this order: the email domain chosen by the company and the default email domain of the
+         *       account, then the address of BeeL. Only email domains that are verified, and only while
+         *       the account holds the custom email domain add-on, count. The add-on is contracted with
+         *       BeeL. `email_domain_id` is present only when the address uses one of the account's email
+         *       domains.
+         *     - **`defaults`:** the content applied to an invoice email that does not specify its own. Each
+         *       property is `null` when it is not set.
+         *     - **Domain no longer verified:** invoice emails go out from BeeL. without interruption, and
+         *       `reason` reports it.
+         *     - **Environment:** the configuration belongs to the company and is the same in test and live.
+         */
+        get: operations["getCompanyEmailConfiguration"];
+        /**
+         * Replace the email configuration of a company
+         * @description Replaces the sender chosen for the invoice emails of the company, and optionally their
+         *     defaults. It does not affect other emails. The sender is a replacement, not a merge: a
+         *     property that is omitted or `null` goes back to its default, which is to inherit the default
+         *     email domain of the account and to use `facturas` as the `local_part`. The response is the
+         *     configuration as it is after the change, including the address in effect.
+         *
+         *     - **`sender.source`:** when omitted it is `EMAIL_DOMAIN` if `email_domain_id` is sent and
+         *       `ACCOUNT_DEFAULT` otherwise. `email_domain_id` is accepted only with `EMAIL_DOMAIN`, and
+         *       `local_part` is not accepted with `BEEL`: any other combination answers `422`
+         *       `VALIDATION_ERROR`.
+         *     - **`defaults`:** omitted, the stored defaults stay as they are. `null` removes them. An
+         *       object replaces all of them, so a property left out of it is removed. Sending an object
+         *       requires the email customization plan: without it the call answers `403`
+         *       `FEATURE_NOT_AVAILABLE`, and the sender is not changed. The templates accept the variables
+         *       listed by `GET /v1/email-template-variables`.
+         *     - **`email_domain_id`:** an email domain of the account that has already been registered. A
+         *       domain that does not exist, belongs to another account or was removed answers `404`
+         *       `EMAIL_DOMAIN_NOT_FOUND`; one that is still being registered answers `409`
+         *       `EMAIL_DOMAIN_NOT_READY`. Choosing a domain that is not verified is allowed: until it is
+         *       verified, invoice emails go out from the default email domain of the account if that one is
+         *       verified, and from BeeL. otherwise.
+         *     - **`local_part`:** up to 64 characters: lowercase letters, digits and the symbols
+         *       `!#$%&'*+/=?^_\`{|}~-`, with single dots between groups. Any other value answers `422`
+         *       `VALIDATION_ERROR`.
+         *     - **Removed email domains:** when the email domain a company chose is removed, the company
+         *       goes back to `ACCOUNT_DEFAULT` and keeps its `local_part`.
+         *     - **Credentials:** it changes the address real invoices are sent from, so it requires a live
+         *       API key and the `companies:write` scope. A test API key answers `403`
+         *       `LIVE_CREDENTIAL_REQUIRED`. Send an `Idempotency-Key` so a retry does not repeat the
+         *       operation.
+         *     - **Environment:** the configuration belongs to the company and is the same in test and live.
+         */
+        put: operations["updateCompanyEmailConfiguration"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/email-template-variables": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the variables of the email templates
+         * @description Returns the placeholders that the `subject` and `message` of the email templates accept,
+         *     such as `defaults.subject` in `GET /v1/companies/{company_id}/email-configuration`. Write a
+         *     placeholder, braces included, wherever the value should appear: it is replaced when the
+         *     email is sent.
+         *
+         *     - **Scope:** the catalogue is the same for every credential and does not depend on any
+         *       account or company, so the operation takes no identifier.
+         *     - **Unknown placeholders:** a placeholder that is not listed is sent as written.
+         *
+         *     **Closed catalogue.** This collection is fixed and bounded: it carries no `pagination`, it
+         *     takes no `page`/`limit`, and every response holds the whole set.
+         */
+        get: operations["listEmailTemplateVariables"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/companies/{company_id}/verifactu-configuration": {
         parameters: {
             query?: never;
@@ -5371,6 +5487,10 @@ interface paths {
          *       under the NIF it was sealed with. To move it, first
          *       `DELETE /v1/companies/{company_id}/payment-connections/{connection_id}` on the NIF
          *       that holds it, then open a new authorization on the NIF you want it under.
+         *       A provider account that was disconnected but already has payments recorded under a NIF
+         *       cannot be moved to another NIF: the callback fails with
+         *       `OAUTH_ACCOUNT_HAS_HISTORY_IN_OTHER_COMPANY`, and the way forward is to connect a new
+         *       provider account for the other NIF. Without recorded payments the move is allowed.
          */
         post: operations["initiatePaymentConnection"];
         delete?: never;
@@ -6378,6 +6498,191 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/accounts/{account_id}/email-domains": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * List the email domains
+         * @description Returns the domains the account sends its emails from, each with the DNS records to publish
+         *     and the verification status of the domain and of every record. It only reads; it does not
+         *     register or verify anything.
+         *
+         *     - **Without the add-on:** the list is still returned, so you can see what the account
+         *       holds, and `max_email_domains` is `0`.
+         *     - **`max_email_domains`:** the maximum number of domains the custom email domain add-on allows the
+         *       account; `null` when the add-on sets no explicit limit. The add-on is contracted with
+         *       BeeL.
+         *     - **`verified_at` and `last_checked_at`:** absent until the domain is verified or checked
+         *       for the first time.
+         *     - **Environment:** domains belong to the account and are the same in test and live.
+         *
+         *     **Closed catalogue.** The domains of an account are a short, bounded set: the response
+         *     carries no `pagination`, the operation takes no paging parameters, and every response holds the
+         *     whole set.
+         */
+        get: operations["listAccountEmailDomains"];
+        put?: never;
+        /**
+         * Register an email domain
+         * @description Registers a domain to send your account's emails from and returns the DNS records you have to
+         *     publish for it. The domain starts `PENDING`; publish the records and ask for the check with
+         *     `POST /v1/accounts/{account_id}/email-domains/{email_domain_id}/verify`. A domain that is not
+         *     `VERIFIED` 72 hours after it was registered is removed and its name is freed.
+         *
+         *     - **Add-on:** requires the custom email domain add-on, which is contracted with BeeL. Without
+         *       it the call answers `403 FEATURE_NOT_AVAILABLE`.
+         *     - **Default:** the first domain of an account, or the new one when the account has no default
+         *       domain, becomes the default; otherwise the default does not change.
+         *     - **`EMAIL_DOMAIN_INVALID` (`422`):** the text is not a full domain name. Internationalised names
+         *       are accepted and stored in their ASCII form.
+         *     - **`EMAIL_DOMAIN_RESERVED` (`422`):** the domain cannot be used as a sending domain, for example because it belongs to BeeL
+         *       or to a public mailbox provider.
+         *     - **`EMAIL_DOMAIN_UNAVAILABLE` (`409`):** the domain is already in use: registered by your account,
+         *       by another account, or already held in the sending service BeeL uses. The answer is the same in
+         *       every case and says nothing about who holds it.
+         *     - **While it registers:** a domain that is still registering shows `status: PENDING` with
+         *       `dns_records: []`. Read it again in a few seconds; if it stays that way, remove it with `DELETE`
+         *       and register it again.
+         *     - **`EMAIL_DOMAIN_LIMIT_REACHED` (`409`):** the account already holds as many domains as the
+         *       add-on allows; `error.details.limit` carries that number.
+         *     - **Unpaid billing:** when the billing of the account is unpaid the call answers `402 PAYMENT_REQUIRED`.
+         *     - **Credentials:** it changes the real account, so it requires a live API key or a dashboard
+         *       session. A test API key answers `403 LIVE_CREDENTIAL_REQUIRED`. Send an `Idempotency-Key` so a retry
+         *       does not repeat the operation.
+         */
+        post: operations["createAccountEmailDomain"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/accounts/{account_id}/email-domains/{email_domain_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+                /** @description Identifier of the email domain. */
+                email_domain_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get an email domain
+         * @description Returns one domain of your account with the DNS records to publish and the verification
+         *     status of the domain and of every record. It only reads; it does not verify anything. A domain
+         *     still registering shows `status: PENDING` with `dns_records: []`.
+         *
+         *     It works without the custom email domain add-on, so you can inspect what the account holds.
+         *     A domain of another account, or one already removed, answers `404`.
+         */
+        get: operations["getAccountEmailDomain"];
+        put?: never;
+        post?: never;
+        /**
+         * Remove an email domain
+         * @description Removes the domain from your account and from the email sending service, which frees the name so
+         *     it can be registered again. The account's emails stop being sent from it.
+         *
+         *     - **Without the add-on:** it works, so you can clean up what the account still holds.
+         *     - **Default domain:** removing the default leaves the account without one; its emails go out
+         *       from BeeL until you set another.
+         *     - **Name:** the name is free for a new registration as soon as the call returns. If the removal in
+         *       the sending service fails afterwards, an immediate new registration of the same name may answer
+         *       `EMAIL_DOMAIN_UNAVAILABLE` for a while.
+         *     - **Still registering:** a domain that stays `PENDING` with `dns_records: []` is removed this way.
+         *     - **Credentials:** it changes the real account, so it requires a live API key or a dashboard
+         *       session. A test API key answers `403 LIVE_CREDENTIAL_REQUIRED`. Send an `Idempotency-Key` so a
+         *       retry does not repeat the operation.
+         */
+        delete: operations["deleteAccountEmailDomain"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/accounts/{account_id}/email-domains/{email_domain_id}/verify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+                /** @description Identifier of the email domain. */
+                email_domain_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Verify an email domain
+         * @description Asks for the DNS records of the domain to be checked, once you have published them. The check
+         *     is asynchronous: the call returns `202` with the domain as it is now, usually still `PENDING`,
+         *     and its `status` changes to `VERIFIED` or `FAILED` when the check finishes. Read the domain with
+         *     `GET` to see the result. A domain that is not `VERIFIED` 72 hours after it was registered is
+         *     removed and its name is freed.
+         *
+         *     - **Add-on:** requires the custom email domain add-on, which is contracted with BeeL. Without
+         *       it the call answers `403 FEATURE_NOT_AVAILABLE`.
+         *     - **`EMAIL_DOMAIN_NOT_READY` (`409`):** the domain is still registering (`dns_records: []`); repeat
+         *       the call in a few seconds.
+         *     - **Sending service failure:** if the check cannot be requested the call fails with `502` and nothing changes.
+         *     - **Unpaid billing:** when the billing of the account is unpaid the call answers `402 PAYMENT_REQUIRED`.
+         *     - **Credentials:** it requires a live API key or a dashboard session. A test API key answers
+         *       `403 LIVE_CREDENTIAL_REQUIRED`. Send an `Idempotency-Key` so a retry does not repeat the operation.
+         */
+        post: operations["verifyAccountEmailDomain"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/accounts/{account_id}/email-domains/{email_domain_id}/default": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+                /** @description Identifier of the email domain. */
+                email_domain_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Set the default email domain
+         * @description Makes this domain the one the account's emails are sent from by default, and clears the
+         *     flag on the domain that had it, so the account always has at most one default.
+         *
+         *     - **Repeatable:** it states the desired default rather than performing a change, so
+         *       repeating the call on the domain that already is the default returns the same `200`.
+         *     - **Any status:** a domain can be the default while it is still `PENDING` or `FAILED`.
+         *       Emails only leave from it once it is `VERIFIED`; until then they go out from BeeL.
+         *     - **Without the add-on:** it works, so an account can still choose among the domains it holds.
+         *     - **Credentials:** it changes the real account, so it requires a live API key or a dashboard
+         *       session. A test API key answers `403 LIVE_CREDENTIAL_REQUIRED`. Send an `Idempotency-Key` so a
+         *       retry does not repeat the operation.
+         */
+        put: operations["setAccountEmailDomainDefault"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/emails": {
         parameters: {
             query?: never;
@@ -7865,7 +8170,8 @@ interface components {
             attach_source_invoices?: boolean;
             /**
              * @description Only applies when `send_automatically` is `true`.
-             *     Overrides default email settings. If it names no recipients, the email goes to the
+             *     Overrides the `defaults` of the company's email configuration: its `subject`, `message`
+             *     and `cc` are sent with the email. If it names no recipients, the email goes to the
              *     customer's `billing_emails`, or to the customer's `email` when there are none.
              */
             email_config?: components["schemas"]["EmailConfiguration"];
@@ -8077,12 +8383,16 @@ interface components {
              */
             cc?: components["schemas"]["Email"][];
             /**
-             * @description Custom email subject (optional, if not specified uses a default)
+             * @description Custom email subject (optional). Priority: the request that sends the email > this
+             *     `email_config.subject` > the `defaults.subject` of the company's email configuration >
+             *     the standard subject.
              * @example Invoice 2025/0001 - Web development services
              */
             subject?: string;
             /**
-             * @description Custom message (optional, added to email body)
+             * @description Custom message (optional, added to the email body). It is sent with the email.
+             *     Priority: the request that sends the email > this `email_config.message` > the
+             *     `defaults.message` of the company's email configuration > the standard message.
              * @example Dear customer, please find attached the invoice for the services provided. Thank you for your trust.
              */
             message?: string;
@@ -8096,13 +8406,13 @@ interface components {
             /**
              * @description CC recipients. Copied addresses count as recipients of the message: they are subject
              *     to the same sending restrictions and to the same quota as the addresses in `recipients`.
-             *     When omitted, the CC addresses configured in the sender's email defaults apply; send an
-             *     empty array to deliver the message without any copy.
+             *     When omitted, the invoice's `email_config.cc` applies, then the CC addresses in the `defaults` of the
+             *     company's email configuration; send an empty array to deliver the message without any copy.
              */
             cc?: components["schemas"]["Email"][];
-            /** @description Email subject (optional, if not specified uses a default) */
+            /** @description Email subject. When omitted, the invoice's `email_config.subject` applies, then the `defaults.subject` of the company's email configuration, then the standard subject. */
             subject?: string;
-            /** @description Custom message (optional, added before standard message) */
+            /** @description Custom message, added before the standard message. When omitted, the invoice's `email_config.message` applies, then the `defaults.message` of the company's email configuration, then the standard message. */
             message?: string;
             /** @default true */
             attach_pdf?: boolean;
@@ -9061,7 +9371,7 @@ interface components {
          *     - {NUM}: Sequential number without padding (e.g., "1")
          *     - {NUM:X}: Sequential number with padding (e.g., {NUM:4} → "0001")
          *
-         *     **REQUIRED**: Must contain at least {NUM} or {NUM:X}
+         *     **REQUIRED**: Must contain exactly one {NUM} or {NUM:X}
          *     **IMPORTANT**: Only uppercase (rejects {yy}, {mm}, {codigo}, etc.)
          *
          *     Valid examples:
@@ -10552,8 +10862,13 @@ interface components {
             preview_days?: number;
             /** Format: date */
             end_date?: string | null;
-            /** Format: uuid */
-            series_id: string;
+            /**
+             * Format: uuid
+             * @description Series the generated invoices are numbered in. Omit it to use the company's default
+             *     series for `invoice_type`. With no default standard series the call answers `422`
+             *     `SERIES_DEFAULT_NOT_FOUND`; the default simplified series is created on first use.
+             */
+            series_id?: string;
             invoice_type: components["schemas"]["RecurringInvoiceType"];
             /**
              * @description Total number of invoices this template will generate before ending on its own, between
@@ -11077,8 +11392,8 @@ interface components {
              */
             aeat_environment?: components["schemas"]["Environment"] | null;
             /**
-             * @description Account-level lifecycle, identical for every company of the account. AEAT emission
-             *     additionally requires the per-NIF representation to be signed.
+             * @description Account-level lifecycle, identical for every company of the account. AEAT emission in
+             *     Live additionally requires the per-NIF representation to be signed.
              */
             account_state?: components["schemas"]["AccountState"];
             /**
@@ -11343,6 +11658,8 @@ interface components {
              *     (the provider rejected the code exchange), `ACCESS_DENIED` (the account holder declined
              *     at the provider), `OAUTH_ACCOUNT_CONNECTED_TO_OTHER_COMPANY` (the provider account is
              *     already connected to another NIF; disconnect it there first),
+             *     `OAUTH_ACCOUNT_HAS_HISTORY_IN_OTHER_COMPANY` (the provider account has payments recorded
+             *     under another NIF; connect a new provider account for this NIF),
              *     `PROVIDER_ERROR` (any other provider-reported failure) or
              *     `OAUTH_UNEXPECTED`. When omitted, the callback redirects to BeeL's default integrations
              *     screen. A `return_url` that is not an absolute `https://` URL with a host is rejected
@@ -11430,10 +11747,12 @@ interface components {
             series?: components["schemas"]["CompanyPaymentConnectionSeries"];
             /**
              * Format: double
-             * @deprecated
-             * @description Deprecated. No longer affects auto-invoicing: a buyer with a tax ID and full address
-             *     always gets an ordinary invoice; without them, a simplified one up to 3,000 EUR.
-             *     Still accepted and returned.
+             * @description Amount in EUR up to which a charge whose buyer has no complete fiscal data (tax ID, name
+             *     and address) is invoiced as a simplified invoice. Above it, the charge is not issued: it
+             *     waits as a draft standard invoice until the buyer's fiscal data is completed. A buyer with
+             *     complete fiscal data always gets a standard invoice, whatever the amount. Up to 400.00 is
+             *     the general limit; a higher value, up to 3000.00, is the issuer's statement that its
+             *     activity is one of those in article 4.2 of RD 1619/2012 (rule SIM-002).
              * @example 400
              */
             simplificada_threshold?: number;
@@ -11486,10 +11805,13 @@ interface components {
             series?: components["schemas"]["UpdateCompanyPaymentConnectionSeries"];
             /**
              * Format: double
-             * @deprecated
-             * @description Deprecated. No longer affects auto-invoicing: a buyer with a tax ID and full address
-             *     always gets an ordinary invoice; without them, a simplified one up to 3,000 EUR.
-             *     Still accepted; between 0.01 and 3000.00.
+             * @description Amount in EUR up to which a charge whose buyer has no complete fiscal data (tax ID, name
+             *     and address) is invoiced as a simplified invoice. Above it, the charge is not issued: it
+             *     waits as a draft standard invoice until the buyer's fiscal data is completed. A buyer with
+             *     complete fiscal data always gets a standard invoice, whatever the amount. Up to 400.00 is
+             *     the general limit; a higher value, up to 3000.00, is the issuer's statement that its
+             *     activity is one of those in article 4.2 of RD 1619/2012 (rule SIM-002). Omit to keep
+             *     the current value.
              */
             simplificada_threshold?: number;
             /**
@@ -11529,9 +11851,11 @@ interface components {
              */
             external_event_id: string;
             /**
-             * @description Canonical identity of the payment at the provider. On Stripe this is always the
-             *     PaymentIntent id (`pi_…`), so every event of the same payment carries the same value
-             *     and can be grouped by it. Null while the identity is not yet resolved.
+             * @description Canonical identity of the payment at the provider. On Stripe this is the
+             *     PaymentIntent id (`pi_…`); for a charge without a PaymentIntent, the Charge id
+             *     (`ch_…`); for a Stripe invoice paid outside Stripe, the payment record id (`pr_…`).
+             *     Every event of the same payment carries the same value and can be grouped by it.
+             *     Null while the identity is not yet resolved.
              *     To trace the event back to the object that delivered it, use `source_object_id`.
              * @example pi_1234567890
              */
@@ -11580,11 +11904,12 @@ interface components {
             status: components["schemas"]["PaymentEventStatus"];
             /**
              * Format: uuid
-             * @description Invoice generated from the event, when there is one.
+             * @description The invoice currently in force for this payment: when the simplified invoice it generated
+             *     was exchanged, the full invoice that replaced it. `null` when the event produced no invoice.
              */
             invoice_id?: string | null;
             /**
-             * @description Number of the invoice generated from the event. `null` while that invoice is still a
+             * @description Number of the invoice in `invoice_id`. `null` while that invoice is still a
              *     draft — a draft has no number yet — and `null` when the event produced no invoice.
              * @example 2026/0042
              */
@@ -11606,6 +11931,7 @@ interface components {
              *     for reasons outside your control are excluded.
              */
             needs_action: boolean;
+            outcome: components["schemas"]["PaymentEventOutcome"];
             /**
              * @description Whether a draft invoice can be generated from this event. When `false`, the draft
              *     operation would be rejected.
@@ -11898,6 +12224,111 @@ interface components {
             };
             meta?: components["schemas"]["ResponseMeta"];
         };
+        /**
+         * @description Verification status of an email domain, and of each of its DNS records.
+         *
+         *     - PENDING: the records have not been detected yet, or verification is in progress. A domain that
+         *       is not `VERIFIED` 72 hours after it was registered is removed
+         *     - VERIFIED: the records were detected and the domain can be used to send
+         *     - FAILED: verification did not succeed; check that the records are published as shown
+         * @enum {string}
+         */
+        EmailDomainStatus: "PENDING" | "VERIFIED" | "FAILED";
+        /**
+         * @description Type of a DNS record.
+         * @enum {string}
+         */
+        DnsRecordType: "MX" | "TXT" | "CNAME";
+        /** @description A DNS record the domain owner has to publish for the domain to be verified. */
+        DnsRecord: {
+            type: components["schemas"]["DnsRecordType"];
+            /**
+             * @description Host name of the record, relative to the domain.
+             * @example send
+             */
+            name: string;
+            /**
+             * @description Content the record must have.
+             * @example mail.example.com
+             */
+            value: string;
+            /**
+             * @description Priority of the record. Only present on `MX` records.
+             * @example 10
+             */
+            priority?: number;
+            status: components["schemas"]["EmailDomainStatus"];
+        };
+        /** @description A domain an account sends its emails from. */
+        EmailDomain: {
+            /**
+             * Format: uuid
+             * @description Identifier of the email domain.
+             * @example 550e8400-e29b-41d4-a716-446655440000
+             */
+            id: string;
+            /**
+             * @description Fully qualified domain name, in lowercase.
+             * @example facturas.ejemplo.com
+             */
+            domain: string;
+            status: components["schemas"]["EmailDomainStatus"];
+            /**
+             * @description Whether this is the domain the account's emails are sent from by default.
+             * @example true
+             */
+            is_default: boolean;
+            /**
+             * @description Records to publish in the domain's DNS, with the verification status of each. Empty (`[]`) while
+             *     the domain is still registering, with `status: PENDING`: read it again in a few seconds, or
+             *     remove it with `DELETE` if it stays empty.
+             */
+            dns_records: components["schemas"]["DnsRecord"][];
+            /**
+             * Format: date-time
+             * @description Moment the domain was registered.
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description Moment the domain was verified. Absent until it is.
+             */
+            verified_at?: string;
+            /**
+             * Format: date-time
+             * @description Moment the records were last checked. Absent until the first check.
+             */
+            last_checked_at?: string;
+        };
+        EmailDomainListResponse: {
+            /** @example true */
+            success: boolean;
+            data: {
+                email_domains: components["schemas"]["EmailDomain"][];
+                /**
+                 * @description Maximum number of email domains the account can have. `0` when the account does not
+                 *     have the custom email domain add-on, which is contracted with BeeL. `null` when the
+                 *     add-on sets no explicit limit.
+                 * @example 3
+                 */
+                max_email_domains: number | null;
+            };
+            meta?: components["schemas"]["ResponseMeta"];
+        };
+        EmailDomainResponse: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["EmailDomain"];
+            meta?: components["schemas"]["ResponseMeta"];
+        };
+        CreateEmailDomainRequest: {
+            /**
+             * @description Fully qualified domain name to send from. It is trimmed, lowercased and stored without a
+             *     trailing dot; internationalised names are stored in their ASCII form.
+             * @example facturas.ejemplo.com
+             */
+            domain: string;
+        };
         /** @description Information about the queried period */
         QueriedPeriod: {
             /**
@@ -12520,6 +12951,8 @@ interface components {
              * @description Only on a full invoice issued in exchange for simplified invoices: the simplified
              *     invoices it replaces, each now `VOIDED` with `void_cause` `EXCHANGED`. With VeriFactu,
              *     the invoice is recorded as `F3` identifying them.
+             *     The invoice inherits the `metadata` of the simplified invoices; when there are several,
+             *     only the keys with the same value in all of them.
              */
             replaced_invoice_ids?: string[];
             void_cause?: components["schemas"]["VoidCause"];
@@ -12555,6 +12988,23 @@ interface components {
              *     in `CONVERTED` status; never included in list rows.
              */
             converted_invoice_id?: string;
+            /**
+             * Format: uuid
+             * @description UUID of the full invoice that replaced this simplified invoice when it was exchanged
+             *     (`void_cause` is `EXCHANGED`), derived at read time (not persisted).
+             *     Only present on the detail endpoint
+             *     (`GET /v1/companies/{company_id}/invoices/{invoice_id}`) for an exchanged simplified
+             *     invoice; never included in list rows.
+             */
+            replaced_by_invoice_id?: string;
+            /**
+             * @description UUIDs of the live (non-deleted) corrective invoices that rectify this invoice, in
+             *     order of creation, including drafts, derived at read time (not persisted).
+             *     Only present in responses that return a single invoice, such as
+             *     `GET /v1/companies/{company_id}/invoices/{invoice_id}`, and only when at least one
+             *     exists; never included in list rows.
+             */
+            rectified_by_invoice_ids?: string[];
             /** @description Reason for rectification (only for corrective invoices) */
             rectification_reason?: string;
             /**
@@ -12575,7 +13025,7 @@ interface components {
              * @description Additional metadata in key-value format. Invoices auto-generated from a
              *     connected payment platform carry system keys you can filter on:
              *     - external_customer_id: Payment-platform customer (e.g. Stripe `cus_…`), present when the payment carried a customer (absent on flows with no customer, e.g. Terminal / payment links without customer collection)
-             *     - external_payment_id: Canonical payment reference. On Stripe this is always the PaymentIntent id (`pi_…`); the Charge, Stripe Invoice and Checkout Session ids are never used here, so every event of the same payment carries the same value.
+             *     - external_payment_id: Canonical payment reference. On Stripe this is the PaymentIntent id (`pi_…`); for a charge without a PaymentIntent, the Charge id (`ch_…`); for a Stripe invoice paid outside Stripe, the payment record id (`pr_…`). The Stripe Invoice and Checkout Session ids are never used here, so every event of the same payment carries the same value.
              *     - payment_intent_id: Stripe PaymentIntent id, when the payment has one
              *     - charge_id: Stripe Charge id, when the payment has one
              *     - payment_provider: Origin platform (e.g. STRIPE_CONNECT)
@@ -12599,7 +13049,8 @@ interface components {
              */
             send_automatically?: boolean | null;
             /**
-             * @description Email configuration used when `send_automatically` is true.
+             * @description Email configuration used when `send_automatically` is true. Its `subject`, `message`
+             *     and `cc` take priority over the `defaults` of the company's email configuration.
              *     If it names no recipients, the email goes to the customer's `billing_emails`, or to
              *     the customer's `email` when there are none.
              */
@@ -12879,13 +13330,25 @@ interface components {
             /**
              * @description CC recipients. Copied addresses count as recipients of the message: they are subject
              *     to the same sending restrictions and to the same quota as the addresses in `recipients`.
-             *     When omitted, the CC addresses configured in the sender's email defaults apply; send an
+             *     When omitted, the CC addresses in the `defaults` of the company's email configuration apply
+             *     (the `email_config.cc` of the invoice applies only when the delivery carries one invoice); send an
              *     empty array to deliver the message without any copy.
              */
             cc?: components["schemas"]["Email"][];
-            /** @description Custom email subject. Defaults to the standard template. */
+            /**
+             * @description Custom email subject. When omitted, the `email_config.subject` of the invoice applies if the
+             *     delivery carries one invoice, then the `defaults.subject` of the company's email
+             *     configuration, then the standard subject. Variables resolve per delivery (see `message`).
+             */
             subject?: string;
-            /** @description Custom message body. Defaults to the standard template. */
+            /**
+             * @description Custom message body. When omitted, the `email_config.message` of the invoice applies if the
+             *     delivery carries one invoice, then the `defaults.message` of the company's email
+             *     configuration, then the standard message. Variables in `subject` and `message` resolve per
+             *     delivery, which is one email: `{invoiceNumber}` is the list of invoice numbers separated by
+             *     ", ", `{customerName}` only when every invoice has the same customer, `{issuerName}` is the
+             *     issuer, and the others (total, dates) are empty.
+             */
             message?: string;
             /** @description Email language. Defaults to the language of the requesting user. */
             language?: components["schemas"]["Language"];
@@ -13498,7 +13961,7 @@ interface components {
          *     payment data and custom fields are taken from it, so only the recurrence is described here.
          *     The source invoice is not modified.
          *
-         *     Deliberately not a variant of `CreateRecurringInvoiceRequest`: that one requires `series_id`,
+         *     Deliberately not a variant of `CreateRecurringInvoiceRequest`: that one requires
          *     `invoice_type` and `lines`, which this call does not carry. Relaxing them there would let a
          *     template be created from scratch with no lines at all.
          */
@@ -14487,7 +14950,7 @@ interface components {
          *
          *     `NONE` — no access to the data.
          *     `VIEW` — read invoices, customers, products, series and fiscal data.
-         *     `OPERATE` — everything in `VIEW`, plus creating and editing them. Issuing invoices for an account you manage additionally requires a signed fiscal representation from the account holder (see `/v1/accounts/{account_id}/companies/{company_id}/representation`).
+         *     `OPERATE` — everything in `VIEW`, plus creating and editing them. In Live, issuing invoices for an account you manage additionally requires a signed fiscal representation from the account holder (see `/v1/companies/{company_id}/representation`). In Test you can issue from the start.
          *
          *     Access level never affects billing: whoever provisioned an account pays for its subscription regardless of the level they keep over it.
          * @enum {string}
@@ -15007,8 +15470,9 @@ interface components {
             max_size_formatted: string;
             /**
              * @description Size the request declared in its `Content-Length` header. Present
-             *     when the whole body was measured, absent when the limit was reached
-             *     while reading an individual uploaded file.
+             *     when the whole body was measured. Absent when the limit was reached
+             *     while reading an individual uploaded file, or when the request did
+             *     not declare a `Content-Length` and was stopped while being read.
              * @example 5242880
              */
             request_size_bytes?: string;
@@ -15483,6 +15947,145 @@ interface components {
             data?: components["schemas"]["IssuingReadinessData"];
             meta?: components["schemas"]["ResponseMeta"];
         };
+        /**
+         * @description What the company chose as the sender of its invoice emails.
+         *
+         *     - ACCOUNT_DEFAULT: no choice; it inherits the default email domain of the account.
+         *     - EMAIL_DOMAIN: one of the email domains of the account, in `email_domain_id`.
+         *     - BEEL: the address of BeeL.
+         * @enum {string}
+         */
+        CompanyEmailSenderSource: "ACCOUNT_DEFAULT" | "EMAIL_DOMAIN" | "BEEL";
+        /**
+         * @description Why invoice emails go out from the address they go out from.
+         *
+         *     - CUSTOM_DOMAIN: from a verified email domain of the account. Nothing to do.
+         *     - ADDON_INACTIVE: the company or the account has an email domain but the account does not
+         *       hold the custom email domain add-on, so emails go out from BeeL. Contract the add-on with
+         *       BeeL. to use the domain.
+         *     - DOMAIN_NOT_VERIFIED: the email domains that apply are not verified, so emails go out from
+         *       BeeL. Verify the domain with `POST /v1/accounts/{account_id}/email-domains/{email_domain_id}/verify`
+         *       once its DNS records are published.
+         *     - NO_DOMAIN: neither the company nor the account has an email domain, so emails go out from
+         *       BeeL. Register one with `POST /v1/accounts/{account_id}/email-domains`.
+         *     - BEEL_SELECTED: the company chose the address of BeeL. (`source` `BEEL`). Nothing to do.
+         * @enum {string}
+         */
+        EmailSenderReason: "CUSTOM_DOMAIN" | "ADDON_INACTIVE" | "DOMAIN_NOT_VERIFIED" | "NO_DOMAIN" | "BEEL_SELECTED";
+        /** @description The address the invoice emails of a company go out from, and why. */
+        EffectiveEmailSender: {
+            /**
+             * Format: email
+             * @description Address shown as the sender of the invoice emails.
+             * @example facturas@facturas.ejemplo.com
+             */
+            from_address: string;
+            reason: components["schemas"]["EmailSenderReason"];
+            /**
+             * Format: uuid
+             * @description The email domain of the account the address belongs to. Absent when the address is BeeL.'s.
+             * @example 550e8400-e29b-41d4-a716-446655440000
+             */
+            email_domain_id?: string;
+        };
+        /** @description The sender chosen for the invoice emails of a company, and the one in effect. */
+        CompanyEmailSender: {
+            source: components["schemas"]["CompanyEmailSenderSource"];
+            /**
+             * Format: uuid
+             * @description The email domain of the account the company chose; `null` unless `source` is `EMAIL_DOMAIN`.
+             */
+            email_domain_id: string | null;
+            /**
+             * @description Part of the address before the `@`. `null` means `facturas`, and it is always `null` when `source` is `BEEL`.
+             * @example cobros
+             */
+            local_part: string | null;
+            effective: components["schemas"]["EffectiveEmailSender"];
+        };
+        /** @description The content applied to an invoice email that does not specify its own. The additional recipients are always added. */
+        CompanyEmailDefaults: {
+            /**
+             * @description Subject template, with the variables of `GET /v1/email-template-variables`.
+             * @example Invoice {invoiceNumber}
+             */
+            subject: string | null;
+            /**
+             * @description Message template, with the variables of `GET /v1/email-template-variables`.
+             * @example Dear {customerName}, please find attached invoice {invoiceNumber}.
+             */
+            message: string | null;
+            /** @description CC recipients, applied when the email request does not specify `cc`. */
+            cc: components["schemas"]["Email"][] | null;
+            /** @description Recipients added to those of every invoice email. */
+            additional_recipients: components["schemas"]["Email"][] | null;
+        };
+        CompanyEmailConfiguration: {
+            sender: components["schemas"]["CompanyEmailSender"];
+            defaults: components["schemas"]["CompanyEmailDefaults"];
+        };
+        UpdateCompanyEmailSender: {
+            source?: components["schemas"]["CompanyEmailSenderSource"];
+            /**
+             * Format: uuid
+             * @description An email domain of the account. Accepted only with `source` `EMAIL_DOMAIN`.
+             */
+            email_domain_id?: string | null;
+            /**
+             * @description Part of the address before the `@`. Not accepted with `source` `BEEL`.
+             * @example cobros
+             */
+            local_part?: string | null;
+        };
+        UpdateCompanyEmailDefaults: {
+            /**
+             * @description Subject template.
+             * @example Invoice {invoiceNumber}
+             */
+            subject?: string | null;
+            /**
+             * @description Message template.
+             * @example Dear {customerName}, please find attached invoice {invoiceNumber}.
+             */
+            message?: string | null;
+            /** @description CC recipients. */
+            cc?: components["schemas"]["Email"][] | null;
+            /** @description Additional recipients. */
+            additional_recipients?: components["schemas"]["Email"][] | null;
+        };
+        UpdateCompanyEmailConfigurationRequest: {
+            sender: components["schemas"]["UpdateCompanyEmailSender"];
+            /** @description The defaults of the invoice emails. Omitted keeps them; `null` removes them. */
+            defaults?: components["schemas"]["UpdateCompanyEmailDefaults"] | null;
+        };
+        /**
+         * @description Name of a variable of the email templates.
+         *
+         *     - invoiceNumber: number of the invoice.
+         *     - customerName: name of the customer.
+         *     - issueDate: issue date of the invoice.
+         *     - invoiceTotal: total of the invoice.
+         *     - dueDate: due date of the invoice.
+         *     - issuerName: name of the company that issues the invoice.
+         * @enum {string}
+         */
+        EmailTemplateVariableKey: "invoiceNumber" | "customerName" | "issueDate" | "invoiceTotal" | "dueDate" | "issuerName";
+        EmailTemplateVariable: {
+            key: components["schemas"]["EmailTemplateVariableKey"];
+            /**
+             * @description The text to write in a template, braces included.
+             * @example {invoiceNumber}
+             */
+            placeholder: string;
+            /**
+             * @description What the variable is replaced with.
+             * @example Invoice number
+             */
+            description: string;
+        };
+        EmailTemplateVariables: {
+            variables: components["schemas"]["EmailTemplateVariable"][];
+        };
         /**
          * @description Nominal billing period of a subscription.
          * @example MONTHLY
@@ -15741,6 +16344,25 @@ interface components {
          * @enum {string}
          */
         PaymentEventType: "PAYMENT_COMPLETED" | "PAYMENT_FAILED" | "REFUND_COMPLETED" | "DISPUTE_OPENED" | "DISPUTE_CLOSED" | "UNKNOWN";
+        /**
+         * @description What this event means for its payment. Branch on this value instead of deriving it from
+         *     `status` and `failure_reason`.
+         *
+         *     - `INVOICED`: an invoice was generated from the event (`invoice_id` is set)
+         *     - `IN_PROGRESS`: the payment can still change, because the event is being processed or
+         *       retried, or the payer has yet to pay
+         *     - `NOT_INVOICED`: closed without an invoice and with nothing for you to do, for example a
+         *       zero-amount payment, or a payment settled from the payer's balance
+         *     - `RESOLVED`: marked as resolved outside BeeL
+         *     - `INCIDENT`: needs your action (`needs_action` is `true`)
+         *     - `NO_CHANGE`: the event does not change the tax position of the payment, such as a refund
+         *       that did not complete, a failed payment attempt, an event type BeeL does not handle, or a
+         *       dispute settled in your favour
+         *
+         *     `INCIDENT` takes precedence over the rest, then `INVOICED`.
+         * @enum {string}
+         */
+        PaymentEventOutcome: "INVOICED" | "IN_PROGRESS" | "NOT_INVOICED" | "RESOLVED" | "INCIDENT" | "NO_CHANGE";
         /** @description How many events share one failure reason. */
         PaymentEventFailureReasonCount: {
             /**
@@ -15933,12 +16555,21 @@ interface components {
          *     - `account.claimed` — A provisioned account was claimed by its holder
          *     - `company.created` — A company was created inside a provisioned account
          *     - `representation.signed` — Fiscal representation signed for a NIF (production invoicing enabled)
+         *     - `email_domain.verified` — A sending domain of the account became `VERIFIED`; sent once per transition
+         *     - `email_domain.failed` — A sending domain of the account became `FAILED`; sent once per transition
+         *     - `email_domain.removed` — A sending domain of the account was removed, with a `reason` (`EXPIRED`,
+         *       `DELETED_BY_USER` or `DELETED_AT_PROVIDER`); sent once per removal
+         *     - `invoice.email.bounced` — The email of an invoice bounced or was marked as spam, with a `reason`
+         *       (`BOUNCED` or `COMPLAINED`); sent once per email
+         *
+         *     The `email_domain.*` events belong to the account: they are delivered only to its live
+         *     endpoints, never to the account that manages it, and `company_id` and `nif` are not set (absent or `null`).
          *
          *     The `account.*` events are delivered only to the **provisioner** that created the
          *     account; a subscription on any other account never receives them.
          * @enum {string}
          */
-        WebhookEventTypeEnum: "invoice.issued" | "invoice.email.sent" | "invoice.pdf.generated" | "invoice.voided" | "recurring_invoice.paused" | "invoice.schedule_failed" | "verifactu.status.updated" | "account.claimed" | "company.created" | "representation.signed";
+        WebhookEventTypeEnum: "invoice.issued" | "invoice.email.sent" | "invoice.pdf.generated" | "invoice.voided" | "recurring_invoice.paused" | "invoice.schedule_failed" | "verifactu.status.updated" | "account.claimed" | "company.created" | "representation.signed" | "email_domain.verified" | "email_domain.failed" | "email_domain.removed" | "invoice.email.bounced";
         CreateWebhookSubscriptionRequest: {
             /**
              * Format: uri
@@ -16207,6 +16838,81 @@ interface components {
              */
             signed_at: string;
         };
+        /**
+         * @description Data payload for `email_domain.verified` and `email_domain.failed` events: the email domain as it
+         *     is after the change, plus its previous status. Sent once per transition. On `email_domain.failed`,
+         *     `previous_status` `PENDING` means the domain never verified and `VERIFIED` means it stopped passing
+         *     the check.
+         */
+        WebhookEventDataEmailDomain: {
+            /**
+             * Format: uuid
+             * @description Identifier of the email domain.
+             */
+            email_domain_id: string;
+            /** @example facturas.ejemplo.com */
+            domain: string;
+            status: components["schemas"]["EmailDomainStatus"];
+            previous_status: components["schemas"]["EmailDomainStatus"];
+            is_default: boolean;
+            dns_records: components["schemas"]["DnsRecord"][];
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            verified_at?: string | null;
+            /** Format: date-time */
+            last_checked_at?: string | null;
+        };
+        /**
+         * @description Why the domain was removed:
+         *
+         *     - EXPIRED: it expired before being verified, 72 hours after it was registered
+         *     - DELETED_BY_USER: a user of the account deleted it
+         *     - DELETED_AT_PROVIDER: it no longer existed in the email sending service, so BeeL. removed it from the account
+         * @enum {string}
+         */
+        EmailDomainRemovalReason: "EXPIRED" | "DELETED_BY_USER" | "DELETED_AT_PROVIDER";
+        /**
+         * @description Data payload for `email_domain.removed` events: the email domain as it was when it was removed, plus
+         *     the reason. Sent once per removal.
+         */
+        WebhookEventDataEmailDomainRemoved: {
+            /**
+             * Format: uuid
+             * @description Identifier of the email domain.
+             */
+            email_domain_id: string;
+            /** @example facturas.ejemplo.com */
+            domain: string;
+            status: components["schemas"]["EmailDomainStatus"];
+            is_default: boolean;
+            dns_records: components["schemas"]["DnsRecord"][];
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            verified_at?: string | null;
+            /** Format: date-time */
+            last_checked_at?: string | null;
+            reason: components["schemas"]["EmailDomainRemovalReason"];
+        };
+        /**
+         * @description Why the email was not delivered: the recipient's server rejected it (`BOUNCED`) or the recipient
+         *     marked it as spam (`COMPLAINED`).
+         * @enum {string}
+         */
+        InvoiceEmailBounceReason: "BOUNCED" | "COMPLAINED";
+        /** @description Data payload for `invoice.email.bounced` events. */
+        WebhookEventDataInvoiceEmailBounced: {
+            /** Format: uuid */
+            invoice_id: string;
+            /** @example 2025/0001 */
+            invoice_number?: string | null;
+            /** @description The addresses the invoice email was sent to (to and cc); at least one of them bounced or complained. */
+            recipients: string[];
+            reason: components["schemas"]["InvoiceEmailBounceReason"];
+            /** Format: date-time */
+            bounced_at: string;
+        };
         /** @description Payload delivered to your endpoint on every webhook event. */
         WebhookEvent: {
             /**
@@ -16253,7 +16959,7 @@ interface components {
              */
             account_external_ref?: string | null;
             account_relationship?: components["schemas"]["WebhookEventAccountRelationship"];
-            data: components["schemas"]["WebhookEventDataInvoiceIssued"] | components["schemas"]["WebhookEventDataInvoiceEmailSent"] | components["schemas"]["WebhookEventDataInvoicePdfGenerated"] | components["schemas"]["WebhookEventDataInvoiceVoided"] | components["schemas"]["WebhookEventDataRecurringInvoicePaused"] | components["schemas"]["WebhookEventDataInvoiceScheduleFailed"] | components["schemas"]["WebhookEventDataVeriFactuStatusUpdated"] | components["schemas"]["WebhookEventDataAccountClaimed"] | components["schemas"]["WebhookEventDataCompanyCreated"] | components["schemas"]["WebhookEventDataRepresentationSigned"];
+            data: components["schemas"]["WebhookEventDataInvoiceIssued"] | components["schemas"]["WebhookEventDataInvoiceEmailSent"] | components["schemas"]["WebhookEventDataInvoicePdfGenerated"] | components["schemas"]["WebhookEventDataInvoiceVoided"] | components["schemas"]["WebhookEventDataRecurringInvoicePaused"] | components["schemas"]["WebhookEventDataInvoiceScheduleFailed"] | components["schemas"]["WebhookEventDataVeriFactuStatusUpdated"] | components["schemas"]["WebhookEventDataAccountClaimed"] | components["schemas"]["WebhookEventDataCompanyCreated"] | components["schemas"]["WebhookEventDataRepresentationSigned"] | components["schemas"]["WebhookEventDataEmailDomain"] | components["schemas"]["WebhookEventDataEmailDomainRemoved"] | components["schemas"]["WebhookEventDataInvoiceEmailBounced"];
         };
         UpdateWebhookSubscriptionRequest: {
             /**
@@ -16605,9 +17311,10 @@ interface components {
          *       API key and no OAuth2 token can perform it, whatever scopes it holds.
          *     - `OPERATION_REQUIRES_API_KEY` — the reverse: the operation needs a scope that only an API
          *       key can hold (such as `accounts:write`), so a dashboard session never satisfies it.
-         *     - `API_KEY_LIVE_NOT_AVAILABLE` — the call came with a live API key (`beel_sk_live_…`) and
-         *       the account has no Live mode yet. It is never degraded to Test: use your test key, or
-         *       activate Live first.
+         *     - `API_KEY_LIVE_NOT_AVAILABLE` — the call came with a live credential (a `beel_sk_live_…`
+         *       API key, or an OAuth2 token issued without the `sandbox` scope) and the account has no
+         *       Live mode yet. It is never degraded to Test: use test credentials, or activate Live
+         *       first.
          *     - `ACCOUNT_REQUIRES_FOCUS_SWITCH` — dashboard session only: you are a member of the account
          *       in the path, but it is not the account in focus. Switch focus to it and retry.
          *     - `REQUEST_BLOCKED` — the edge security filter stopped the request before the API saw its
@@ -17164,6 +17871,11 @@ interface components {
          *     contract's `snake_case`) to a message describing what is wrong with it, or follows
          *     `FieldDeserializationError` when the value is outside an enum's vocabulary. Otherwise it is
          *     one of the series rules, among them:
+         *     - `SERIES_FORMAT_NUM_REQUIRED` / `SERIES_FORMAT_MULTIPLE_NUM` — the format has no counter
+         *       (`{NUM}` or `{NUM:X}`), or more than one. It needs exactly one.
+         *     - `SERIES_FORMAT_INVALID_PADDING` / `SERIES_FORMAT_UNRECOGNIZED_VARS` — the padding in
+         *       `{NUM:X}` is not a whole number from 1 to 20, or the format uses a variable BeeL. does
+         *       not know. Allowed: `{CODIGO}`, `{YYYY}`, `{YY}`, `{MM}`, `{NUM}`, `{NUM:X}`.
          *     - `SERIES_MONTHLY_REQUIRES_MONTH_AND_YEAR` / `SERIES_ANNUAL_REQUIRES_YEAR` — the format
          *       cannot tell the counter reset periods apart.
          *     - `SERIES_INITIAL_NUMBER_OUT_OF_RANGE` — the initial number is out of range.
@@ -17344,6 +18056,28 @@ interface components {
                 "application/json": components["schemas"]["ErrorResponse"];
             };
         };
+        /** @description `EMAIL_DOMAIN_NOT_FOUND` — no email domain with that id belongs to the account. A domain of another account, or one already removed, answers the same way. */
+        EmailDomainNotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "success": false,
+                 *       "error": {
+                 *         "code": "EMAIL_DOMAIN_NOT_FOUND",
+                 *         "message": "No email domain with that id belongs to your account."
+                 *       },
+                 *       "meta": {
+                 *         "timestamp": "2025-01-15T10:30:00Z",
+                 *         "request_id": "4bf92f3577b34da6a3ce929d0e0e4736"
+                 *       }
+                 *     }
+                 */
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
     };
     parameters: {
         /**
@@ -17353,7 +18087,10 @@ interface components {
          *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
          *     - Retrying with the same key replays the first response when it was a success (2xx) or a
          *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-         *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+         *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+         *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+         *       the operation may have taken effect: check the resource before using a new key. Without that header,
+         *       the retry runs the operation once
          *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
          *     - Stored responses expire 24 hours after processing
          *
@@ -17390,7 +18127,8 @@ interface components {
          *     The company does **not** have to belong to the API key's own account: one you manage works
          *     too, which is what makes the `company_id` returned by `POST /v1/accounts` usable here to
          *     invoice on a provisioned account's behalf. What you may do with it is then decided by your
-         *     access level over that account, and issuing also requires a signed fiscal representation.
+         *     access level over that account, and issuing in Live also requires a signed fiscal
+         *     representation.
          *
          *     This header is how you **operate** on a company, never how you find one: a value you do not
          *     reach answers `403`, the same as one that does not exist, so guessing reveals nothing. Get
@@ -17667,7 +18405,8 @@ interface operations {
                  *     The company does **not** have to belong to the API key's own account: one you manage works
                  *     too, which is what makes the `company_id` returned by `POST /v1/accounts` usable here to
                  *     invoice on a provisioned account's behalf. What you may do with it is then decided by your
-                 *     access level over that account, and issuing also requires a signed fiscal representation.
+                 *     access level over that account, and issuing in Live also requires a signed fiscal
+                 *     representation.
                  *
                  *     This header is how you **operate** on a company, never how you find one: a value you do not
                  *     reach answers `403`, the same as one that does not exist, so guessing reveals nothing. Get
@@ -17780,7 +18519,8 @@ interface operations {
                  *     The company does **not** have to belong to the API key's own account: one you manage works
                  *     too, which is what makes the `company_id` returned by `POST /v1/accounts` usable here to
                  *     invoice on a provisioned account's behalf. What you may do with it is then decided by your
-                 *     access level over that account, and issuing also requires a signed fiscal representation.
+                 *     access level over that account, and issuing in Live also requires a signed fiscal
+                 *     representation.
                  *
                  *     This header is how you **operate** on a company, never how you find one: a value you do not
                  *     reach answers `403`, the same as one that does not exist, so guessing reveals nothing. Get
@@ -17798,7 +18538,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -18033,7 +18776,8 @@ interface operations {
                  *     The company does **not** have to belong to the API key's own account: one you manage works
                  *     too, which is what makes the `company_id` returned by `POST /v1/accounts` usable here to
                  *     invoice on a provisioned account's behalf. What you may do with it is then decided by your
-                 *     access level over that account, and issuing also requires a signed fiscal representation.
+                 *     access level over that account, and issuing in Live also requires a signed fiscal
+                 *     representation.
                  *
                  *     This header is how you **operate** on a company, never how you find one: a value you do not
                  *     reach answers `403`, the same as one that does not exist, so guessing reveals nothing. Get
@@ -18099,7 +18843,8 @@ interface operations {
                  *     The company does **not** have to belong to the API key's own account: one you manage works
                  *     too, which is what makes the `company_id` returned by `POST /v1/accounts` usable here to
                  *     invoice on a provisioned account's behalf. What you may do with it is then decided by your
-                 *     access level over that account, and issuing also requires a signed fiscal representation.
+                 *     access level over that account, and issuing in Live also requires a signed fiscal
+                 *     representation.
                  *
                  *     This header is how you **operate** on a company, never how you find one: a value you do not
                  *     reach answers `403`, the same as one that does not exist, so guessing reveals nothing. Get
@@ -18332,7 +19077,8 @@ interface operations {
                  *     The company does **not** have to belong to the API key's own account: one you manage works
                  *     too, which is what makes the `company_id` returned by `POST /v1/accounts` usable here to
                  *     invoice on a provisioned account's behalf. What you may do with it is then decided by your
-                 *     access level over that account, and issuing also requires a signed fiscal representation.
+                 *     access level over that account, and issuing in Live also requires a signed fiscal
+                 *     representation.
                  *
                  *     This header is how you **operate** on a company, never how you find one: a value you do not
                  *     reach answers `403`, the same as one that does not exist, so guessing reveals nothing. Get
@@ -18455,7 +19201,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -18571,7 +19320,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -18661,7 +19413,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -18791,6 +19546,15 @@ interface operations {
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            /** @description `INVOICE_PDF_UNAVAILABLE`: the invoice needs its VeriFactu QR and BeeL. cannot produce its PDF because of a problem on our side. Answered immediately and without `Retry-After`: asking again does not help until support solves it. Contact support with the `meta.request_id`. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
             429: components["responses"]["TooManyRequests"];
             500: components["responses"]["InternalServerError"];
             default: components["responses"]["UnexpectedError"];
@@ -18852,7 +19616,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -18983,7 +19750,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19072,7 +19842,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19190,7 +19963,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19403,7 +20179,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19541,7 +20320,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19659,7 +20441,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19756,7 +20541,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19819,7 +20607,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -19916,7 +20707,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -20041,7 +20835,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -20308,6 +21105,14 @@ interface operations {
                 date_from?: string;
                 /** @description Date to, inclusive (YYYY-MM-DD). Applies to the same date as `date_from`. */
                 date_to?: string;
+                /** @description Due date from, inclusive (YYYY-MM-DD). Invoices without a due date are excluded. */
+                due_date_from?: string;
+                /** @description Due date to, inclusive (YYYY-MM-DD). Invoices without a due date are excluded. */
+                due_date_to?: string;
+                /** @description Payment date from, inclusive (YYYY-MM-DD). Invoices without a payment date are excluded. */
+                payment_date_from?: string;
+                /** @description Payment date to, inclusive (YYYY-MM-DD). Invoices without a payment date are excluded. */
+                payment_date_to?: string;
                 /** @description Search by invoice number (e.g., 2025/0001) */
                 invoice_number?: string;
                 /** @description Filter by recipient's fiscal name (partial, case-insensitive search) */
@@ -20323,6 +21128,11 @@ interface operations {
                  *     issued invoice; a single invoice can have several partial correctives.
                  */
                 rectified_invoice_id?: string;
+                /**
+                 * @description Return the simplified invoices replaced by this exchange invoice. Accepts the id of an
+                 *     issued full invoice; it matches the ids in its `replaced_invoice_ids`.
+                 */
+                replaced_by_invoice_id?: string;
                 /** @description Minimum taxable base */
                 taxable_base_min?: number;
                 /** @description Maximum taxable base */
@@ -20475,7 +21285,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -20718,7 +21531,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -20909,7 +21725,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -21089,7 +21908,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -21383,7 +22205,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -21765,6 +22590,15 @@ interface operations {
                 };
             };
             404: components["responses"]["NotFound"];
+            /** @description `INVOICE_PDF_UNAVAILABLE`: the invoice needs its VeriFactu QR and BeeL. cannot produce its PDF because of a problem on our side, not in your request. Answered immediately and without `Retry-After`: asking again does not help until support solves it. Contact support with the `meta.request_id`; once it is solved, the same request returns the PDF. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
             429: components["responses"]["TooManyRequests"];
             500: components["responses"]["InternalServerError"];
             default: components["responses"]["UnexpectedError"];
@@ -21832,6 +22666,15 @@ interface operations {
                 };
             };
             404: components["responses"]["NotFound"];
+            /** @description `INVOICE_PDF_UNAVAILABLE`: the invoice needs its VeriFactu QR and BeeL. cannot produce its PDF, so there is no preview image either. Asking again does not help until support solves it; contact support with the `meta.request_id`. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
             429: components["responses"]["TooManyRequests"];
             500: components["responses"]["InternalServerError"];
             default: components["responses"]["UnexpectedError"];
@@ -21907,7 +22750,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -22071,7 +22917,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -22209,6 +23058,8 @@ interface operations {
              *     - `OPERATION_DATE_AFTER_ISSUE_DATE` — `operation_date` is later than the issue date (today when issuing); send today or a past date.
              *     - `OPERATION_DATE_TOO_OLD` — `operation_date` is more than twenty years before the issue date; AEAT does not accept it. Send a more recent date.
              *     - `PROFORMA_NOT_ISSUABLE` — a proforma is never issued; convert it with `convert-to-invoice` (optionally with `issue: true`).
+             *     - `RECIPIENT_ADDRESS_REQUIRED` — a standard invoice needs the recipient's address (RD 1619/2012 art. 6.1.e); complete it on the draft before issuing.
+             *     - `RECIPIENT_FISCAL_NAME_REQUIRED` — a standard invoice needs the recipient's legal name; a draft parked without it (for example, a Stripe payment with a tax ID and no name) must be completed before issuing.
              *     - `RECIPIENT_ID_REQUIRED` — a standard invoice needs an identified recipient: a `customer_id`, or inline data with `nif` or `alternative_id`.
              *     - `REGIME_KEY_CLASSIFICATION_NOT_ACCEPTED` — AEAT does not accept that `exemption_reason` (or its absence) with the line's `regime_key`; the message lists the reasons it admits.
              *     - `REGIME_KEY_NOT_SUPPORTED` — BeeL. cannot declare that `regime_key` to AEAT (e.g. `06`, `14`); use another key.
@@ -22243,7 +23094,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -22372,7 +23226,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -22567,7 +23424,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -22824,7 +23684,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -22980,7 +23843,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -23163,7 +24029,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -23269,6 +24138,8 @@ interface operations {
              *
              *     Other `error.code` values with this status:
              *
+             *     - `RECIPIENT_ADDRESS_REQUIRED` — a standard invoice needs the recipient's address; complete it before scheduling.
+             *     - `RECIPIENT_FISCAL_NAME_REQUIRED` — a standard invoice needs the recipient's legal name; complete it before scheduling.
              *     - `RECIPIENT_ID_REQUIRED` — a standard invoice needs an identified recipient: a `customer_id`, or inline data with `nif` or `alternative_id`.
              */
             422: {
@@ -23295,7 +24166,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -23371,7 +24245,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -23537,7 +24414,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -23678,6 +24558,9 @@ interface operations {
              *     Also: `series_id` (explicit or resolved by default) numbering against a series that is
              *     inactive is rejected with `error.code` `SERIES_INACTIVE` — no template is created.
              *     Activate the series, or send a `series_id` for one that is already active.
+             *     Also: with no `series_id` and no default standard series for a `STANDARD` template, the
+             *     call is rejected with `error.code` `SERIES_DEFAULT_NOT_FOUND`. Create a standard series
+             *     and mark it as default, or send a `series_id`.
              *
              *     Other `error.code` values with this status:
              *
@@ -24184,7 +25067,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -24275,7 +25161,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -24367,7 +25256,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -24519,7 +25411,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -24723,7 +25618,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -24916,7 +25814,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -25104,6 +26005,9 @@ interface operations {
              *     Also: `series_id` (explicit or resolved by default) numbering against a series that is
              *     inactive is rejected with `error.code` `SERIES_INACTIVE` — no template is created.
              *     Activate the series, or send a `series_id` for one that is already active.
+             *     Also: with no `series_id` and no default standard series for a `STANDARD` template, the
+             *     call is rejected with `error.code` `SERIES_DEFAULT_NOT_FOUND`. Create a standard series
+             *     and mark it as default, or send a `series_id`.
              *
              *     Other `error.code` values with this status:
              *
@@ -25296,7 +26200,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -25576,7 +26483,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -25689,7 +26599,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -25985,7 +26898,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -26173,7 +27089,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -26409,7 +27328,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -26751,7 +27673,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -26970,7 +27895,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -27143,7 +28071,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -27252,7 +28183,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -27968,7 +28902,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -28335,7 +29272,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -28550,7 +29490,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -28668,7 +29611,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -29173,7 +30119,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -29323,7 +30272,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -29469,7 +30421,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -29865,7 +30820,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -29966,7 +30924,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -30206,7 +31167,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -30480,7 +31444,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -31144,7 +32111,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -31222,6 +32192,7 @@ interface operations {
              *
              *     - `SERIES_FORMAT_INVALID_PADDING` — the padding in `{NUM:X}` must be a whole number from 1 to 20 (e.g. `{NUM:4}` → `0001`).
              *     - `SERIES_FORMAT_NUM_REQUIRED` — the series `format` has no `{NUM}` or `{NUM:X}`, so it cannot number invoices. Add the counter.
+             *     - `SERIES_FORMAT_MULTIPLE_NUM` — the series `format` has more than one `{NUM}` or `{NUM:X}`. The invoice number carries a single counter, so a second one would appear literally. Keep one.
              *     - `SERIES_FORMAT_UNRECOGNIZED_VARS` — the `format` uses a variable BeeL. does not know. Allowed: `{CODIGO}`, `{YYYY}`, `{YY}`, `{MM}`, `{NUM}`, `{NUM:X}`.
              */
             422: {
@@ -31260,7 +32231,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -31488,7 +32462,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -31756,7 +32733,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -31924,6 +32904,7 @@ interface operations {
              *     - `IRPF_RATE_ONLY_FOR_CORPORATE_ISSUER` — the rate (e.g. 9.5 % Ceuta/Melilla) only applies to corporate issuers; an individual issuer must use a personal-income-tax rate.
              *     - `SERIES_FORMAT_INVALID_PADDING` — the padding in `{NUM:X}` must be a whole number from 1 to 20 (e.g. `{NUM:4}` → `0001`).
              *     - `SERIES_FORMAT_NUM_REQUIRED` — the series `format` has no `{NUM}` or `{NUM:X}`, so it cannot number invoices. Add the counter.
+             *     - `SERIES_FORMAT_MULTIPLE_NUM` — the series `format` has more than one `{NUM}` or `{NUM:X}`. The invoice number carries a single counter, so a second one would appear literally. Keep one.
              *     - `SERIES_FORMAT_UNRECOGNIZED_VARS` — the `format` uses a variable BeeL. does not know. Allowed: `{CODIGO}`, `{YYYY}`, `{YY}`, `{MM}`, `{NUM}`, `{NUM:X}`.
              */
             422: {
@@ -32267,7 +33248,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -32313,6 +33297,19 @@ interface operations {
                 };
             };
             404: components["responses"]["NotFound"];
+            /**
+             * @description `PROFILE_INCOMPLETE` — the company's fiscal identity is not complete enough to produce
+             *     the document; `error.details` names each missing field, as in
+             *     `POST /v1/companies/{company_id}/representation`.
+             */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
             500: components["responses"]["InternalServerError"];
             default: components["responses"]["UnexpectedError"];
         };
@@ -32378,7 +33375,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -32571,7 +33571,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -32614,8 +33617,6 @@ interface operations {
              *       generated on top of it; contact support.
              *     * `REPRESENTATION_DOCUMENT_GENERATION_FAILED` — the provider could not produce the
              *       document. Nothing was stored; repeat the request later.
-             *
-             *     An incomplete fiscal identity is also answered with `400`, naming what is missing.
              */
             400: {
                 headers: {
@@ -32639,7 +33640,21 @@ interface operations {
                     "application/json": components["schemas"]["ErrorResponse"];
                 };
             };
-            422: components["responses"]["ValidationError"];
+            /**
+             * @description `PROFILE_INCOMPLETE` — the company's fiscal identity is not complete enough to produce
+             *     the document. `error.details` has one entry per missing field, keyed by its name:
+             *     `entity_type`, `nif`, `legal_name`, `address` and, for a legal entity, `legal_form` and
+             *     `legal_representative`. Nothing was generated. Complete the company and repeat the
+             *     request.
+             */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
             429: components["responses"]["TooManyRequests"];
             500: components["responses"]["InternalServerError"];
             default: components["responses"]["UnexpectedError"];
@@ -32762,7 +33777,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -32863,7 +33881,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -33033,7 +34054,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -33094,6 +34118,247 @@ interface operations {
             default: components["responses"]["UnexpectedError"];
         };
     };
+    getCompanyEmailConfiguration: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Unique identifier (UUID) of the company the operation acts on: its identifier, not its NIF. It is the only source of context: the account that owns it is derived from it, and the `BeeL-Active-Company` header plays no part. A company you do not reach answers `403`, and so does a company that does not exist, so the existence of a company in another account is never disclosed. */
+                company_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Email configuration of the company */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "success": true,
+                     *       "data": {
+                     *         "sender": {
+                     *           "source": "ACCOUNT_DEFAULT",
+                     *           "email_domain_id": null,
+                     *           "local_part": null,
+                     *           "effective": {
+                     *             "from_address": "facturas@facturas.ejemplo.com",
+                     *             "reason": "CUSTOM_DOMAIN",
+                     *             "email_domain_id": "550e8400-e29b-41d4-a716-446655440000"
+                     *           }
+                     *         },
+                     *         "defaults": {
+                     *           "subject": "Invoice {invoiceNumber}",
+                     *           "message": "Dear {customerName}, please find attached invoice {invoiceNumber}.",
+                     *           "cc": [
+                     *             "administracion@ejemplo.com"
+                     *           ],
+                     *           "additional_recipients": null
+                     *         }
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["SuccessResponse"] & {
+                        data: components["schemas"]["CompanyEmailConfiguration"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /**
+             * @description Your account does not own or manage this company (`error.code`
+             *     `ACTIVE_COMPANY_NOT_ACCESSIBLE`), or the credential lacks the `companies:read` scope
+             *     (`INSUFFICIENT_SCOPE`).
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
+    updateCompanyEmailConfiguration: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Idempotency key to prevent duplicates in sensitive operations.
+                 *
+                 *     - Any unique client-generated string (e.g. an order id). A UUID also works but is not required
+                 *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
+                 *     - Retrying with the same key replays the first response when it was a success (2xx) or a
+                 *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
+                 *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
+                 *     - Stored responses expire 24 hours after processing
+                 *
+                 *     The key is scoped per user and environment, and bound to the request body, so retrying after
+                 *     a network timeout replays the stored response instead of repeating the operation.
+                 *
+                 *     | Status | Code | When |
+                 *     |---|---|---|
+                 *     | `400` | `INVALID_IDEMPOTENCY_KEY` | The key breaks the format rules above. |
+                 *     | `409` | `IDEMPOTENCY_KEY_PROCESSING` | The first request is still in flight. Wait for the `Retry-After` seconds (2) and retry with the same key. |
+                 *     | `409` | `IDEMPOTENCY_KEY_MISMATCH` | The key was already used with a **different** body. Use a new key. |
+                 * @example invoice-order-12345
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKeyHeader"];
+            };
+            path: {
+                /** @description Unique identifier (UUID) of the company the operation acts on: its identifier, not its NIF. It is the only source of context: the account that owns it is derived from it, and the `BeeL-Active-Company` header plays no part. A company you do not reach answers `403`, and so does a company that does not exist, so the existence of a company in another account is never disclosed. */
+                company_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "sender": {
+                 *         "source": "EMAIL_DOMAIN",
+                 *         "email_domain_id": "550e8400-e29b-41d4-a716-446655440000",
+                 *         "local_part": "cobros"
+                 *       },
+                 *       "defaults": {
+                 *         "subject": "Invoice {invoiceNumber}",
+                 *         "message": "Dear {customerName}, please find attached invoice {invoiceNumber}.",
+                 *         "cc": [
+                 *           "administracion@ejemplo.com"
+                 *         ]
+                 *       }
+                 *     }
+                 */
+                "application/json": components["schemas"]["UpdateCompanyEmailConfigurationRequest"];
+            };
+        };
+        responses: {
+            /** @description Email configuration of the company after the change */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessResponse"] & {
+                        data: components["schemas"]["CompanyEmailConfiguration"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /**
+             * @description Your account does not own or manage this company, does not hold write access over it,
+             *     or the credential is a test one (`LIVE_CREDENTIAL_REQUIRED`). Not owning the company answers
+             *     `error.code` `ACTIVE_COMPANY_NOT_ACCESSIBLE`; a credential without the `companies:write`
+             *     scope answers `INSUFFICIENT_SCOPE`. Sending `defaults` without the email customization
+             *     plan answers `FEATURE_NOT_AVAILABLE`.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description The email domain does not exist, belongs to another account or was removed
+             *     (`error.code` `EMAIL_DOMAIN_NOT_FOUND`).
+             */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description The email domain is still being registered and cannot be chosen yet
+             *     (`error.code` `EMAIL_DOMAIN_NOT_READY`).
+             */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description A property is not valid, or the combination of `source`, `email_domain_id` and
+             *     `local_part` is not allowed (`error.code` `VALIDATION_ERROR`). Send values that follow
+             *     the format described for the operation.
+             */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
+    listEmailTemplateVariables: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Variables of the email templates */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "success": true,
+                     *       "data": {
+                     *         "variables": [
+                     *           {
+                     *             "key": "invoiceNumber",
+                     *             "placeholder": "{invoiceNumber}",
+                     *             "description": "Invoice number"
+                     *           },
+                     *           {
+                     *             "key": "customerName",
+                     *             "placeholder": "{customerName}",
+                     *             "description": "Customer name"
+                     *           }
+                     *         ]
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["SuccessResponse"] & {
+                        data: components["schemas"]["EmailTemplateVariables"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
     getCompanyVeriFactuConfiguration: {
         parameters: {
             query?: never;
@@ -33429,7 +34694,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -33523,6 +34791,7 @@ interface operations {
              *
              *     - `SERIES_FORMAT_INVALID_PADDING` — the padding in `{NUM:X}` must be a whole number from 1 to 20 (e.g. `{NUM:4}` → `0001`).
              *     - `SERIES_FORMAT_NUM_REQUIRED` — the series `format` has no `{NUM}` or `{NUM:X}`, so it cannot number invoices. Add the counter.
+             *     - `SERIES_FORMAT_MULTIPLE_NUM` — the series `format` has more than one `{NUM}` or `{NUM:X}`. The invoice number carries a single counter, so a second one would appear literally. Keep one.
              *     - `SERIES_FORMAT_UNRECOGNIZED_VARS` — the `format` uses a variable BeeL. does not know. Allowed: `{CODIGO}`, `{YYYY}`, `{YY}`, `{MM}`, `{NUM}`, `{NUM:X}`.
              */
             422: {
@@ -33607,7 +34876,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -33906,7 +35178,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34006,7 +35281,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34189,7 +35467,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34329,7 +35610,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34609,7 +35893,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34683,7 +35970,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34770,7 +36060,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34839,7 +36132,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -34908,7 +36204,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35005,7 +36304,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35204,7 +36506,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35256,7 +36561,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35311,7 +36619,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35408,7 +36719,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35632,7 +36946,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35690,7 +37007,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -35749,7 +37069,10 @@ interface operations {
                  *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
                  *     - Retrying with the same key replays the first response when it was a success (2xx) or a
                  *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
-                 *       After a 5xx, check whether the operation took effect before retrying with a **new** key
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
                  *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
                  *     - Stored responses expire 24 hours after processing
                  *
@@ -36153,6 +37476,589 @@ interface operations {
             default: components["responses"]["UnexpectedError"];
         };
     };
+    listAccountEmailDomains: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Email domains retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "success": true,
+                     *       "data": {
+                     *         "email_domains": [
+                     *           {
+                     *             "id": "550e8400-e29b-41d4-a716-446655440000",
+                     *             "domain": "facturas.ejemplo.com",
+                     *             "status": "PENDING",
+                     *             "is_default": true,
+                     *             "dns_records": [
+                     *               {
+                     *                 "type": "MX",
+                     *                 "name": "send",
+                     *                 "value": "mail.example.com",
+                     *                 "priority": 10,
+                     *                 "status": "PENDING"
+                     *               },
+                     *               {
+                     *                 "type": "TXT",
+                     *                 "name": "send",
+                     *                 "value": "v=spf1 include:example.com ~all",
+                     *                 "status": "PENDING"
+                     *               }
+                     *             ],
+                     *             "created_at": "2025-01-20T14:30:00Z"
+                     *           }
+                     *         ],
+                     *         "max_email_domains": 3
+                     *       },
+                     *       "meta": {
+                     *         "timestamp": "2025-01-20T15:00:00Z",
+                     *         "request_id": "req_123"
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EmailDomainListResponse"];
+                };
+            };
+            400: components["responses"]["InvalidRequestTarget"];
+            401: components["responses"]["Unauthorized"];
+            /**
+             * @description The credential cannot reach the account in the path, or lacks the `email-domains:read` scope.
+             *     An account you cannot reach and an account that does not exist answer identically.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
+    createAccountEmailDomain: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Idempotency key to prevent duplicates in sensitive operations.
+                 *
+                 *     - Any unique client-generated string (e.g. an order id). A UUID also works but is not required
+                 *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
+                 *     - Retrying with the same key replays the first response when it was a success (2xx) or a
+                 *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
+                 *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
+                 *     - Stored responses expire 24 hours after processing
+                 *
+                 *     The key is scoped per user and environment, and bound to the request body, so retrying after
+                 *     a network timeout replays the stored response instead of repeating the operation.
+                 *
+                 *     | Status | Code | When |
+                 *     |---|---|---|
+                 *     | `400` | `INVALID_IDEMPOTENCY_KEY` | The key breaks the format rules above. |
+                 *     | `409` | `IDEMPOTENCY_KEY_PROCESSING` | The first request is still in flight. Wait for the `Retry-After` seconds (2) and retry with the same key. |
+                 *     | `409` | `IDEMPOTENCY_KEY_MISMATCH` | The key was already used with a **different** body. Use a new key. |
+                 * @example invoice-order-12345
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKeyHeader"];
+            };
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "domain": "facturas.ejemplo.com"
+                 *     }
+                 */
+                "application/json": components["schemas"]["CreateEmailDomainRequest"];
+            };
+        };
+        responses: {
+            /** @description Email domain registered */
+            201: {
+                headers: {
+                    Location: components["headers"]["CreatedResourceLocation"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "success": true,
+                     *       "data": {
+                     *         "id": "550e8400-e29b-41d4-a716-446655440000",
+                     *         "domain": "facturas.ejemplo.com",
+                     *         "status": "PENDING",
+                     *         "is_default": true,
+                     *         "dns_records": [
+                     *           {
+                     *             "type": "MX",
+                     *             "name": "send",
+                     *             "value": "mail.example.com",
+                     *             "priority": 10,
+                     *             "status": "PENDING"
+                     *           },
+                     *           {
+                     *             "type": "TXT",
+                     *             "name": "send",
+                     *             "value": "v=spf1 include:example.com ~all",
+                     *             "status": "PENDING"
+                     *           }
+                     *         ],
+                     *         "created_at": "2025-01-20T14:30:00Z"
+                     *       },
+                     *       "meta": {
+                     *         "timestamp": "2025-01-20T14:30:00Z",
+                     *         "request_id": "req_123"
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EmailDomainResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description `PAYMENT_REQUIRED` — the billing of your account is unpaid (payment retries are exhausted), so the operation is refused until the outstanding invoice is settled. */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description The credential cannot reach the account in the path, lacks the `email-domains:write` scope,
+             *     is a test API key (`LIVE_CREDENTIAL_REQUIRED`), or the account does not have the custom
+             *     email domain add-on (`FEATURE_NOT_AVAILABLE`). An account you cannot reach and an account
+             *     that does not exist answer identically.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description `EMAIL_DOMAIN_UNAVAILABLE` or `EMAIL_DOMAIN_LIMIT_REACHED`; `error.code` tells them apart. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description `EMAIL_DOMAIN_INVALID` or `EMAIL_DOMAIN_RESERVED`; `error.code` tells them apart. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            /**
+             * @description `EXTERNAL_SERVICE_ERROR` — the domain could not be registered with the email sending service.
+             *     Nothing was registered. It is transient; repeat the request later.
+             */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
+    getAccountEmailDomain: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+                /** @description Identifier of the email domain. */
+                email_domain_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Email domain retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "success": true,
+                     *       "data": {
+                     *         "id": "550e8400-e29b-41d4-a716-446655440000",
+                     *         "domain": "facturas.ejemplo.com",
+                     *         "status": "PENDING",
+                     *         "is_default": true,
+                     *         "dns_records": [
+                     *           {
+                     *             "type": "MX",
+                     *             "name": "send",
+                     *             "value": "mail.example.com",
+                     *             "priority": 10,
+                     *             "status": "PENDING"
+                     *           }
+                     *         ],
+                     *         "created_at": "2025-01-20T14:30:00Z"
+                     *       },
+                     *       "meta": {
+                     *         "timestamp": "2025-01-20T15:00:00Z",
+                     *         "request_id": "req_123"
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EmailDomainResponse"];
+                };
+            };
+            400: components["responses"]["InvalidRequestTarget"];
+            401: components["responses"]["Unauthorized"];
+            /**
+             * @description The credential cannot reach the account in the path, or lacks the `email-domains:read` scope.
+             *     An account you cannot reach and an account that does not exist answer identically.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            404: components["responses"]["EmailDomainNotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
+    deleteAccountEmailDomain: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Idempotency key to prevent duplicates in sensitive operations.
+                 *
+                 *     - Any unique client-generated string (e.g. an order id). A UUID also works but is not required
+                 *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
+                 *     - Retrying with the same key replays the first response when it was a success (2xx) or a
+                 *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
+                 *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
+                 *     - Stored responses expire 24 hours after processing
+                 *
+                 *     The key is scoped per user and environment, and bound to the request body, so retrying after
+                 *     a network timeout replays the stored response instead of repeating the operation.
+                 *
+                 *     | Status | Code | When |
+                 *     |---|---|---|
+                 *     | `400` | `INVALID_IDEMPOTENCY_KEY` | The key breaks the format rules above. |
+                 *     | `409` | `IDEMPOTENCY_KEY_PROCESSING` | The first request is still in flight. Wait for the `Retry-After` seconds (2) and retry with the same key. |
+                 *     | `409` | `IDEMPOTENCY_KEY_MISMATCH` | The key was already used with a **different** body. Use a new key. |
+                 * @example invoice-order-12345
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKeyHeader"];
+            };
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+                /** @description Identifier of the email domain. */
+                email_domain_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Email domain removed successfully */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["InvalidRequestTarget"];
+            401: components["responses"]["Unauthorized"];
+            /**
+             * @description The credential cannot reach the account in the path, lacks the `email-domains:write` scope,
+             *     or is a test API key (`LIVE_CREDENTIAL_REQUIRED`). An account you cannot reach and an
+             *     account that does not exist answer identically.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            404: components["responses"]["EmailDomainNotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
+    verifyAccountEmailDomain: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Idempotency key to prevent duplicates in sensitive operations.
+                 *
+                 *     - Any unique client-generated string (e.g. an order id). A UUID also works but is not required
+                 *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
+                 *     - Retrying with the same key replays the first response when it was a success (2xx) or a
+                 *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
+                 *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
+                 *     - Stored responses expire 24 hours after processing
+                 *
+                 *     The key is scoped per user and environment, and bound to the request body, so retrying after
+                 *     a network timeout replays the stored response instead of repeating the operation.
+                 *
+                 *     | Status | Code | When |
+                 *     |---|---|---|
+                 *     | `400` | `INVALID_IDEMPOTENCY_KEY` | The key breaks the format rules above. |
+                 *     | `409` | `IDEMPOTENCY_KEY_PROCESSING` | The first request is still in flight. Wait for the `Retry-After` seconds (2) and retry with the same key. |
+                 *     | `409` | `IDEMPOTENCY_KEY_MISMATCH` | The key was already used with a **different** body. Use a new key. |
+                 * @example invoice-order-12345
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKeyHeader"];
+            };
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+                /** @description Identifier of the email domain. */
+                email_domain_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Verification requested */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "success": true,
+                     *       "data": {
+                     *         "id": "550e8400-e29b-41d4-a716-446655440000",
+                     *         "domain": "facturas.ejemplo.com",
+                     *         "status": "PENDING",
+                     *         "is_default": false,
+                     *         "dns_records": [
+                     *           {
+                     *             "type": "MX",
+                     *             "name": "send",
+                     *             "value": "mail.example.com",
+                     *             "priority": 10,
+                     *             "status": "PENDING"
+                     *           }
+                     *         ],
+                     *         "created_at": "2025-01-20T14:30:00Z"
+                     *       },
+                     *       "meta": {
+                     *         "timestamp": "2025-01-20T15:30:00Z",
+                     *         "request_id": "req_123"
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EmailDomainResponse"];
+                };
+            };
+            400: components["responses"]["InvalidRequestTarget"];
+            401: components["responses"]["Unauthorized"];
+            /** @description `PAYMENT_REQUIRED` — the billing of your account is unpaid (payment retries are exhausted), so the operation is refused until the outstanding invoice is settled. */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description The credential cannot reach the account in the path, lacks the `email-domains:write` scope,
+             *     is a test API key (`LIVE_CREDENTIAL_REQUIRED`), or the account does not have the custom
+             *     email domain add-on (`FEATURE_NOT_AVAILABLE`). An account you cannot reach and an account
+             *     that does not exist answer identically.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            404: components["responses"]["EmailDomainNotFound"];
+            /** @description `EMAIL_DOMAIN_NOT_READY` — the domain is still registering with the email sending service (`dns_records: []`). */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            /**
+             * @description `EXTERNAL_SERVICE_ERROR` — the verification could not be requested from the email sending service.
+             *     Nothing changed. It is transient; repeat the request later.
+             */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
+    setAccountEmailDomainDefault: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Idempotency key to prevent duplicates in sensitive operations.
+                 *
+                 *     - Any unique client-generated string (e.g. an order id). A UUID also works but is not required
+                 *     - Allowed characters: letters, digits, `_` and `-` (max 255 chars)
+                 *     - Retrying with the same key replays the first response when it was a success (2xx) or a
+                 *       server error (5xx): same status and body, plus the header `Idempotency-Replay: true`.
+                 *       After a 5xx other than 503, check whether the operation took effect before retrying with a **new** key
+                 *     - After a `503`, retry first with the **same** key. If the response carries `Idempotency-Replay: true`,
+                 *       the operation may have taken effect: check the resource before using a new key. Without that header,
+                 *       the retry runs the operation once
+                 *     - A 4xx is not stored: the key is released, so the corrected request can reuse it
+                 *     - Stored responses expire 24 hours after processing
+                 *
+                 *     The key is scoped per user and environment, and bound to the request body, so retrying after
+                 *     a network timeout replays the stored response instead of repeating the operation.
+                 *
+                 *     | Status | Code | When |
+                 *     |---|---|---|
+                 *     | `400` | `INVALID_IDEMPOTENCY_KEY` | The key breaks the format rules above. |
+                 *     | `409` | `IDEMPOTENCY_KEY_PROCESSING` | The first request is still in flight. Wait for the `Retry-After` seconds (2) and retry with the same key. |
+                 *     | `409` | `IDEMPOTENCY_KEY_MISMATCH` | The key was already used with a **different** body. Use a new key. |
+                 * @example invoice-order-12345
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKeyHeader"];
+            };
+            path: {
+                /** @description Your own account, or an account you provisioned. The account in the path, not the credential, decides which account the operation acts on. A `403` is returned when you do not reach it, the same response an account that does not exist gets. */
+                account_id: string;
+                /** @description Identifier of the email domain. */
+                email_domain_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default email domain set successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "success": true,
+                     *       "data": {
+                     *         "id": "550e8400-e29b-41d4-a716-446655440000",
+                     *         "domain": "facturas.ejemplo.com",
+                     *         "status": "VERIFIED",
+                     *         "is_default": true,
+                     *         "dns_records": [
+                     *           {
+                     *             "type": "MX",
+                     *             "name": "send",
+                     *             "value": "mail.example.com",
+                     *             "priority": 10,
+                     *             "status": "VERIFIED"
+                     *           }
+                     *         ],
+                     *         "created_at": "2025-01-20T14:30:00Z",
+                     *         "verified_at": "2025-01-20T15:10:00Z",
+                     *         "last_checked_at": "2025-01-20T15:10:00Z"
+                     *       },
+                     *       "meta": {
+                     *         "timestamp": "2025-01-20T15:30:00Z",
+                     *         "request_id": "req_123"
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EmailDomainResponse"];
+                };
+            };
+            400: components["responses"]["InvalidRequestTarget"];
+            401: components["responses"]["Unauthorized"];
+            /**
+             * @description The credential cannot reach the account in the path, lacks the `email-domains:write` scope,
+             *     or is a test API key (`LIVE_CREDENTIAL_REQUIRED`). An account you cannot reach and an
+             *     account that does not exist answer identically.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            404: components["responses"]["EmailDomainNotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["InternalServerError"];
+            default: components["responses"]["UnexpectedError"];
+        };
+    };
     listEmailDeliveries: {
         parameters: {
             query?: {
@@ -36411,6 +38317,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36469,6 +38377,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36528,6 +38438,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36596,6 +38508,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36657,6 +38571,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36719,6 +38635,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36780,6 +38698,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36838,6 +38758,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36903,6 +38825,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -36962,6 +38886,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -37024,6 +38950,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -37082,6 +39010,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -37143,6 +39073,8 @@ declare class InvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -38627,6 +40559,7 @@ declare class CompanyPaymentEventsResource {
         failure_reason?: string | null;
         failure_message?: string | null;
         needs_action: boolean;
+        outcome: components["schemas"]["PaymentEventOutcome"];
         draft_available: boolean;
         retry_available: boolean;
         discard_available: boolean;
@@ -38669,6 +40602,7 @@ declare class CompanyPaymentEventsResource {
         failure_reason?: string | null;
         failure_message?: string | null;
         needs_action: boolean;
+        outcome: components["schemas"]["PaymentEventOutcome"];
         draft_available: boolean;
         retry_available: boolean;
         discard_available: boolean;
@@ -38719,6 +40653,7 @@ declare class CompanyPaymentEventsResource {
         failure_reason?: string | null;
         failure_message?: string | null;
         needs_action: boolean;
+        outcome: components["schemas"]["PaymentEventOutcome"];
         draft_available: boolean;
         retry_available: boolean;
         discard_available: boolean;
@@ -38759,6 +40694,7 @@ declare class CompanyPaymentEventsResource {
         failure_reason?: string | null;
         failure_message?: string | null;
         needs_action: boolean;
+        outcome: components["schemas"]["PaymentEventOutcome"];
         draft_available: boolean;
         retry_available: boolean;
         discard_available: boolean;
@@ -38799,6 +40735,7 @@ declare class CompanyPaymentEventsResource {
         failure_reason?: string | null;
         failure_message?: string | null;
         needs_action: boolean;
+        outcome: components["schemas"]["PaymentEventOutcome"];
         draft_available: boolean;
         retry_available: boolean;
         discard_available: boolean;
@@ -39070,6 +41007,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39167,6 +41106,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39252,6 +41193,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39312,6 +41255,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39373,6 +41318,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39441,6 +41388,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39502,6 +41451,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39574,6 +41525,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39634,6 +41587,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39704,6 +41659,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39784,6 +41741,8 @@ declare class CompanyInvoicesResource {
         rectified_invoice_id?: string;
         source_proforma_id?: string;
         converted_invoice_id?: string;
+        replaced_by_invoice_id?: string;
+        rectified_by_invoice_ids?: string[];
         rectification_reason?: string;
         recurring_invoice_id?: string | null;
         recurring_invoice_name?: string | null;
@@ -39991,6 +41950,8 @@ declare class CompanyInvoiceScheduleResource {
         rectified_invoice_id?: string | undefined;
         source_proforma_id?: string | undefined;
         converted_invoice_id?: string | undefined;
+        replaced_by_invoice_id?: string | undefined;
+        rectified_by_invoice_ids?: string[] | undefined;
         rectification_reason?: string | undefined;
         recurring_invoice_id?: string | null | undefined;
         recurring_invoice_name?: string | null | undefined;
@@ -41139,6 +43100,8 @@ declare class CompanyRecurringInvoicesResource {
         rectified_invoice_id?: string | undefined;
         source_proforma_id?: string | undefined;
         converted_invoice_id?: string | undefined;
+        replaced_by_invoice_id?: string | undefined;
+        rectified_by_invoice_ids?: string[] | undefined;
         rectification_reason?: string | undefined;
         recurring_invoice_id?: string | null | undefined;
         recurring_invoice_name?: string | null | undefined;