@codespar/sdk 0.16.4 → 0.16.6

package/dist/generated/openapi.d.ts

@@ -6141,6 +6141,11 @@ export interface paths {
                                 status: "active" | "blocked" | "canceled";
                                 /** @description The card's token in the cardholder-data environment. Null until ingest lands, which is its own step after the card exists, so a freshly issued card can be readable here with no token yet. */
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             }[];
@@ -6269,6 +6274,11 @@ export interface paths {
                                 status: "active" | "blocked" | "canceled";
                                 /** @description The card's token in the cardholder-data environment. Null until ingest lands, which is its own step after the card exists, so a freshly issued card can be readable here with no token yet. */
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             };
@@ -6313,6 +6323,11 @@ export interface paths {
                                 status: "active" | "blocked" | "canceled";
                                 /** @description The card's token in the cardholder-data environment. Null until ingest lands, which is its own step after the card exists, so a freshly issued card can be readable here with no token yet. */
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             } | null;
@@ -6353,6 +6368,11 @@ export interface paths {
                                 status: "active" | "blocked" | "canceled";
                                 /** @description The card's token in the cardholder-data environment. Null until ingest lands, which is its own step after the card exists, so a freshly issued card can be readable here with no token yet. */
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             };
@@ -6406,6 +6426,11 @@ export interface paths {
                                 status: "active" | "blocked" | "canceled";
                                 /** @description The card's token in the cardholder-data environment. Null until ingest lands, which is its own step after the card exists, so a freshly issued card can be readable here with no token yet. */
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             } | null;
@@ -6621,6 +6646,11 @@ export interface paths {
                             status: "active" | "blocked" | "canceled";
                             /** @description The card's token in the cardholder-data environment. Null until ingest lands, which is its own step after the card exists, so a freshly issued card can be readable here with no token yet. */
                             token_id: string | null;
+                            /**
+                             * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                             * @enum {string}
+                             */
+                            cde: "ingested" | "not_ingested" | "not_configured";
                             /** Format: date-time */
                             created_at: string;
                         } | {
@@ -6664,6 +6694,11 @@ export interface paths {
                                 status: "active" | "blocked" | "canceled";
                                 /** @description The card's token in the cardholder-data environment. Null until ingest lands, which is its own step after the card exists, so a freshly issued card can be readable here with no token yet. */
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             } | null;
@@ -8300,6 +8335,11 @@ export interface paths {
                             status: "active" | "blocked" | "canceled";
                             /** @description The card-data-environment token id, null until the mint flow allocates one. Allocation happens BEFORE the card material is ingested, so a token id with no material behind it is a recorded failure rather than a silent gap. It is the handle a PCI-scoped surface exchanges for card material; no card material is reachable through this API with it. */
                             token_id: string | null;
+                            /**
+                             * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                             * @enum {string}
+                             */
+                            cde: "ingested" | "not_ingested" | "not_configured";
                             /** Format: date-time */
                             created_at: string;
                         } | {
@@ -8334,6 +8374,11 @@ export interface paths {
                                 status: "active" | "blocked" | "canceled";
                                 /** @description The card-data-environment token id, null until the mint flow allocates one. Allocation happens BEFORE the card material is ingested, so a token id with no material behind it is a recorded failure rather than a silent gap. It is the handle a PCI-scoped surface exchanges for card material; no card material is reachable through this API with it. */
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             } | null;
@@ -8455,6 +8500,11 @@ export interface paths {
                                 /** @enum {string} */
                                 status: "active" | "blocked" | "canceled";
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             };
@@ -8492,6 +8542,11 @@ export interface paths {
                                 /** @enum {string} */
                                 status: "active" | "blocked" | "canceled";
                                 token_id: string | null;
+                                /**
+                                 * @description Whether the cardholder-data environment holds this card's PAN. `ingested`: it does, and `token_id` names the token. `not_configured`: this deployment has no CDE, the PAN was never asked for, and no retry of the Idempotency-Key changes that — a deployment posture, not a caller fault. `not_ingested`: a CDE exists and the card has no token; on a mint that is the 502 `issuer_ingest_failed` retry contract, on a read it is a card whose ingest has not landed.
+                                 * @enum {string}
+                                 */
+                                cde: "ingested" | "not_ingested" | "not_configured";
                                 /** Format: date-time */
                                 created_at: string;
                             };
@@ -15132,6 +15187,8 @@ export interface paths {
          *
          *     **`idempotency_key` is REQUIRED for that combination**, and it is checked before anything reaches the issuer. A repeat with the same key returns the charge already issued, or its still-open reservation, instead of a second receivable the same debtor could pay twice. Send it as the `Idempotency-Key` header, as the body's `idempotency_key`, or as both with the SAME value; two different values are refused rather than one silently winning.
          *
+         *     **`consumer_id` is REQUIRED for a `boleto` too**: it names the merchant-side consumer the receivable settles into, and its wallet is what the payment credits. Without it there is nothing to settle into and the call is refused with `consumer_id_required` before anything is sent. In a test project any stable id of your own works: the project's shared-sandbox receiver stands in for the consumer's account at the issuer (the consumer is never onboarded there), and `POST /v1/test/charges/{chargeId}/pay` settles the charge into that consumer's wallet.
+         *
          *     An agreement in N instalments is N cobranças, one per parcela, each with its own `due_date` and its own key. There is no single instalment charge.
          *
          *     **Each refusal names a `reason`, and the reason is what to branch on.** The two error `code` values (`invalid_args`, `provider_error`) are too coarse: they cover six different situations, and reading them as one would turn `not found` into `bad request`.
@@ -15140,7 +15197,9 @@ export interface paths {
          *     |---|---|---|
          *     | `charge_id_missing` | 400 | the call named no charge |
          *     | `project_scope_missing` | 400 | the credential is not project-scoped, and a charge belongs to one project |
+         *     | `consumer_id_required` | 400 | a `boleto` create named no `consumer_id`, so there is no wallet for the receivable to settle into |
          *     | `charge_not_found` | 404 | no charge under that id FOR THIS TENANT |
+         *     | `charge_reference_ambiguous` | 409 | the reference is one charge's id AND another's idempotency key; query by the charge id |
          *     | `issuance_unconfirmed` | 409 | the key holds a reservation whose create never got an answer |
          *     | `already_payment_notified` | 409 | the clearing house already notified a payment |
          *     | `not_cancellable_in_this_state` | 409 | the issuer accepts a cancellation only in some states |
@@ -15159,11 +15218,13 @@ export interface paths {
             requestBody?: {
                 content: {
                     "application/json": {
-                        /** @description In minor units. */
+                        /** @description In MAJOR units of `currency`, NOT minor: `12.5` is R$ 12,50 and comes back as `amount_minor: 1250`. Sending `1250` here issues a R$ 1.250,00 charge. This is the one field of the charge family that takes major units; every `*_minor` field, including the response's `amount_minor`, is in centavos. */
                         amount: number;
                         currency: string;
                         /** @description `pix`, `boleto`, `card` or `wallet`. */
                         method: string;
+                        /** @description The merchant-side consumer the charge settles into: its wallet is credited when the debtor pays. REQUIRED for `boleto` (refused with `consumer_id_required` otherwise); optional for the other methods, where an absent value falls back to the session's user when there is one. */
+                        consumer_id?: string;
                         description?: string;
                         buyer?: {
                             [key: string]: unknown;
@@ -15189,7 +15250,11 @@ export interface paths {
                         "application/json": {
                             /** @description The issuer's charge id. Null while the issuance is unconfirmed. */
                             id: string | null;
-                            /** @description The provider's state as far as we know it, normalized. Forced to PROCESSING until the issuance is confirmed. */
+                            /**
+                             * @description The provider's state as far as we know it, normalized (`PROCESSING`, `PENDING`, `CONFIRMED`, `CANCELLED`, `EXPIRED`). Forced to PROCESSING until the issuance is confirmed.
+                             *
+                             *     **A charge settled by the sandbox payer answers `CONFIRMED` here**, the same value a real payment leaves a live read answering — so a client that polls `status` sees the test payment exactly where it would see a live one. The issuer's homolog account never sees that money and keeps answering PENDING (EXPIRED after the due date); that answer stays in `raw` and is not reported as `status` or as a `status_conflict`, because for a test charge the fixture is the issuer's truth. `settlement: "confirmed"` and `local_status: "settled"` say the same thing from our side.
+                             */
                             status: string;
                             /** @description What CodeSpar recorded, which is a different question from `status`. */
                             local_status: string;
@@ -15197,9 +15262,9 @@ export interface paths {
                             status_conflict: boolean;
                             method: string;
                             currency: string;
-                            /** @description In units. */
+                            /** @description In MAJOR units of `currency`: `12.5` is R$ 12,50. Always `amount_minor / 100`. */
                             amount: number;
-                            /** @description In minor units. */
+                            /** @description In minor units (centavos): `1250` is R$ 12,50. */
                             amount_minor: number;
                             due_date: string | null;
                             /** @description True only when all four hold: the issuance is confirmed, our row is still open, the provider says PENDING, and at least one document exists. This is the field to branch on, not `status`. */
@@ -15224,7 +15289,7 @@ export interface paths {
                         };
                     };
                 };
-                /** @description The call is malformed, or the two idempotency keys disagree. */
+                /** @description The call is malformed, names no consumer for a boleto, or the two idempotency keys disagree. */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -15233,7 +15298,7 @@ export interface paths {
                         "application/json": {
                             error: {
                                 /** @enum {string} */
-                                code: "charge_idempotency_key_required" | "idempotency_key_conflict";
+                                code: "charge_idempotency_key_required" | "consumer_id_required" | "idempotency_key_conflict";
                                 message: string;
                                 details?: {
                                     [key: string]: unknown;
@@ -15301,7 +15366,9 @@ export interface paths {
         };
         /**
          * Read a charge
-         * @description Reads a charge this project issued. `chargeId` accepts EITHER the id the create returned OR the caller's own `idempotency_key` — the row is resolved under this credential's org and project, which is what makes another tenant's id simply not found.
+         * @description Reads a charge this project issued. `chargeId` accepts EITHER the id the create returned (the issuer's charge transaction id) OR the caller's own `idempotency_key` — the row is resolved under this credential's org and project, which is what makes another tenant's id simply not found. A value that is one charge's id AND another charge's key is refused with `charge_reference_ambiguous` rather than answered for whichever came first; query by the charge id in that case. The Pix leg's own transaction id is not a reference here.
+         *
+         *     **A charge the sandbox payer settled answers `status: "CONFIRMED"`** with `settlement: "confirmed"` and `local_status: "settled"` — see `status` on the response for why the issuer's own PENDING is not reported.
          *
          *     **Branch on `payable`, not on `status`.** `payable` is true only when the issuance is confirmed, our row is still open, the provider says PENDING, and at least one payable document exists. A cobrança com vencimento answers PROCESSING with `payable: false` and no document at first, because the instrument registers with the clearing house before it can be paid.
          *
@@ -15313,7 +15380,9 @@ export interface paths {
          *     |---|---|---|
          *     | `charge_id_missing` | 400 | the call named no charge |
          *     | `project_scope_missing` | 400 | the credential is not project-scoped, and a charge belongs to one project |
+         *     | `consumer_id_required` | 400 | a `boleto` create named no `consumer_id`, so there is no wallet for the receivable to settle into |
          *     | `charge_not_found` | 404 | no charge under that id FOR THIS TENANT |
+         *     | `charge_reference_ambiguous` | 409 | the reference is one charge's id AND another's idempotency key; query by the charge id |
          *     | `issuance_unconfirmed` | 409 | the key holds a reservation whose create never got an answer |
          *     | `already_payment_notified` | 409 | the clearing house already notified a payment |
          *     | `not_cancellable_in_this_state` | 409 | the issuer accepts a cancellation only in some states |
@@ -15342,7 +15411,11 @@ export interface paths {
                         "application/json": {
                             /** @description The issuer's charge id. Null while the issuance is unconfirmed. */
                             id: string | null;
-                            /** @description The provider's state as far as we know it, normalized. Forced to PROCESSING until the issuance is confirmed. */
+                            /**
+                             * @description The provider's state as far as we know it, normalized (`PROCESSING`, `PENDING`, `CONFIRMED`, `CANCELLED`, `EXPIRED`). Forced to PROCESSING until the issuance is confirmed.
+                             *
+                             *     **A charge settled by the sandbox payer answers `CONFIRMED` here**, the same value a real payment leaves a live read answering — so a client that polls `status` sees the test payment exactly where it would see a live one. The issuer's homolog account never sees that money and keeps answering PENDING (EXPIRED after the due date); that answer stays in `raw` and is not reported as `status` or as a `status_conflict`, because for a test charge the fixture is the issuer's truth. `settlement: "confirmed"` and `local_status: "settled"` say the same thing from our side.
+                             */
                             status: string;
                             /** @description What CodeSpar recorded, which is a different question from `status`. */
                             local_status: string;
@@ -15350,9 +15423,9 @@ export interface paths {
                             status_conflict: boolean;
                             method: string;
                             currency: string;
-                            /** @description In units. */
+                            /** @description In MAJOR units of `currency`: `12.5` is R$ 12,50. Always `amount_minor / 100`. */
                             amount: number;
-                            /** @description In minor units. */
+                            /** @description In minor units (centavos): `1250` is R$ 12,50. */
                             amount_minor: number;
                             due_date: string | null;
                             /** @description True only when all four hold: the issuance is confirmed, our row is still open, the provider says PENDING, and at least one document exists. This is the field to branch on, not `status`. */
@@ -15417,7 +15490,7 @@ export interface paths {
                         };
                     };
                 };
-                /** @description The charge exists and is not readable in this state. */
+                /** @description The charge exists and is not readable in this state, or the reference names two charges. */
                 409: {
                     headers: {
                         [name: string]: unknown;
@@ -15426,7 +15499,7 @@ export interface paths {
                         "application/json": {
                             error: {
                                 /** @enum {string} */
-                                code: "issuance_unconfirmed";
+                                code: "issuance_unconfirmed" | "charge_reference_ambiguous";
                                 message: string;
                                 details?: {
                                     [key: string]: unknown;
@@ -15490,7 +15563,9 @@ export interface paths {
          *     |---|---|---|
          *     | `charge_id_missing` | 400 | the call named no charge |
          *     | `project_scope_missing` | 400 | the credential is not project-scoped, and a charge belongs to one project |
+         *     | `consumer_id_required` | 400 | a `boleto` create named no `consumer_id`, so there is no wallet for the receivable to settle into |
          *     | `charge_not_found` | 404 | no charge under that id FOR THIS TENANT |
+         *     | `charge_reference_ambiguous` | 409 | the reference is one charge's id AND another's idempotency key; query by the charge id |
          *     | `issuance_unconfirmed` | 409 | the key holds a reservation whose create never got an answer |
          *     | `already_payment_notified` | 409 | the clearing house already notified a payment |
          *     | `not_cancellable_in_this_state` | 409 | the issuer accepts a cancellation only in some states |
@@ -15519,7 +15594,11 @@ export interface paths {
                         "application/json": {
                             /** @description The issuer's charge id. Null while the issuance is unconfirmed. */
                             id: string | null;
-                            /** @description The provider's state as far as we know it, normalized. Forced to PROCESSING until the issuance is confirmed. */
+                            /**
+                             * @description The provider's state as far as we know it, normalized (`PROCESSING`, `PENDING`, `CONFIRMED`, `CANCELLED`, `EXPIRED`). Forced to PROCESSING until the issuance is confirmed.
+                             *
+                             *     **A charge settled by the sandbox payer answers `CONFIRMED` here**, the same value a real payment leaves a live read answering — so a client that polls `status` sees the test payment exactly where it would see a live one. The issuer's homolog account never sees that money and keeps answering PENDING (EXPIRED after the due date); that answer stays in `raw` and is not reported as `status` or as a `status_conflict`, because for a test charge the fixture is the issuer's truth. `settlement: "confirmed"` and `local_status: "settled"` say the same thing from our side.
+                             */
                             status: string;
                             /** @description What CodeSpar recorded, which is a different question from `status`. */
                             local_status: string;
@@ -15527,9 +15606,9 @@ export interface paths {
                             status_conflict: boolean;
                             method: string;
                             currency: string;
-                            /** @description In units. */
+                            /** @description In MAJOR units of `currency`: `12.5` is R$ 12,50. Always `amount_minor / 100`. */
                             amount: number;
-                            /** @description In minor units. */
+                            /** @description In minor units (centavos): `1250` is R$ 12,50. */
                             amount_minor: number;
                             due_date: string | null;
                             /** @description True only when all four hold: the issuance is confirmed, our row is still open, the provider says PENDING, and at least one document exists. This is the field to branch on, not `status`. */
@@ -15603,7 +15682,7 @@ export interface paths {
                         "application/json": {
                             error: {
                                 /** @enum {string} */
-                                code: "issuance_unconfirmed" | "already_payment_notified" | "not_cancellable_in_this_state";
+                                code: "issuance_unconfirmed" | "already_payment_notified" | "not_cancellable_in_this_state" | "charge_reference_ambiguous";
                                 message: string;
                                 details?: {
                                     [key: string]: unknown;
@@ -15642,6 +15721,389 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/test/charges/{chargeId}/pay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pay a charge in the sandbox
+         * @description Plays the DEBTOR of a test charge: settles it through the SAME path a Celcoin `charge-in` webhook takes (translate, publish `commerce.charge.paid`, reconcile, ledger `fund()` with the `pending -> settled` claim). It is not a status write, so the event fans out to your triggers exactly as a real payment would, and the ledger and receipt side effects are the ones production produces.
+         *
+         *     **Test-mode only, fail-closed.** A live-environment key or project answers 403 `sandbox_pay_not_permitted` before the body is read or any query runs.
+         *
+         *     **Nothing claims money moved.** The event payload, the ledger entry and the charge row all carry `simulated: true` and `settled_against: "sandbox_fixture"`; a real `charge-in` never carries either.
+         *
+         *     **Idempotent.** The provider event id is the one the real delivery would carry, so a second pay dedupes at the event (no second trigger fire), the ledger dedupes on the charge, and a charge already `settled` answers its recorded state with `idempotent_replay: true` whatever amount the second call names.
+         *
+         *     `chargeId` is the id `create` returned, or your own idempotency key, resolved under the caller's org and project: another tenant's charge is `charge_not_found`, never `forbidden`.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    chargeId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description Overrides the quoted amount, in minor units, to simulate a partial or divergent payment. The funding bridge credits what arrived and closes the charge, exactly as it does for a real `charge-in` that disagrees with the quote. Omitted: the quoted amount is paid in full. */
+                        amount_minor?: number;
+                    };
+                };
+            };
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            charge_id: string;
+                            /** @enum {string} */
+                            status: "paid";
+                            /** @description What CodeSpar recorded: `settled`. */
+                            local_status: string;
+                            currency: string;
+                            quoted_minor: number;
+                            /** @description What the ledger credited. */
+                            paid_minor: number;
+                            /** @enum {string} */
+                            payment: "full" | "partial" | "over";
+                            /** @description The leg the simulated debtor used. Always `Pix` today. */
+                            paid_via: string;
+                            wallet_id: string;
+                            /** @description The `fund` entry keyed `bolepix:<charge_id>`. Null only for a charge the other credit path settled. */
+                            ledger_entry_id: string | null;
+                            /** @description The one `commerce.charge.paid` this charge has. A second pay never mints another. */
+                            event: {
+                                id: string;
+                                /** @enum {string} */
+                                type: "commerce.charge.paid";
+                            } | null;
+                            /** @description True when a sandbox fixture settled it. Read off the records, never off the request. */
+                            simulated: boolean;
+                            /** @enum {string|null} */
+                            settled_against: "sandbox_fixture" | null;
+                            /**
+                             * @description Nothing moved anywhere, including at the provider's sandbox.
+                             * @enum {boolean}
+                             */
+                            money_moved: false;
+                            /** @description True when the charge was already settled and this call answered from the record. */
+                            idempotent_replay: boolean;
+                        };
+                    };
+                };
+                /** @description The body is outside the schema, or the credential names no project. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "invalid_body" | "project_scope_missing";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description Not a test-environment key/project. Terminal for that credential. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "sandbox_pay_not_permitted";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description No charge under that id for this tenant. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "charge_not_found";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description The charge exists and cannot be paid: `issuance_unconfirmed` is a reservation whose create never got an answer; `charge_not_payable` is a charge already closed (expired or cancelled); `charge_reference_ambiguous` is a reference that is one charge's id and another's idempotency key — pay by the charge id. */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "issuance_unconfirmed" | "charge_not_payable" | "charge_reference_ambiguous";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description The payment event was published but the ledger credit did not land; the charge is still open. Retrying is safe — the event dedupes and the credit is keyed on the charge. */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "sandbox_settlement_failed";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/charges/{chargeId}/sandbox/pay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pay a charge in the sandbox (alias path)
+         * @deprecated
+         * @description Alias of `POST /v1/test/charges/{chargeId}/pay` (ent#979 contract: one handler, two paths, one scope). Same body, same answers.
+         *
+         *     Plays the DEBTOR of a test charge: settles it through the SAME path a Celcoin `charge-in` webhook takes (translate, publish `commerce.charge.paid`, reconcile, ledger `fund()` with the `pending -> settled` claim). It is not a status write, so the event fans out to your triggers exactly as a real payment would, and the ledger and receipt side effects are the ones production produces.
+         *
+         *     **Test-mode only, fail-closed.** A live-environment key or project answers 403 `sandbox_pay_not_permitted` before the body is read or any query runs.
+         *
+         *     **Nothing claims money moved.** The event payload, the ledger entry and the charge row all carry `simulated: true` and `settled_against: "sandbox_fixture"`; a real `charge-in` never carries either.
+         *
+         *     **Idempotent.** The provider event id is the one the real delivery would carry, so a second pay dedupes at the event (no second trigger fire), the ledger dedupes on the charge, and a charge already `settled` answers its recorded state with `idempotent_replay: true` whatever amount the second call names.
+         *
+         *     `chargeId` is the id `create` returned, or your own idempotency key, resolved under the caller's org and project: another tenant's charge is `charge_not_found`, never `forbidden`.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    chargeId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description Overrides the quoted amount, in minor units, to simulate a partial or divergent payment. The funding bridge credits what arrived and closes the charge, exactly as it does for a real `charge-in` that disagrees with the quote. Omitted: the quoted amount is paid in full. */
+                        amount_minor?: number;
+                    };
+                };
+            };
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            charge_id: string;
+                            /** @enum {string} */
+                            status: "paid";
+                            /** @description What CodeSpar recorded: `settled`. */
+                            local_status: string;
+                            currency: string;
+                            quoted_minor: number;
+                            /** @description What the ledger credited. */
+                            paid_minor: number;
+                            /** @enum {string} */
+                            payment: "full" | "partial" | "over";
+                            /** @description The leg the simulated debtor used. Always `Pix` today. */
+                            paid_via: string;
+                            wallet_id: string;
+                            /** @description The `fund` entry keyed `bolepix:<charge_id>`. Null only for a charge the other credit path settled. */
+                            ledger_entry_id: string | null;
+                            /** @description The one `commerce.charge.paid` this charge has. A second pay never mints another. */
+                            event: {
+                                id: string;
+                                /** @enum {string} */
+                                type: "commerce.charge.paid";
+                            } | null;
+                            /** @description True when a sandbox fixture settled it. Read off the records, never off the request. */
+                            simulated: boolean;
+                            /** @enum {string|null} */
+                            settled_against: "sandbox_fixture" | null;
+                            /**
+                             * @description Nothing moved anywhere, including at the provider's sandbox.
+                             * @enum {boolean}
+                             */
+                            money_moved: false;
+                            /** @description True when the charge was already settled and this call answered from the record. */
+                            idempotent_replay: boolean;
+                        };
+                    };
+                };
+                /** @description The body is outside the schema, or the credential names no project. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "invalid_body" | "project_scope_missing";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description Not a test-environment key/project. Terminal for that credential. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "sandbox_pay_not_permitted";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description No charge under that id for this tenant. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "charge_not_found";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description The charge exists and cannot be paid: `issuance_unconfirmed` is a reservation whose create never got an answer; `charge_not_payable` is a charge already closed (expired or cancelled); `charge_reference_ambiguous` is a reference that is one charge's id and another's idempotency key — pay by the charge id. */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "issuance_unconfirmed" | "charge_not_payable" | "charge_reference_ambiguous";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+                /** @description The payment event was published but the ledger credit did not land; the charge is still open. Retrying is safe — the event dedupes and the credit is keyed on the charge. */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: {
+                                /** @enum {string} */
+                                code: "sandbox_settlement_failed";
+                                message: string;
+                                details?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                            /** @description Echoes the `X-Request-Id` header when the request carried one. */
+                            request_id: string | null;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/consumers/consents": {
         parameters: {
             query?: never;