@atumlabs/payment-gateway-client 3.0.0 → 4.0.0

package/dist/sender-auth-verify-CEf7FN6s.d.ts

@@ -0,0 +1,2316 @@
+/**
+ * The result of a counterparty authorization request. Contains either
+ * the PSP's authorization decision (authorized/declined with proof) or
+ * an error indicating why authorization could not be completed.
+ *
+ */
+type AuthorizationResult = {
+    /**
+     * Correlation key for this authorization
+     */
+    payment_id: string;
+    /**
+     * The beneficiary PSP's DID
+     */
+    counterparty_did: string;
+    /**
+     * Authorization outcome. "authorized" or "declined" when the PSP responded.
+     * "error" or "timeout" when the authorization could not be completed.
+     *
+     */
+    status: 'authorized' | 'declined' | 'error' | 'timeout';
+    /**
+     * The PSP's raw authorization response (present when status is authorized or declined)
+     */
+    authorization_response?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Machine-readable error code (present when status is error or timeout).
+     * Counterparty-sourced codes are derived from the error code the
+     * Counterparty Gateway publishes. GATEWAY_TIMEOUT, PROOF_INVALID, and
+     * PROOF_STALE are raised by this gateway itself (no counterparty envelope corresponds).
+     *
+     */
+    error_code?: 'COUNTERPARTY_NOT_FOUND' | 'COUNTERPARTY_TIMEOUT' | 'WEBHOOK_ERROR' | 'WEBHOOK_CONNECTION_ERROR' | 'INTERNAL_ERROR' | 'GATEWAY_TIMEOUT' | 'PROOF_INVALID' | 'PROOF_STALE';
+    /**
+     * Human-readable error description
+     */
+    error_message?: string;
+    /**
+     * HTTP status code from the PSP webhook (only for WEBHOOK_ERROR)
+     */
+    webhook_http_status?: number;
+};
+/**
+ * Authorization outcome. "authorized" or "declined" when the PSP responded.
+ * "error" or "timeout" when the authorization could not be completed.
+ *
+ */
+type status = 'authorized' | 'declined' | 'error' | 'timeout';
+/**
+ * Machine-readable error code (present when status is error or timeout).
+ * Counterparty-sourced codes are derived from the error code the
+ * Counterparty Gateway publishes. GATEWAY_TIMEOUT, PROOF_INVALID, and
+ * PROOF_STALE are raised by this gateway itself (no counterparty envelope corresponds).
+ *
+ */
+type error_code = 'COUNTERPARTY_NOT_FOUND' | 'COUNTERPARTY_TIMEOUT' | 'WEBHOOK_ERROR' | 'WEBHOOK_CONNECTION_ERROR' | 'INTERNAL_ERROR' | 'GATEWAY_TIMEOUT' | 'PROOF_INVALID' | 'PROOF_STALE';
+/**
+ * Structured payment request with sender authorization and optional W3C Verifiable Credentials
+ */
+type PaymentRequest = {
+    /**
+     * Semver-shaped declaration version (MAJOR.MINOR). The major component is locked to this schema's parent directory (v1 → major must be 1). Producers MUST emit the canonical value exported by the bindings' Version constant; the canonical bumps on each additive minor evolution.
+     */
+    version: string;
+    /**
+     * Unique identifier for this payment request (used for idempotency)
+     */
+    request_id: string;
+    source: OwnedAsset;
+    /**
+     * Array of destination assets for the settlement agent to choose from (at least one required, at most 16).
+     * The ceiling bounds the fan-out one request can buy: every consumer iterates this list.
+     */
+    destination: Array<OwnedAsset>;
+    /**
+     * The exact amount to be received at the destination (in the smallest unit, e.g., wei for ETH, cents for USD).
+     */
+    fulfillment_amount: string;
+    /**
+     * The maximum amount willing to be spent from the source (in the smallest unit).
+     */
+    max_source_amount?: string;
+    /**
+     * Required. The deadline for receiving price quotes from settlement providers. After this
+     * point no new quotes are accepted. The gateway injects no default and validates the value
+     * is in the future. The originator must supply it, and a request that omits it or supplies
+     * a past value is rejected with 400.
+     *
+     * Keep this window short. A settler holds its quoted price for a limited period of its
+     * own choosing, and the gateway selects only once the window has closed, so a deadline
+     * set beyond that hold leaves no quote still awardable and the request is declined with
+     * QUOTE_WINDOW_TOO_LONG. That hold is set by each settler and is not part of this
+     * contract, so treat 60 seconds as a practical upper bound and prefer a shorter window
+     * where your integration allows.
+     */
+    quote_deadline: string;
+    /**
+     * Required. The final deadline for completing the payment. If not completed by this time the
+     * payment fails and is eligible for a refund. The gateway injects no default and validates
+     * the value is in the future. The originator must supply it, and a request that omits it or
+     * supplies a past value is rejected with 400.
+     */
+    fulfillment_deadline: string;
+    /**
+     * Who performs each leg of the payment. Omitted on the wire means settler for every leg. The split object keeps deposit, reserve, and fulfill as separate keys.
+     */
+    executor?: 'settler' | 'originator' | {
+        deposit: 'settler' | 'originator';
+        reserve: 'settler' | 'originator';
+        fulfill: 'settler' | 'originator';
+    };
+    /**
+     * Policy requirements for settler authentication. Keys are policy names, values indicate if the policy is required.
+     */
+    settler_auth_required?: {
+        [key: string]: (boolean);
+    };
+    sender_auth: SenderAuth;
+    originator_auth?: VerifiableCredentialAuth;
+    /**
+     * Wallet address or public key of a trusted service that will automatically select
+     * the best exchange rate for your payment. Leave empty to use the default selector.
+     */
+    quote_selector?: string;
+    /**
+     * The verification service that confirms the payment was delivered before the escrow
+     * releases the source funds, and the account it signs with. Required on every chain:
+     * the gateway's `/v1/defaults` response supplies it for each chain.
+     */
+    fulfillment_verifier: {
+        /**
+         * The wallet address or public key of the verification service
+         */
+        account: string;
+        /**
+         * Origin of the fulfillment verifier service, with no path — the caller
+         * appends the verifier's own API paths. The gateway's `/v1/defaults` response
+         * supplies the default fulfillment verifier for each chain.
+         */
+        endpoint: string;
+    };
+    /**
+     * Escrow contract on the source chain that holds the source funds until proof of fulfillment has been verified. Required on every chain. Take the value for the source chain from the payment gateway's GET /v1/defaults (`escrow_contract`).
+     */
+    escrow_contract_address: string;
+    /**
+     * Fulfillment Proxy contract address, used to emit proof of fulfillment on the destination chain. Leave empty to use the default.
+     */
+    fulfillment_proxy?: string;
+    /**
+     * Optional settler filtering requirements. If whitelist is present, only whitelisted settlers may win. If blacklist is present, blacklisted settlers are excluded. Both can be specified; blacklist takes precedence (a settler in both lists is rejected).
+     */
+    settler_requirements?: {
+        /**
+         * List of settler DIDs permitted to fulfill this request. If present and non-empty, only these settlers may win. Use W3C DID format (e.g., did:pkh:eip155:1:0xABC...).
+         */
+        whitelist?: Array<(string)>;
+        /**
+         * List of settler DIDs excluded from fulfilling this request. If present and non-empty, these settlers are rejected. Use W3C DID format (e.g., did:pkh:eip155:1:0xABC...).
+         */
+        blacklist?: Array<(string)>;
+    };
+};
+type deposit = 'settler' | 'originator';
+type reserve = 'settler' | 'originator';
+type fulfill = 'settler' | 'originator';
+/**
+ * Authorization for an originator to fulfill a payment request. The settler produces this declaration after authorizeFulfillment when the payment request's fulfill executor is "originator". A settler fulfill does not produce it.
+ *
+ * Canonical JSON Schema: schemas/declarations/FulfillmentAuthorization/v1/schema.json
+ * Published at https://schemas.atum.xyz/declarations/FulfillmentAuthorization/v1
+ */
+type FulfillmentAuthorization = {
+    /**
+     * Semver-shaped declaration version (MAJOR.MINOR). The major component is locked to this schema's parent directory (v1 → major must be 1).
+     */
+    version: string;
+    /**
+     * Authorization scheme.
+     */
+    scheme: 'EIP-3009';
+    /**
+     * Signed authorization. For scheme EIP-3009, message_prehash is the EIP-712 TransferWithAuthorization typed data as a JSON string ({domain, types, primaryType, message}, with uint256 values as decimal strings), message is its EIP-712 digest, signature is the settler's 65-byte signature over that digest, and payload is absent. message.validBefore is the payment request's fulfillment_deadline in whole unix seconds, and message.nonce is the fulfillment quote hash.
+     */
+    authorization: SignedMessage;
+    /**
+     * Raw JSON of the fulfillment quote (schemas/declarations/FulfillmentQuote/v1/schema.json), including proof metadata so its canonical quote hash can be computed.
+     */
+    fulfillment_quote_json: string;
+    /**
+     * Pointer to the on-chain evidence of the fulfillment authorization.
+     */
+    evidence: {
+        /**
+         * Chain transaction identifier. EVM transactions are 0x-prefixed hex, Tron transactions are hex without that prefix, and Solana transactions are base58.
+         */
+        transaction_id: string;
+        log_index: number;
+    };
+};
+/**
+ * Authorization scheme.
+ */
+type scheme = 'EIP-3009';
+/**
+ * Confirmation details after a payment has been successfully delivered.
+ * Contains proof of delivery and transaction details for both source and destination chains.
+ *
+ */
+type FulfillmentConfirmation = {
+    /**
+     * Unique identifier for this payment transaction.
+     * Use this to track the payment across all systems.
+     *
+     */
+    payment_id: string;
+    /**
+     * Your original request ID that was provided when creating the payment.
+     * Helps match confirmations to your internal systems.
+     *
+     */
+    request_id: string;
+    /**
+     * Timestamp when the fulfillment was completed
+     */
+    fulfillment_timestamp?: string;
+    /**
+     * The blockchain where funds were locked in escrow, using CAIP-2 format.
+     * CAIP-2 is a standard way to identify blockchains: {namespace}:{reference}
+     * Examples:
+     * - "eip155:1" for Ethereum mainnet
+     * - "eip155:42161" for Arbitrum
+     * - "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" for Solana
+     * - "tron:mainnet" for Tron
+     *
+     */
+    source_chain_id: string;
+    /**
+     * The blockchain where the payment was delivered, using CAIP-2 format.
+     * CAIP-2 is a standard way to identify blockchains: {namespace}:{reference}
+     * Examples:
+     * - "eip155:1" for Ethereum mainnet
+     * - "eip155:42161" for Arbitrum
+     * - "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" for Solana
+     * - "tron:mainnet" for Tron
+     *
+     */
+    destination_chain_id: string;
+    /**
+     * Transaction hash of the escrow reservation on the source chain
+     */
+    source_tx_hash: string;
+    /**
+     * Transaction hash of the fulfillment on the destination chain
+     */
+    destination_tx_hash: string;
+    /**
+     * Block number where the source transaction was confirmed
+     */
+    source_block_number?: number;
+    /**
+     * Block number where the destination transaction was confirmed
+     */
+    destination_block_number?: number;
+};
+/**
+ * Represents a cryptocurrency or token in a specific wallet. This tells the system what asset you're sending/receiving and which wallet to use.
+ */
+type OwnedAsset = {
+    /**
+     * A unique identifier for the asset using CAIP-19 format.
+     * CAIP-19 is a standard way to identify blockchain assets: {chain_id}/{asset_namespace}:{asset_reference}
+     * Examples:
+     * - Ethereum USDC: "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+     * - Arbitrum USDC: "eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+     * - Solana USDC: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+     * - Tron USDT: "tron:mainnet/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
+     */
+    asset_identifier: string;
+    /**
+     * The wallet address that owns this asset.
+     * Format depends on the blockchain:
+     * - Ethereum/EVM: 0x-prefixed hex address (42 characters)
+     * - Solana: Base58 encoded address
+     * - Tron: T-prefixed Base58 address
+     *
+     * A destination account is checked at ingress and must be payable on the chain named by
+     * its `asset_identifier`: it parses for that chain, carries a valid EIP-55 checksum when
+     * mixed-case, has no surrounding whitespace, and is not the zero address. A receiver that
+     * fails any of these is refused with `INVALID_DESTINATION_ACCOUNT`, before any funds move.
+     */
+    account: string;
+};
+/**
+ * Authorization from the asset owner to execute the payment. The exact format depends on the source blockchain's authorization mechanism.
+ */
+type SenderAuth = {
+    /**
+     * DEPRECATED: inner-document credential carrier. Credentials MUST ride ONLY in the holder-signed PaymentRequestEnvelope (PRE); the inner PaymentRequest carries no credential and its Data Integrity signature EXCLUDES this field (stripped before canonicalization on both producer and verifier). Populated only for one back-compat rollout cycle, then removed.
+     * @deprecated
+     */
+    verifiable_credential?: VerifiableCredentialAuth;
+    message_scheme: SenderAuthMessageScheme;
+    /**
+     * Array of signed messages (at least one required)
+     */
+    signed_messages: Array<SignedMessage>;
+};
+/**
+ * The signature method used for authorizing this payment:
+ * - `EVM_PERMIT2`: Gasless token approvals for Ethereum/EVM chains
+ * - `EVM_PERMIT2_ESCROW`: Gasless approvals with escrow support
+ * - `SOLANA`: Standard Solana transaction signatures
+ * - `TRON`: Tron transaction signatures
+ */
+type SenderAuthMessageScheme = 'EVM_PERMIT2' | 'EVM_PERMIT2_ESCROW' | 'SOLANA' | 'TRON';
+/**
+ * A message that has been cryptographically signed to prove authorization. The signature proves you control the wallet that's sending funds.
+ */
+type SignedMessage = {
+    /**
+     * The data that was signed, hex-encoded with a 0x prefix on every supported chain. For the deposit (signed_messages[0]) it is the 32-byte hash of message_prehash.
+     */
+    message: string;
+    /**
+     * The original data that `message` is the hash of. Required on every entry of a payment
+     * request's `sender_auth.signed_messages`: the gateway reads the signed terms from it.
+     */
+    message_prehash?: string;
+    /**
+     * The cryptographic signature proving you authorized this message. Hex-encoded with a 0x prefix on every supported chain. The signer's own public key is base58 on Solana, but the signature itself is not.
+     */
+    signature: string;
+    /**
+     * Optional chain-specific payload containing additional signing context (e.g., delegate_signer for Solana). Preserved through the pipeline for downstream consumers.
+     */
+    payload?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Optional identity verification using cryptographic credentials.
+ *
+ * DEPRECATED. Credentials are moving to a holder-signed W3C VerifiablePresentation that
+ * travels alongside a request rather than inside it. That envelope is not part of this
+ * HTTP contract, so there is nothing here to move them to yet: treat this as a legacy
+ * carrier, and do not build a new integration on it.
+ */
+type VerifiableCredentialAuth = {
+    verifiable_credential: VerifiableCredential;
+    /**
+     * Reference to verification method from the DID Document
+     */
+    verification_method_id: string;
+    /**
+     * Cryptographic signature matching the verification method type
+     */
+    signature: string;
+};
+/**
+ * W3C Verifiable Credential structure conforming to the W3C Verifiable Credentials Data Model v1.1
+ */
+type VerifiableCredential = {
+    /**
+     * JSON-LD context array, must include 'https://www.w3.org/2018/credentials/v1'
+     */
+    '@context': Array<(string)>;
+    /**
+     * Unique identifier for this credential
+     */
+    id: string;
+    /**
+     * Credential types, must include 'VerifiableCredential'
+     */
+    type: Array<(string)>;
+    /**
+     * DID or issuer object of the credential issuer
+     */
+    issuer: string | {
+        [key: string]: unknown;
+    };
+    /**
+     * When the credential was issued
+     */
+    issuanceDate: string;
+    /**
+     * When the credential expires
+     */
+    expirationDate?: string;
+    /**
+     * Claims about the credential subject (structure varies by issuer)
+     */
+    credentialSubject: {
+        [key: string]: unknown;
+    };
+    /**
+     * Information for credential revocation checking. Not consulted by the verifier today.
+     */
+    credentialStatus?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Cryptographic proof of credential integrity
+     */
+    proof: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Where your payment is in its lifecycle. One payment reads the same however you ask
+ * about it.
+ *
+ * - `pending`: accepted and in progress. Nothing has reached the recipient yet.
+ * - `finalizing`: the transaction paying your recipient is on chain and is accruing
+ * the confirmations its chain requires. NOT FINAL, see below.
+ * - `completed`: delivered, with the required confirmations behind it.
+ * - `failed`: did not complete. Any funds held in escrow are returned, and `error`
+ * describes what went wrong.
+ * - `refunding`: the settler will not deliver this payment and your funds are being
+ * returned from escrow. NOT FINAL: it becomes `refund_available` or `refunded`, and it
+ * can still become `completed` or `failed`.
+ * - `refund_available`: the settler did not deliver and the refund is authorized for you
+ * to submit. GET /v1/payments/{paymentId}/status returns `refund_signature`, which you
+ * submit to the source escrow to return your funds. The other responses report this
+ * status without the signature. NOT FINAL: the funds are still in escrow, so it becomes
+ * `refunded` once the refund lands, or `completed` if the settler delivers late and is
+ * paid first. Do not pay again while it is `refund_available`.
+ * - `refunded`: your funds were returned from the source escrow. `transactions.refund` is
+ * the refund transaction, when it is known.
+ *
+ * `completed`, `failed` and `refunded` are final and will not change afterwards.
+ * `pending`, `finalizing`, `refunding` and `refund_available` will.
+ *
+ * **Do not treat `finalizing` as delivered.** It says the payment has been made on
+ * chain but is not yet irreversible, much as a card authorization is not yet a
+ * settlement. It normally becomes `completed`, and it can still become `failed` if
+ * the transaction never reaches the confirmation depth its chain requires. Acting on
+ * `finalizing` — releasing goods, crediting an account — means accepting that risk
+ * deliberately, at whatever threshold suits you rather than the one we wait for.
+ *
+ * `finalizing` is about paying the recipient. While your own funds are still being
+ * committed on the source chain the payment is `pending`, because nothing has reached
+ * the recipient yet.
+ *
+ */
+type PaymentStatus = 'pending' | 'finalizing' | 'completed' | 'failed' | 'refunding' | 'refund_available' | 'refunded';
+/**
+ * One on-chain transaction belonging to a payment: which chain, which transaction, and
+ * which block it landed in.
+ *
+ * Whether the payment has actually happened is answered by `status`, not here. Read this
+ * to look the transaction up on chain and to verify it yourself.
+ *
+ */
+type PaymentTransaction = {
+    /**
+     * The transaction's hash on its chain. Hex hashes carry the `0x` prefix, including on
+     * Tron, whose own tooling omits it.
+     *
+     */
+    transaction_hash: string;
+    /**
+     * CAIP-2 identifier of the chain the transaction is on.
+     */
+    chain_id: string;
+    /**
+     * The block the transaction landed in. Absent until it has been mined.
+     *
+     * Provisional while `status` is `finalizing`: on a chain that settles against another,
+     * a reorganization there can move the transaction to a different block. Settled once
+     * `status` is `completed` — keep it as a final record only from then.
+     *
+     */
+    block_number?: number;
+};
+/**
+ * The transactions a payment has produced, one entry per stage, added as each becomes
+ * known. A stage absent here has produced no transaction yet.
+ *
+ * These are the movements that decide whether your payment happened: your funds being
+ * committed, your recipient being paid, and your funds being returned when the payment
+ * is refunded. Present on every outcome, so a payment that did not complete can still be
+ * traced on chain.
+ * `fulfillment_confirmation` is not a substitute: it is written only once a payment
+ * completes, and describes the finished delivery rather than progress towards it.
+ *
+ * Where a stage is attempted more than once, the entry describes the attempt that
+ * counts — the one that succeeded, or the last one if none did.
+ *
+ */
+type PaymentTransactions = {
+    /**
+     * Committing your funds on the source chain.
+     */
+    deposit?: PaymentTransaction;
+    /**
+     * Paying your recipient on the destination chain.
+     */
+    fulfillment?: PaymentTransaction;
+    /**
+     * Returning your funds from the escrow on the source chain. Can be absent on a
+     * `refunded` payment when the refund transaction is not known.
+     *
+     */
+    refund?: PaymentTransaction;
+};
+/**
+ * The refund authorization for a `refund_available` payment, as the verifier signed it.
+ * Submit it to the source chain's escrow `refund` to return your funds yourself.
+ *
+ * Anyone holding it can submit the refund, but the escrow only ever pays the depositor. If
+ * the settler delivers late and is paid first, the refund no longer goes through.
+ * On Solana the submitter also receives the rent of the deposit account the refund closes.
+ *
+ */
+type RefundSignature = {
+    /**
+     * The verifier's signature over `message_hash`. Hex with the `0x` prefix on EVM and
+     * Tron chains, hex without it on Solana.
+     *
+     */
+    signature: string;
+    /**
+     * The signed digest, hex without the `0x` prefix.
+     */
+    message_hash: string;
+    /**
+     * The signed message as JSON. On EVM and Tron chains it carries the RefundWitness the
+     * escrow's `refund` takes.
+     *
+     */
+    message_prehash: string;
+};
+/**
+ * Response from submitting a payment request. If settlement completes inside the
+ * gateway's synchronous window, the response includes a fulfillment_confirmation with
+ * full settlement details. Otherwise you receive a payment_id plus the payment's
+ * current `status`, and can poll /v1/payments/{paymentId}/status for updates.
+ *
+ * Read `status` before deciding what to do next: a `pending` or `finalizing` payment is
+ * in flight and must NOT be re-submitted under a new request_id (that would be a second
+ * payment), whereas a `failed` one is terminal — re-submitting it under the SAME
+ * request_id resolves to the same terminal payment, so a genuine re-attempt needs a
+ * new request_id.
+ *
+ * **A synchronously-completed payment carries proof of QUOTE as well as of delivery.** When
+ * settlement lands inside the window you get `status: completed`, a full
+ * `fulfillment_confirmation`, and — since a quote necessarily was awarded to get there —
+ * `quote_id` and `fulfillment_quote`. The fast path therefore needs no follow-up call to
+ * verify: recompute `quote_hash` over the returned quote and compare it against the on-chain
+ * commitment from this response alone.
+ *
+ * `status` is present on every response. `completed` is always accompanied by
+ * fulfillment_confirmation; `failed` is accompanied by `error` where a reason has been
+ * recorded.
+ *
+ */
+type PaymentResponse = {
+    /**
+     * Unique ID for tracking this payment. Save this to check status later.
+     *
+     */
+    payment_id: string;
+    status: PaymentStatus;
+    transactions?: PaymentTransactions;
+    /**
+     * Whether this response describes a payment that already existed, rather than one
+     * created by this request. `true` means the request_id had been used before and you
+     * are being handed the ORIGINAL payment — no second payment was created and nothing
+     * additional was charged.
+     *
+     * **Re-attempting a payment.** Re-submit the same request and you get the same payment
+     * back. You may re-send the original bytes unchanged: the deadlines will have expired by
+     * then — `quote_deadline` bounds the auction and is short, while this endpoint may hold a
+     * submission for up to 30 seconds — and an expired deadline on a re-submission is not an
+     * error, because the request is resolved onto the payment that already exists rather than
+     * used to create one.
+     *
+     * Re-signing with fresh deadlines is equally fine and returns the same payment. What you
+     * must NOT change is the request_id, and what you must not change under it is the
+     * payment's economics — source, destination, fulfillment_amount, max_source_amount — which
+     * are rejected with 409 IDEMPOTENCY_TERMS_MISMATCH. Deadlines and the signature are
+     * exempt precisely so that a re-attempt is possible.
+     *
+     * A genuinely new payment needs a NEW request_id. In particular a `failed` payment is
+     * terminal: re-submitting its request_id keeps returning that dead payment, so recovering
+     * means starting a new one under a new key.
+     *
+     * Present on every response, `false` for a newly created payment. A response without
+     * the field is from a gateway predating it, not a newly created payment.
+     *
+     * This is the field to read when reconciling a suspected double charge: two
+     * submissions where the second reports `true` are one payment, whereas two both
+     * reporting `false` are two. It says nothing about how far the payment has got —
+     * read `status` for that.
+     *
+     */
+    idempotent_replay: boolean;
+    /**
+     * The winning quote's ID. Present when `status` is `completed` — a payment cannot settle
+     * without an award — and absent on a `pending` response, where no quote has been selected
+     * yet. Same value and meaning as on GET /v1/payments/{paymentId}/status.
+     *
+     */
+    quote_id?: string;
+    /**
+     * The settler-signed FulfillmentQuote for the winning quote, returned verbatim as an
+     * opaque signed document — the PREIMAGE of the `quote_hash` committed on-chain. Same
+     * value, semantics and canonicalization caveats as on
+     * GET /v1/payments/{paymentId}/status; see that field for how to verify it.
+     *
+     * Present when `status` is `completed`. It may be absent even then, if the stored quote
+     * is unreadable: the award is reported through `quote_id` regardless, so a present
+     * `quote_id` with no `fulfillment_quote` means "verification preimage unavailable" and
+     * never "no quote was awarded". A consumer that requires the preimage should fall back to
+     * the status endpoint rather than treat the payment as unverified.
+     *
+     */
+    fulfillment_quote?: {
+        [key: string]: unknown;
+    };
+    fulfillment_confirmation?: FulfillmentConfirmation;
+    /**
+     * The settler-signed FulfillmentAuthorization for this payment, returned verbatim as an
+     * opaque signed document (structurally the canonical FulfillmentAuthorization/v1 declaration at
+     * https://schemas.atum.xyz/declarations/FulfillmentAuthorization/v1; see also
+     * `#/components/schemas/FulfillmentAuthorization`). The inner declaration requires
+     * `version`, `scheme`, `authorization` (the signed EIP-3009 transfer, in `authorization.message_prehash`), `fulfillment_quote_json`,
+     * and `evidence` (the on-chain authorizeFulfillment transaction). On the wire the settler
+     * typically wraps that declaration in JSON-LD with `@context`, `type`, and `proof` — those
+     * envelope fields ride alongside the declaration and MUST be preserved byte-for-byte.
+     *
+     * Present when the settler authorized an originator fulfill. Mutually exclusive with
+     * `fulfillment_confirmation` until the originator fulfills: when this field is populated,
+     * `fulfillment_confirmation` is absent.
+     *
+     * The service returns these bytes verbatim and does not re-serialize through a typed
+     * representation (which would normalize timestamps and reorder JSON-LD envelope fields).
+     *
+     */
+    fulfillment_authorization?: {
+        [key: string]: unknown;
+    };
+    error?: PaymentFailure;
+    /**
+     * Why the settler did not deliver, as it reported when it gave up. Present only when
+     * `status` is `refunding`, `refund_available` or `refunded`, and absent when the refund
+     * started without a reason from the settler. `status` decides what to do next: its
+     * `retry_classification` and `request_id_reusable` describe the settler's error, not
+     * this payment, and never mean paying again while it is `refunding` or `refund_available`.
+     *
+     */
+    refund_reason?: PaymentFailure;
+    /**
+     * How many settler agents this payment's auction was broadcast to. Accompanies
+     * `decline_summary` and is present under the same condition. Same meaning and same
+     * absence rule as on GET /v1/payments/{paymentId}/status: absent means unknown, never
+     * zero.
+     *
+     */
+    requested_count?: number;
+    /**
+     * Why the payment drew few or no quotes, carried on the submission response so that a
+     * `failed` payment explains itself here rather than requiring a follow-up read. A
+     * payment that ran out its quote deadline reports `NO_QUOTES_RECEIVED` on `error`;
+     * this is what the settlers actually said.
+     *
+     * Present when `status` is `failed`, alongside `error`. A submission rejected before
+     * its auction opened is answered as an error response rather than this type and carries
+     * no breakdown, and GET /v1/payments/{paymentId}/status reports the breakdown in every
+     * state.
+     *
+     * Same counting rules as GET /v1/payments/{paymentId}/status: every declining agent is
+     * counted exactly once under its most recent reason, empty means no agent declined,
+     * absent means the breakdown could not be read. The free-form decline detail is never
+     * relayed.
+     *
+     */
+    decline_summary?: Array<DeclineSummaryEntry>;
+};
+type GetPaymentStatusResponse = {
+    /**
+     * The payment ID you're checking status for.
+     *
+     */
+    payment_id?: string;
+    status?: PaymentStatus;
+    transactions?: PaymentTransactions;
+    /**
+     * When the status was last updated
+     */
+    updated_at?: string;
+    /**
+     * The winning quote's ID. Present once a quote has been awarded for this payment;
+     * absent while the payment is still collecting or awarding. Cross-references the
+     * `quote_id` returned by GET /v1/payments/quote-requests/{quoteRequestId}.
+     *
+     */
+    quote_id?: string;
+    /**
+     * The settler-signed FulfillmentQuote for the winning quote, returned verbatim as an
+     * opaque signed document (structurally the canonical FulfillmentQuote/v1 declaration at
+     * https://schemas.atum.xyz/declarations/FulfillmentQuote/v1). Present once a quote has
+     * been awarded — including after the payment completes and `fulfillment_confirmation` is
+     * populated, since that is precisely when a consumer verifies.
+     *
+     * This is the PREIMAGE of the `quote_hash` committed on-chain in the escrow deposit and
+     * reserve witnesses. On-chain we commit only the hash, so a quote-selector consumer
+     * recomputes quote_hash over these bytes and compares it against the on-chain commitment
+     * to confirm the payment settled against the quote it selected ("trust but verify"), and
+     * verifies the settler signature over the same bytes.
+     *
+     * quote_hash is canonicalization-based (URDNA2015), so it is stable across JSON
+     * key-order/whitespace normalization and across JSON string-escaping differences. The
+     * returned bytes are hash-equivalent to, but not necessarily byte-identical with, what
+     * the settler emitted (quotes are stored as JSONB, which normalizes on write). The
+     * gateway still never re-serializes the quote through a typed struct (that renormalizes
+     * timestamp values and WOULD change quote_hash), so the Go binding exposes it as a raw
+     * JSON passthrough.
+     *
+     */
+    fulfillment_quote?: {
+        [key: string]: unknown;
+    };
+    fulfillment_confirmation?: FulfillmentConfirmation;
+    /**
+     * The settler-signed FulfillmentAuthorization for this payment, returned verbatim as an
+     * opaque signed document (structurally the canonical FulfillmentAuthorization/v1 declaration at
+     * https://schemas.atum.xyz/declarations/FulfillmentAuthorization/v1; see also
+     * `#/components/schemas/FulfillmentAuthorization`). The inner declaration requires
+     * `version`, `scheme`, `authorization` (the signed EIP-3009 transfer, in `authorization.message_prehash`), `fulfillment_quote_json`,
+     * and `evidence` (the on-chain authorizeFulfillment transaction). On the wire the settler
+     * typically wraps that declaration in JSON-LD with `@context`, `type`, and `proof` — those
+     * envelope fields ride alongside the declaration and MUST be preserved byte-for-byte.
+     *
+     * Present when the settler authorized an originator fulfill. Mutually exclusive with
+     * `fulfillment_confirmation` until the originator fulfills: when this field is populated,
+     * `fulfillment_confirmation` is absent.
+     *
+     * The service returns these bytes verbatim and does not re-serialize through a typed
+     * representation (which would normalize timestamps and reorder JSON-LD envelope fields).
+     *
+     */
+    fulfillment_authorization?: {
+        [key: string]: unknown;
+    };
+    error?: PaymentFailure;
+    /**
+     * Why the settler did not deliver, as it reported when it gave up. Present only when
+     * `status` is `refunding`, `refund_available` or `refunded`, and absent when the refund
+     * started without a reason from the settler. `status` decides what to do next: its
+     * `retry_classification` and `request_id_reusable` describe the settler's error, not
+     * this payment, and never mean paying again while it is `refunding` or `refund_available`.
+     *
+     */
+    refund_reason?: PaymentFailure;
+    /**
+     * Present only when `status` is `refund_available`.
+     */
+    refund_signature?: RefundSignature;
+    /**
+     * How many settler agents this payment's auction was broadcast to. Absent means
+     * unknown, never zero.
+     *
+     */
+    requested_count?: number;
+    /**
+     * Why the payment drew few or no quotes. Read from the same settler reports as the
+     * quote-request endpoints, keyed by this payment, so a payment that failed on an expired
+     * quote deadline can say WHY nobody funded it instead of only that nobody did.
+     *
+     * Every declining agent is counted exactly once under its most recent reason. Empty means
+     * no agent declined against this payment, absent means the breakdown could not be read. A
+     * payment awarded out of a quote-request batch was bid on at quote time, so its declines
+     * are keyed to that batch and are read from the batch's status endpoint rather than here.
+     * As on the quote-request endpoints, the free-form decline detail is never relayed.
+     *
+     */
+    decline_summary?: Array<DeclineSummaryEntry>;
+};
+/**
+ * Why a payment failed, or why its settler gave up. As `error` it is present only when
+ * `status` is `failed`, as `refund_reason` only on the refund statuses, and it is identical
+ * however you ask about the payment.
+ *
+ * `code` is the stable, machine-readable identity of the failure — branch on it
+ * rather than on `message`, which is written for a person and may be reworded.
+ * `docs_url` points at the page describing that code.
+ *
+ */
+type PaymentFailure = {
+    /**
+     * Public error category in SCREAMING_SNAKE_CASE. Common codes:
+     * - `SETTLEMENT_FAILED`: the settlement could not be completed
+     * - `NO_QUOTES_RECEIVED`: no quotes arrived within the auction window
+     * - `INTERNAL_ERROR`: an unexpected error occurred
+     *
+     */
+    code: string;
+    /**
+     * Human-readable description of the failure, for a person reading it. Do not
+     * branch on this text.
+     *
+     */
+    message: string;
+    /**
+     * Which part of the system reported the failure.
+     *
+     */
+    domain?: 'PAYMENT_GATEWAY' | 'SETTLER_GATEWAY' | 'SETTLER_AGENT' | 'WALLET_ORCHESTRATION' | 'VERIFICATION_SERVICE' | 'BLOCKCHAIN' | 'EXTERNAL_SERVICE';
+    /**
+     * Link to the documentation page for this public code.
+     */
+    docs_url?: string;
+    /**
+     * What the caller should do next. Absent means the condition has not been classified, which is not the same as safe to retry.
+     * Re-sending the same `request_id` is an idempotent replay and always safe. This value is about submitting a new one, which starts a new payment. See https://docs.atum.xyz/errors for the value set.
+     */
+    retry_classification?: string;
+    /**
+     * Whether the caller may re-send the `request_id` this payment was created under. On this shape it is almost always false, because a payment exists by definition, but it is carried rather than assumed so a caller reads the same field here as on a synchronous error. Absent means undetermined, which a caller should read as false.
+     */
+    request_id_reusable?: boolean;
+    blockchain_context?: PaymentBlockchainContext;
+};
+/**
+ * Which part of the system reported the failure.
+ *
+ */
+type domain = 'PAYMENT_GATEWAY' | 'SETTLER_GATEWAY' | 'SETTLER_AGENT' | 'WALLET_ORCHESTRATION' | 'VERIFICATION_SERVICE' | 'BLOCKCHAIN' | 'EXTERNAL_SERVICE';
+/**
+ * Where on chain a failed payment failed. Present only when the failure happened
+ * on chain — an escrow revert, or a fulfillment that could not be delivered — so a
+ * payment that failed before any transaction was sent carries no context here.
+ */
+type PaymentBlockchainContext = {
+    /**
+     * CAIP-2 chain identifier
+     */
+    chain_id?: string;
+    /**
+     * Failed transaction hash
+     */
+    transaction_hash?: string;
+    /**
+     * Block number where error occurred
+     */
+    block_number?: number;
+    /**
+     * Contract that caused the error
+     */
+    contract_address?: string;
+    /**
+     * Smart contract revert reason
+     */
+    revert_reason?: string;
+    /**
+     * Gas consumed before failure
+     */
+    gas_used?: string;
+    /**
+     * Estimated gas needed for success
+     */
+    estimated_gas_needed?: string;
+};
+/**
+ * Human-readable payment request parameters for generating an unsigned PaymentRequest.
+ * Asset identifiers use a CAIP-19-like format with "/" separator and support friendly names.
+ *
+ */
+type PreparePaymentRequest = {
+    /**
+     * Unique identifier for tracking this payment request.
+     * Used for idempotency and matching responses to requests.
+     *
+     */
+    request_id: string;
+    /**
+     * Source asset in human-readable CAIP-19-like format: {chain}/{asset}
+     * Supports both friendly names and full CAIP-19 identifiers:
+     * - "ethereum/usdc" (friendly names)
+     * - "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" (full CAIP-19)
+     *
+     */
+    source_asset: string;
+    /**
+     * Wallet address that will send the payment
+     */
+    source_account: string;
+    /**
+     * Destination asset in human-readable CAIP-19-like format: {chain}/{asset}
+     * Supports both friendly names and full CAIP-19 identifiers:
+     * - "arbitrum/usdc"
+     * - "eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+     *
+     */
+    destination_asset: string;
+    /**
+     * Wallet address that will receive the payment
+     */
+    destination_account: string;
+    /**
+     * Simple amount specification in decimal format (e.g., "1.50" for $1.50 USDC).
+     * Use this OR specify both max_source_amount and fulfillment_amount.
+     * Cannot be used together with max_source_amount/fulfillment_amount.
+     *
+     */
+    amount?: string;
+    /**
+     * Maximum amount willing to spend from source (in decimal format).
+     * Must be specified together with fulfillment_amount.
+     * Cannot be used together with amount field.
+     *
+     */
+    max_source_amount?: string;
+    /**
+     * Exact amount to be fulfilled at destination (in decimal format).
+     * Must be specified together with max_source_amount.
+     * Cannot be used together with amount field.
+     *
+     */
+    fulfillment_amount?: string;
+    /**
+     * Seconds until quote deadline (from now).
+     * How long to wait for settlement provider quotes.
+     *
+     */
+    quote_deadline_seconds?: number;
+    /**
+     * Seconds until fulfillment deadline (from now).
+     * Final deadline for completing the payment.
+     *
+     */
+    fulfillment_deadline_seconds?: number;
+};
+/**
+ * Complete unsigned PaymentRequest ready for signing.
+ * Contains all resolved technical details and typed data ready for signing.
+ *
+ */
+type PreparePaymentResponse = {
+    /**
+     * Complete PaymentRequest with signature field set to null.
+     * Client should fill in the signature field(s) in
+     * sender_auth.signed_messages, either by signing the message_hash
+     * field in signed_messages or by using typed data signing on the
+     * message_prehash field in signed messages, and then submit the full
+     * object to POST /v1/payments.
+     *
+     */
+    payment_request: PaymentRequest;
+};
+type ResolvePaymentResponse = {
+    /**
+     * The payment ID that corresponds to the given request ID
+     */
+    payment_id: string;
+};
+/**
+ * Step-by-step view of a payment's settlement lifecycle. Includes a route
+ * summary, a list of steps with timings, and if the payment failed, a
+ * structured error describing where and why.
+ *
+ */
+type PaymentTimelineResponse = {
+    payment_id: string;
+    status: PaymentStatus;
+    transactions?: PaymentTransactions;
+    created_at: string;
+    updated_at: string;
+    /**
+     * Total time from first step to last completed step (only set for terminal states)
+     */
+    total_duration_ms?: number;
+    summary?: PaymentSummary;
+    error?: PaymentFailure;
+    /**
+     * Why the settler did not deliver, as it reported when it gave up. Present only when
+     * `status` is `refunding`, `refund_available` or `refunded`, and absent when the refund
+     * started without a reason from the settler. `status` decides what to do next: its
+     * `retry_classification` and `request_id_reusable` describe the settler's error, not
+     * this payment, and never mean paying again while it is `refunding` or `refund_available`.
+     *
+     */
+    refund_reason?: PaymentFailure;
+    steps: Array<TimelineStep>;
+};
+/**
+ * Top-level context about the payment (parties, assets, amounts)
+ */
+type PaymentSummary = {
+    /**
+     * CAIP-19 identifier of the source asset
+     */
+    source_asset?: string;
+    source_account?: string;
+    dest_asset?: string;
+    dest_account?: string;
+    /**
+     * Raw fulfillment amount in smallest token units
+     */
+    fulfillment_amount?: string;
+    /**
+     * Human-readable formatted amount with symbol, e.g. "1.00 USDC".
+     * Only set when the source asset's decimals are known via the token registry.
+     *
+     */
+    display_amount?: string;
+    /**
+     * Raw max source amount in smallest token units
+     */
+    max_source_amount?: string;
+    request_id?: string;
+};
+type TimelineStep = {
+    /**
+     * Internal name of the step (matches settlement event type)
+     */
+    name: string;
+    /**
+     * Human-readable label
+     */
+    label: string;
+    /**
+     * Current status of this step:
+     * - `completed`: Step finished successfully
+     * - `in_progress`: Step currently executing
+     * - `pending`: Step hasn't started yet
+     * - `failed`: Step errored out
+     * - `skipped`: Step will never execute because an earlier step failed
+     *
+     */
+    status: 'completed' | 'in_progress' | 'pending' | 'failed' | 'skipped';
+    /**
+     * When the step completed (if it has)
+     */
+    timestamp?: string;
+    /**
+     * Time this step took, measured from the previous step
+     */
+    duration_ms?: number;
+    /**
+     * CAIP-2 chain this step happened on (if on-chain)
+     */
+    chain_id?: string;
+    /**
+     * Transaction hash associated with this step (if on-chain)
+     */
+    transaction_hash?: string;
+    /**
+     * Additional step-specific data (e.g. block_number, settler, reason)
+     */
+    details?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Current status of this step:
+ * - `completed`: Step finished successfully
+ * - `in_progress`: Step currently executing
+ * - `pending`: Step hasn't started yet
+ * - `failed`: Step errored out
+ * - `skipped`: Step will never execute because an earlier step failed
+ *
+ */
+type status2 = 'completed' | 'in_progress' | 'pending' | 'failed' | 'skipped';
+/**
+ * Safe, outward-facing error. Derived from an internal error through the shared error catalog. The public code identifies the category and the message is a curated, safe description.
+ *
+ * A panic is caught by shared middleware that responds `{"error": "Internal server error occurred"}` instead, so a 500 is not guaranteed to carry this shape.
+ */
+type ErrorResponse = {
+    /**
+     * Public, machine-readable error category in SCREAMING_SNAKE_CASE.
+     */
+    code: string;
+    /**
+     * Curated, safe, human-readable message.
+     */
+    message: string;
+    /**
+     * Correlation id to quote to support to locate the internal error record.
+     */
+    request_id?: string;
+    /**
+     * The payment this error was raised against. Absent when the error is not about a specific payment.
+     */
+    payment_id?: string;
+    /**
+     * Link to the documentation page for this public code.
+     */
+    docs_url?: string;
+    /**
+     * Originating service domain.
+     */
+    domain?: string;
+    /**
+     * What the caller should do next. Absent means the condition has not been classified, which is not the same as safe to retry.
+     * Re-sending the same `request_id` is an idempotent replay and always safe. This value is about submitting a new one, which starts a new operation. See https://docs.atum.xyz/errors for the value set.
+     */
+    retry_classification?: string;
+    /**
+     * Whether the caller may re-send this same request_id. True means no payment was created for it, so the id is still free. False means a payment exists for it, so the id is spent and re-sending only replays this outcome. Absent means undetermined, which a caller should read as false. Separate from retry_classification, which answers what the caller must change rather than whether the id survived.
+     */
+    request_id_reusable?: boolean;
+};
+/**
+ * Request body for opening a quote-request batch. Structurally the existing PaymentRequest
+ * with `sender_auth` omitted (the spend authorization is deferred to the award call); see
+ * schemas/declarations/PaymentRequest/v1/schema.json.
+ *
+ */
+type CreateQuoteRequest = {
+    /**
+     * Semver-shaped declaration version (MAJOR.MINOR), locked to major 1 for v1. Producers emit
+     * the canonical value exported by the bindings' Version constant.
+     *
+     */
+    version: string;
+    /**
+     * Client-supplied idempotency key for this quote-request. The same request_id from the
+     * same originator returns the same quote_request_id. Independent of the award-call request_id.
+     *
+     */
+    request_id: string;
+    source: OwnedAsset;
+    /**
+     * Array of destination assets for the settlement agent to choose from (at least one required, at most 16).
+     * The ceiling bounds the fan-out one request can buy: every consumer iterates this list.
+     *
+     */
+    destination: Array<OwnedAsset>;
+    /**
+     * The exact amount to be received at the destination (smallest unit, e.g. wei or cents).
+     */
+    fulfillment_amount: string;
+    /**
+     * Optional cap on what the originator is willing to spend from source (smallest unit).
+     * Quotes with source_amount above this are filtered. No cap applied if omitted.
+     *
+     */
+    max_source_amount?: string;
+    /**
+     * Required. End of the collection window. After this point no new quotes are accepted.
+     * The gateway injects no default and never mutates the originator-supplied body, so the
+     * value is carried through verbatim to the award call. It must be supplied and must be in
+     * the future. Must be strictly earlier than fulfillment_deadline.
+     *
+     * Keep this window short. A settler holds its quoted price for a limited period of its
+     * own choosing, and the gateway selects only once the window has closed, so a deadline
+     * set beyond that hold leaves no quote still awardable and the request is declined with
+     * QUOTE_WINDOW_TOO_LONG. That hold is set by each settler and is not part of this
+     * contract, so treat 60 seconds as a practical upper bound and prefer a shorter window
+     * where your integration allows.
+     *
+     */
+    quote_deadline: string;
+    /**
+     * Required. Final deadline for completing the payment. Past it the payment fails and
+     * eligible for refund. The gateway injects no default and never mutates the
+     * originator-supplied body, so the value is carried through verbatim to the award call. It
+     * must be supplied and must be in the future. Must be strictly later than quote_deadline.
+     *
+     */
+    fulfillment_deadline: string;
+    /**
+     * Policy requirements for settler authentication. Keys are policy names, values indicate if required.
+     */
+    settler_auth_required?: {
+        [key: string]: (boolean);
+    };
+    originator_auth?: VerifiableCredentialAuth;
+    /**
+     * Wallet address or public key of a trusted service that auto-selects the best rate.
+     * Leave empty to use the default selector.
+     *
+     */
+    quote_selector?: string;
+    /**
+     * The verification service that confirms the payment was delivered before the escrow
+     * releases the source funds, and the account it signs with. Required on every chain:
+     * the gateway's `/v1/defaults` response supplies it for each chain.
+     *
+     */
+    fulfillment_verifier: {
+        /**
+         * The wallet address or public key of the verification service
+         */
+        account: string;
+        /**
+         * Origin of the fulfillment verifier service, with no path — the caller
+         * appends the verifier's own API paths. The gateway's `/v1/defaults` response
+         * supplies the default fulfillment verifier for each chain.
+         *
+         */
+        endpoint: string;
+    };
+    /**
+     * Escrow contract on the source chain that holds the source funds until proof of
+     * fulfillment has been verified. Required on every chain: the gateway's `/v1/defaults`
+     * response supplies it for each chain (`escrow_contract`).
+     *
+     */
+    escrow_contract_address: string;
+    /**
+     * Optional fulfillment-proxy contract address on the destination chain. Leave empty to use the default.
+     */
+    fulfillment_proxy?: string;
+    /**
+     * Optional settler filtering. If whitelist is present, only whitelisted settlers may win.
+     * If blacklist is present, blacklisted settlers are excluded. Both can be specified;
+     * blacklist takes precedence (a settler in both is rejected).
+     *
+     */
+    settler_requirements?: {
+        /**
+         * Settler DIDs permitted to fulfill this request (W3C DID format). If present, only these may win.
+         */
+        whitelist?: Array<(string)>;
+        /**
+         * Settler DIDs excluded from fulfilling this request (W3C DID format).
+         */
+        blacklist?: Array<(string)>;
+    };
+    /**
+     * Optional JSON-LD context URLs — present when the originator wraps the request in a W3C
+     * Data Integrity envelope so a downstream verifier can recover the signer identity.
+     *
+     */
+    '@context'?: Array<(string)>;
+    proof?: DataIntegrityProof;
+    /**
+     * Optional document-level W3C Verifiable Credentials (e.g. KnownToAtum about the request producer).
+     */
+    verifiableCredential?: Array<VerifiableCredential>;
+};
+/**
+ * W3C Data Integrity proof conforming to the Data Integrity 1.0 specification. Which of jws or proofValue is required depends on the cryptosuite named in type, and that pairing is checked where the proof is verified rather than by this schema, so a document can satisfy the schema and still be refused at verification.
+ */
+type DataIntegrityProof = {
+    /**
+     * Proof type identifier. ECDSA-secp256k1 (recoverable, EVM-compatible) for did:pkh:eip155:* signers; Ed25519 for did:pkh:solana:* signers.
+     */
+    type: string;
+    /**
+     * ISO 8601 timestamp when the proof was created. Canonicalize the value exactly as it appears in the raw JSON: parsing it into a date-time and re-serializing can change the spelling (Z versus +00:00), and a different spelling canonicalizes to different bytes, so the signature no longer verifies.
+     */
+    created: string;
+    /**
+     * DID URL identifying the verification method, e.g., 'did:pkh:eip155:1:0x...#blockchainAccountId' for ECDSA or 'did:pkh:solana:<chain>:<addr>#SolanaMethod2021' for Ed25519.
+     */
+    verificationMethod: string;
+    /**
+     * Purpose of the proof (e.g., assertionMethod, authentication).
+     */
+    proofPurpose: string;
+    /**
+     * Detached JWS signature in <base64url(header)>..<base64url(sig)> form, header {alg:ES256K-R, b64:false, crit:[b64]}. Required at runtime for EcdsaSecp256k1RecoverySignature2020.
+     */
+    jws?: string;
+    /**
+     * Multibase-encoded raw signature bytes. Required at runtime for Ed25519Signature2020; mutually exclusive with jws in practice.
+     */
+    proofValue?: string;
+};
+/**
+ * One collected quote — the content-hash identifier plus the verbatim settler-signed FulfillmentQuote.
+ */
+type Quote = {
+    /**
+     * Canonical content-hash of the signed quote bytes; identifies the quote server-side at
+     * award time. Provided as a convenience — the gateway re-derives it from
+     * bid_award.fulfillment_quote_json.
+     *
+     */
+    quote_id: string;
+    /**
+     * The settler-signed FulfillmentQuote (structurally the canonical FulfillmentQuote/v1
+     * declaration at https://schemas.atum.xyz/declarations/FulfillmentQuote/v1), returned
+     * verbatim as an opaque signed document. A client recomputes quote_hash over the returned
+     * bytes and verifies the settler signature, then re-embeds them into
+     * bid_award.fulfillment_quote_json at award. quote_hash is canonicalization-based
+     * (URDNA2015), so it is stable across JSON key-order/whitespace normalization. The
+     * returned bytes are hash-equivalent to, but not necessarily byte-identical with, what the
+     * settler emitted (quotes are stored as JSONB, which normalizes on write). The gateway
+     * still never re-serializes the quote through a typed struct (that renormalizes timestamp
+     * values and WOULD change quote_hash), so the Go binding exposes it as a raw JSON passthrough.
+     *
+     */
+    fulfillment_quote: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * A collected quote in the status response, annotated with its award linkage.
+ */
+type AwardedQuote = {
+    quote_id: string;
+    /**
+     * The settler-signed FulfillmentQuote (structurally the canonical FulfillmentQuote/v1
+     * declaration at https://schemas.atum.xyz/declarations/FulfillmentQuote/v1), returned
+     * verbatim as an opaque signed document. A client recomputes quote_hash over the returned
+     * bytes and verifies the settler signature, then re-embeds them into
+     * bid_award.fulfillment_quote_json at award. quote_hash is canonicalization-based
+     * (URDNA2015), so it is stable across JSON key-order/whitespace normalization. The
+     * returned bytes are hash-equivalent to, but not necessarily byte-identical with, what the
+     * settler emitted (quotes are stored as JSONB, which normalizes on write). The gateway
+     * still never re-serializes the quote through a typed struct (that renormalizes timestamp
+     * values and WOULD change quote_hash), so the Go binding exposes it as a raw JSON passthrough.
+     *
+     */
+    fulfillment_quote: {
+        [key: string]: unknown;
+    };
+    /**
+     * payment_id if this quote was awarded; null otherwise. Under MVP single-award, at most
+     * one quote per batch carries a non-null value.
+     *
+     */
+    awarded_payment_id?: string | null;
+};
+/**
+ * A (quote_id, payment_id) pair for an awarded quote in a batch.
+ */
+type AwardedPayment = {
+    quote_id: string;
+    payment_id: string;
+};
+/**
+ * Synchronous response to POST /v1/payments/quote-requests. Self-contained — the corridor
+ * fields are echoed at the response root so a drop-recovery client can build the award call
+ * without retaining the original request body.
+ *
+ * The corridor echoed here describes the batch you actually receive. On an idempotent
+ * replay that is the ORIGINAL batch's corridor and window, which may differ from what you
+ * just sent in the ways a retry is allowed to differ (the deadlines, and address casing).
+ *
+ */
+type QuoteRequestResponse = {
+    /**
+     * Gateway-generated resource ID for the batch, used in subsequent status reads and awards.
+     */
+    quote_request_id: string;
+    /**
+     * Collection-phase outcome of the create call:
+     * - `ready` — collection complete; `quotes` populated. If no settler bid, this is still
+     * `ready` with an empty `quotes` array (a successful "no quotes available" result —
+     * distinct from `expired`, which only applies to collected quotes that later lapse).
+     * - `collecting` — the sync wait cap fired before the quote deadline; poll the status endpoint for quotes.
+     * The `awarded` and `expired` lifecycle states are observed only via the status endpoint, not here.
+     *
+     */
+    status: 'collecting' | 'ready';
+    /**
+     * Whether this response describes a batch that already existed, rather than one opened
+     * by this request. `true` means the `request_id` had been used before and you are being
+     * handed the ORIGINAL batch — no second batch was opened and no second broadcast went
+     * out to settlement agents.
+     *
+     * **Re-attempting a quote-request.** Re-submit the same request and you get the same
+     * batch back. You may re-send the original bytes unchanged: `quote_deadline` bounds the
+     * collection window and is short, so it will usually have expired by the time you
+     * retry, and an expired deadline on a re-submission is not an error — the request is
+     * resolved onto the batch that already exists rather than used to open one.
+     * Re-signing with fresh deadlines is equally fine and returns the same batch.
+     *
+     * The window is NOT extended either way: it belongs to the batch, and `quote_deadline`
+     * in this response is the batch's own. Read `status` to see whether collection is
+     * still running.
+     *
+     * What you must not change under one `request_id` is the corridor's economics —
+     * accounts, assets, or amounts — which are rejected with 409
+     * IDEMPOTENCY_TERMS_MISMATCH rather than resolved onto the first batch. A genuinely
+     * different corridor needs a new `request_id`.
+     *
+     * Present on every response, `false` for a newly opened batch. A response without the
+     * field is from a gateway predating it, not a newly opened batch.
+     *
+     */
+    idempotent_replay: boolean;
+    source?: OwnedAsset;
+    destination?: Array<OwnedAsset>;
+    fulfillment_amount?: string;
+    max_source_amount?: string;
+    fulfillment_deadline?: string;
+    quote_deadline?: string;
+    /**
+     * Collected quotes. Present when status is `ready` — an empty array if no settler bid.
+     */
+    quotes?: Array<Quote>;
+    /**
+     * How many agents the request was broadcast to, so silence is distinguishable from a
+     * decline without a second call. Same meaning and same absence rule as on the status
+     * endpoint: absent means unknown, never zero.
+     *
+     */
+    requested_count?: number;
+    /**
+     * Why the request drew few or no quotes, carried here so that a `ready` response with an
+     * empty `quotes` array explains itself rather than requiring a follow-up read.
+     *
+     * Same counting rules as the status endpoint: every declining agent counted exactly once
+     * under its most recent reason, empty when nobody declined, absent when the detail could not
+     * be read. Provisional while `status` is `collecting`, because agents are still responding.
+     *
+     */
+    decline_summary?: Array<DeclineSummaryEntry>;
+};
+/**
+ * Collection-phase outcome of the create call:
+ * - `ready` — collection complete; `quotes` populated. If no settler bid, this is still
+ * `ready` with an empty `quotes` array (a successful "no quotes available" result —
+ * distinct from `expired`, which only applies to collected quotes that later lapse).
+ * - `collecting` — the sync wait cap fired before the quote deadline; poll the status endpoint for quotes.
+ * The `awarded` and `expired` lifecycle states are observed only via the status endpoint, not here.
+ *
+ */
+type status3 = 'collecting' | 'ready';
+/**
+ * Asynchronous (202) response to POST /v1/payments/quote-requests. Returns the batch handle
+ * plus the echoed corridor; quotes are retrieved via the status endpoint.
+ *
+ * The corridor echoed here describes the batch you actually receive. On an idempotent
+ * replay that is the ORIGINAL batch's corridor and window, which may differ from what you
+ * just sent in the ways a retry is allowed to differ (the deadlines, and address casing).
+ *
+ */
+type QuoteRequestAccepted = {
+    quote_request_id: string;
+    /**
+     * Always `collecting` — a constant on this response, not a report of the batch's state.
+     * On an idempotent replay the batch's window may already have closed; read
+     * GET /v1/payments/quote-requests/{quoteRequestId} for its actual state.
+     *
+     */
+    status: 'collecting';
+    /**
+     * Whether this response describes a batch that already existed, rather than one opened
+     * by this request. `true` means the `request_id` had been used before and you are being
+     * handed the ORIGINAL batch — no second batch was opened and no second broadcast went
+     * out to settlement agents.
+     *
+     * The idempotency contract is the same as on the synchronous (200) response: a
+     * re-submission may carry expired deadlines and is resolved onto the existing batch
+     * rather than rejected, the collection window is the batch's own and is not extended,
+     * and differing economics are rejected with 409 IDEMPOTENCY_TERMS_MISMATCH rather than
+     * collapsed onto the first batch.
+     *
+     * Present on every response, `false` for a newly opened batch. A response without the
+     * field is from a gateway predating it, not a newly opened batch.
+     *
+     */
+    idempotent_replay: boolean;
+    source?: OwnedAsset;
+    destination?: Array<OwnedAsset>;
+    fulfillment_amount?: string;
+    max_source_amount?: string;
+    fulfillment_deadline?: string;
+    quote_deadline?: string;
+};
+/**
+ * Always `collecting` — a constant on this response, not a report of the batch's state.
+ * On an idempotent replay the batch's window may already have closed; read
+ * GET /v1/payments/quote-requests/{quoteRequestId} for its actual state.
+ *
+ */
+type status4 = 'collecting';
+/**
+ * Response to GET /v1/payments/quote-requests/{quoteRequestId}. The `status` enum describes
+ * the quote-request batch lifecycle and is disjoint from the payment-status enum.
+ *
+ */
+type QuoteRequestStatusResponse = {
+    quote_request_id: string;
+    /**
+     * Derived batch lifecycle, computed at read time (not a stored state machine). Disjoint
+     * from the payment-status enum returned by the award and payment-status endpoints.
+     * - `collecting` — collection window still open; `quotes` lists those collected so far
+     * (a quote is awardable from arrival, by its own `award_deadline`; more may arrive until
+     * `collection_close`).
+     * - `ready` — collection complete; none awarded yet; either at least one quote is still
+     * within its `award_deadline`, or no settler bid (empty `quotes` array — the successful
+     * "no quotes available" result).
+     * - `awarded` — a quote produced a payment row; no further awards accepted (MVP).
+     * - `expired` — collection closed, nothing awarded, and every collected quote is now past
+     * its `award_deadline` ("quotes lapsed"). An empty batch is `ready`, not `expired` — the
+     * two are deliberately distinct ("no quotes available" vs "quotes lapsed").
+     *
+     */
+    status: 'collecting' | 'ready' | 'awarded' | 'expired';
+    /**
+     * Collected quotes with award linkage — those collected so far while `collecting`, the full set once the window closes.
+     */
+    quotes?: Array<AwardedQuote>;
+    /**
+     * Flat list of awarded (quote_id, payment_id) pairs. At most one entry under MVP single-award.
+     */
+    payments?: Array<AwardedPayment>;
+    /**
+     * How many agents the request was broadcast to. The only auction count that is not
+     * derivable from the rest of this response:
+     *
+     * - quoted = `quotes` length
+     * - declined = sum of `decline_summary[].count`
+     * - participated = quoted + declined
+     * - silent = `requested_count` - participated
+     *
+     * Silence and a decline are different signals, which is why the denominator is surfaced
+     * rather than left implicit.
+     *
+     * ABSENT when the number is unknown, which happens when the broadcast count was never
+     * recorded or when the auction detail could not be read. Absence means unknown, never zero,
+     * so `silent` is derivable only when this field is present.
+     *
+     */
+    requested_count?: number;
+    /**
+     * Why the request drew few or no quotes, so a caller can tell "nobody can fund this right
+     * now" from "my request was malformed".
+     *
+     * EXHAUSTIVE over agents: every agent that declined is counted exactly once, under its most
+     * recent reason, so the counts sum to the number of agents that declined. An agent that
+     * declined more than once with different reasons is counted once, not once per reason.
+     *
+     * Empty means nobody declined. ABSENT means the auction detail could not be read, so the
+     * breakdown is unknown. While `status` is `collecting` it is provisional, because agents are
+     * still responding.
+     *
+     * The free-form decline detail is never relayed, because that detail carries an agent's
+     * balances and would let a caller map inventory by polling cheap quote-requests across
+     * corridors.
+     *
+     */
+    decline_summary?: Array<DeclineSummaryEntry>;
+};
+/**
+ * Derived batch lifecycle, computed at read time (not a stored state machine). Disjoint
+ * from the payment-status enum returned by the award and payment-status endpoints.
+ * - `collecting` — collection window still open; `quotes` lists those collected so far
+ * (a quote is awardable from arrival, by its own `award_deadline`; more may arrive until
+ * `collection_close`).
+ * - `ready` — collection complete; none awarded yet; either at least one quote is still
+ * within its `award_deadline`, or no settler bid (empty `quotes` array — the successful
+ * "no quotes available" result).
+ * - `awarded` — a quote produced a payment row; no further awards accepted (MVP).
+ * - `expired` — collection closed, nothing awarded, and every collected quote is now past
+ * its `award_deadline` ("quotes lapsed"). An empty batch is `ready`, not `expired` — the
+ * two are deliberately distinct ("no quotes available" vs "quotes lapsed").
+ *
+ */
+type status5 = 'collecting' | 'ready' | 'awarded' | 'expired';
+type DeclineSummaryEntry = {
+    reason: DeclineReason;
+    /**
+     * Agents whose most recent decline reason was this one. Counts agents, never rows, and an
+     * agent appears under one reason only.
+     *
+     */
+    count: number;
+    /**
+     * What would have to change for a settler giving this reason to submit a price quote,
+     * drawn from the same closed set as the `retry_classification` on an error response so
+     * a caller reads one vocabulary.
+     *
+     * It describes the decline only. The authoritative instruction for the payment is the
+     * `retry_classification` on its own error response: a payment can fail for a reason no
+     * settler named, and it can succeed while some settlers declined.
+     *
+     * Optional, and a pattern-constrained string for the same reason `DeclineReason` is.
+     *
+     */
+    retry_classification?: string;
+    /**
+     * Link to the documentation for this reason. Absent rather than empty when no page is
+     * published, so a reader never follows a link to the site root.
+     *
+     */
+    docs_url?: string;
+};
+/**
+ * A settler's reason for not bidding, projected from its internal reason code through
+ * the shared decline catalog (`apis/decline/v1/catalog.json`), which is the single
+ * source of truth for the reason set. Several internal codes may map to one public
+ * reason.
+ *
+ * Deliberately a pattern-constrained string rather than a closed enum. The set grows
+ * whenever a settler gains a cause worth naming, and a consumer whose generated client
+ * closes the set rejects the whole response on a value it has not seen. Treat an
+ * unrecognised value as `OTHER`.
+ *
+ * `OTHER` covers a reason whose detail is settler-authored free text, and any reason
+ * this gateway does not recognise. Both are counted so the summary stays exhaustive,
+ * without relaying text we neither author nor validate.
+ *
+ */
+type DeclineReason = string;
+/**
+ * Request body for POST /v1/payments/awards. Carries the two originator-signed artifacts:
+ * `sender_auth` (Permit2 deposit authorization) and a fully-formed `bid_award` declaration.
+ * The awarded quote is derived server-side from bid_award.fulfillment_quote_json — no
+ * explicit quote_id on the wire.
+ *
+ */
+type AwardRequest = {
+    /**
+     * Client-supplied idempotency key for this award call. Independent of the quote-request's request_id.
+     */
+    request_id: string;
+    sender_auth: SenderAuth;
+    bid_award: BidAward;
+};
+/**
+ * Fully-formed, originator-signed bid award. Mirrors schemas/declarations/BidAward/v1/schema.json.
+ * `authorization` carries the Escrow reserve-witness signature naming the chosen settler;
+ * `fulfillment_quote_json` is the verbatim settler-signed quote string received in the quote
+ * response (carrying the settler's proof).
+ *
+ */
+type BidAward = {
+    /**
+     * Semver-shaped declaration version (MAJOR.MINOR), locked to major 1 for v1. Producers emit
+     * the canonical value exported by the bindings' Version constant.
+     *
+     */
+    version: string;
+    authorization: SignedMessage;
+    /**
+     * The settler-signed FulfillmentQuote received in the quote response, forwarded verbatim.
+     * Verification is canonicalization-based — the settler's W3C Data Integrity proof is checked
+     * over the canonicalized form, and `quote_id` is derived as the canonical content-hash — so a
+     * JSON decode/re-encode that only changes key order or whitespace does not invalidate it.
+     * Clients SHOULD still forward the received bytes as-is rather than rebuild the object; the
+     * SDK helpers do this and also expose settler-proof verification.
+     *
+     */
+    fulfillment_quote_json: string;
+    /**
+     * Optional JSON-LD context URLs when the award is wrapped in a W3C Data Integrity envelope.
+     */
+    '@context'?: Array<(string)>;
+    proof?: DataIntegrityProof;
+    /**
+     * Optional W3C Verifiable Credentials attesting the award producer.
+     */
+    verifiableCredential?: Array<VerifiableCredential>;
+};
+/**
+ * Synchronous response to POST /v1/payments/awards. The `status` field describes the payment
+ * lifecycle. Note there are two distinct status surfaces for a Quote-API payment, with
+ * different vocabularies: (1) this award response (`awarding`/`completed`/…), and
+ * (2) the separate GET /v1/payments/{paymentId}/status endpoint you poll afterward, which
+ * reports the same payment under its own values (an in-progress payment reads as `pending`
+ * there). Both are disjoint from the quote-request batch status on the quote-request endpoints.
+ *
+ */
+type AwardResponse = {
+    payment_id: string;
+    /**
+     * Payment lifecycle status on the award response:
+     * - `completed` — settlement finished within the sync wait (includes fulfillment_confirmation).
+     * - `awarding` — settlement still in progress when the sync cap fired (or on wait=false);
+     * poll GET /v1/payments/{paymentId}/status.
+     * - `failed` — settlement reached a terminal failure (e.g. the settler could not fulfill, or
+     * an on-chain step was rejected).
+     * - `cancelled` — the payment was terminated before settlement completed and will not proceed.
+     * `failed` and `cancelled` are terminal states surfaced here only when they occur within the
+     * sync wait; otherwise the response is `awarding` and the terminal state is read from the
+     * payment-status endpoint.
+     *
+     */
+    status: 'awarding' | 'completed' | 'failed' | 'cancelled';
+    fulfillment_confirmation?: FulfillmentConfirmation;
+    /**
+     * The settler-signed FulfillmentAuthorization for this payment, returned verbatim as an
+     * opaque signed document (structurally the canonical FulfillmentAuthorization/v1 declaration at
+     * https://schemas.atum.xyz/declarations/FulfillmentAuthorization/v1; see also
+     * `#/components/schemas/FulfillmentAuthorization`). The inner declaration requires
+     * `version`, `scheme`, `authorization` (the signed EIP-3009 transfer, in `authorization.message_prehash`), `fulfillment_quote_json`,
+     * and `evidence` (the on-chain authorizeFulfillment transaction). On the wire the settler
+     * typically wraps that declaration in JSON-LD with `@context`, `type`, and `proof` — those
+     * envelope fields ride alongside the declaration and MUST be preserved byte-for-byte.
+     *
+     * Present when the settler authorized an originator fulfill within the sync wait.
+     * Mutually exclusive with `fulfillment_confirmation` until the originator fulfills: when
+     * this field is populated, `fulfillment_confirmation` is absent.
+     *
+     * The service returns these bytes verbatim and does not re-serialize through a typed
+     * representation (which would normalize timestamps and reorder JSON-LD envelope fields).
+     *
+     */
+    fulfillment_authorization?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Payment lifecycle status on the award response:
+ * - `completed` — settlement finished within the sync wait (includes fulfillment_confirmation).
+ * - `awarding` — settlement still in progress when the sync cap fired (or on wait=false);
+ * poll GET /v1/payments/{paymentId}/status.
+ * - `failed` — settlement reached a terminal failure (e.g. the settler could not fulfill, or
+ * an on-chain step was rejected).
+ * - `cancelled` — the payment was terminated before settlement completed and will not proceed.
+ * `failed` and `cancelled` are terminal states surfaced here only when they occur within the
+ * sync wait; otherwise the response is `awarding` and the terminal state is read from the
+ * payment-status endpoint.
+ *
+ */
+type status6 = 'awarding' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Asynchronous (202) response to POST /v1/payments/awards — just the payment handle.
+ */
+type AwardAccepted = {
+    payment_id: string;
+    /**
+     * Always `awarding` — settlement is in progress server-side.
+     */
+    status: 'awarding';
+};
+/**
+ * Always `awarding` — settlement is in progress server-side.
+ */
+type status7 = 'awarding';
+/**
+ * The addresses for one chain. Optional fields appear only where they apply to that
+ * chain; an absent optional field is not an error.
+ *
+ */
+type ChainDefaults = {
+    /**
+     * CAIP-2 identifier of the chain these defaults describe, normalised to lower case.
+     */
+    chain_id: string;
+    /**
+     * The account named as the reserver in the deposit authorization. Sign against this exact value; a deposit reserved by anyone else is rejected.
+     */
+    quote_selector: string;
+    /**
+     * The escrow the deposit is made into, and the spender of the token approval. Empty when the chain is not fully configured.
+     */
+    escrow_contract: string;
+    /**
+     * The contract that pays the receiver. Read this from the DESTINATION chain's defaults, not the source chain's. Empty when the chain is not fully configured.
+     */
+    fulfillment_proxy: string;
+    /**
+     * The service that attests settlement, and the account it signs with.
+     */
+    fulfillment_verifier: {
+        /**
+         * The account named as the releaser in the deposit authorization. Sign against this exact value.
+         */
+        account: string;
+        /**
+         * Base URL of the fulfillment verifier serving this chain.
+         */
+        endpoint: string;
+    };
+    /**
+     * The Permit2 this chain's escrow verifies against, sent only when it is not the canonical deployment. When absent, use the canonical Permit2 address for the chain. EVM and Tron only.
+     */
+    permit2_contract?: string;
+    /**
+     * Tokens this chain's escrow accepts for deposit. Absent when the gateway has no listing for the chain, which does not mean no token is accepted.
+     */
+    tokens?: Array<{
+        symbol: string;
+        /**
+         * Token contract address, in the chain's native address format.
+         */
+        address: string;
+        /**
+         * Decimal places, for converting a human amount to base units.
+         */
+        decimals: number;
+    }>;
+    /**
+     * Solana only. The cluster the escrow's signing domain is bound to, needed to build the deposit hash. Absent for EVM and Tron.
+     */
+    svm_signature_cluster_id?: string;
+    /**
+     * Solana only. The escrow's signature domain version, which the deposit hash commits to. Absent for EVM and Tron.
+     */
+    svm_signature_domain_version?: number;
+    /**
+     * The depositRequestHash version to sign for a deposit from this chain: 1 is keccak256 of the request_id, 2 is the hash of the payment terms, computed over the request body exactly as it is then posted. Absent means 1. A deposit signed with version 1 is still accepted while the gateway publishes 2. The gateway publishes 2 for a chain only once every reader of the deposit there reads version 2, veri-fill's release check included, so this is the network-wide signal a client signs by and a merchant lists 2 in an x402 or MPP challenge by.
+     */
+    deposit_request_hash_version?: number;
+};
+/**
+ * Either one chain's defaults or every chain keyed by CAIP-2 chain id, depending on whether `chain_id` was supplied. A top-level `chain_id` identifies the first.
+ */
+type GetDefaultsResult = ChainDefaults | ChainDefaultsByChain;
+/**
+ * Defaults for every chain the gateway serves, keyed by CAIP-2 chain id. Each key repeats the `chain_id` of the value it maps to.
+ */
+type ChainDefaultsByChain = {
+    [key: string]: ChainDefaults;
+};
+type SubmitPaymentData = {
+    requestBody: PaymentRequest;
+};
+type SubmitPaymentResponse = PaymentResponse;
+type GetPaymentStatusData = {
+    /**
+     * The ID of the payment to query
+     */
+    paymentId: string;
+};
+type GetPaymentStatusResponse2 = GetPaymentStatusResponse;
+type ResolvePaymentData = {
+    /**
+     * The client-supplied request ID embedded in the payment request
+     */
+    requestId: string;
+};
+type ResolvePaymentResponse2 = ResolvePaymentResponse;
+type GetPaymentTimelineData = {
+    /**
+     * The ID of the payment to query
+     */
+    paymentId: string;
+};
+type GetPaymentTimelineResponse = PaymentTimelineResponse;
+type PreparePaymentData = {
+    requestBody: PreparePaymentRequest;
+};
+type PreparePaymentResponse2 = PreparePaymentResponse;
+type AuthorizePaymentData = {
+    requestBody: PaymentRequest;
+};
+type AuthorizePaymentResponse = AuthorizationResult;
+type CreateQuoteRequestData = {
+    requestBody: CreateQuoteRequest;
+    /**
+     * Return a handle immediately (`false`, default) or hold the connection for collected quotes (`true`).
+     */
+    wait?: boolean;
+};
+type CreateQuoteRequestResponse = QuoteRequestResponse | QuoteRequestAccepted;
+type GetQuoteRequestStatusData = {
+    /**
+     * The ID of the quote-request batch to query
+     */
+    quoteRequestId: string;
+};
+type GetQuoteRequestStatusResponse = QuoteRequestStatusResponse;
+type AwardQuoteData = {
+    requestBody: AwardRequest;
+    /**
+     * Return a handle immediately (`false`, default) or hold the connection for the payment result (`true`).
+     */
+    wait?: boolean;
+};
+type AwardQuoteResponse = AwardResponse | AwardAccepted;
+type GetDefaultsData = {
+    /**
+     * CAIP-2 chain identifier. Omit it, or send it empty, to receive every chain the gateway serves, keyed by chain id.
+     */
+    chainId?: string;
+};
+type GetDefaultsResponse = GetDefaultsResult;
+type HealthCheckResponse = {
+    status?: string;
+};
+type $OpenApiTs = {
+    '/v1/payments': {
+        post: {
+            req: SubmitPaymentData;
+            res: {
+                /**
+                 * Payment request submitted successfully
+                 */
+                200: PaymentResponse;
+                /**
+                 * Invalid request
+                 */
+                400: ErrorResponse;
+                /**
+                 * Signature or sender authorization could not be verified
+                 */
+                401: ErrorResponse;
+                /**
+                 * Payment declined during counterparty authorization
+                 */
+                403: ErrorResponse;
+                /**
+                 * The `request_id` has already been used for a payment with different economics
+                 * (`IDEMPOTENCY_TERMS_MISMATCH`). Re-submitting one `request_id` is how a retry is
+                 * made safe, so it must identify one payment; use a distinct `request_id` per
+                 * payment.
+                 *
+                 */
+                409: ErrorResponse;
+                /**
+                 * Payment request too large to process
+                 */
+                413: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: ErrorResponse;
+                /**
+                 * The request was not accepted: a dependency is temporarily unavailable, or this operation is paused (`SERVICE_PAUSED`). Nothing was submitted, so the request is safe to retry.
+                 */
+                503: ErrorResponse;
+            };
+        };
+    };
+    '/v1/payments/{paymentId}/status': {
+        get: {
+            req: GetPaymentStatusData;
+            res: {
+                /**
+                 * Payment status retrieved successfully
+                 */
+                200: GetPaymentStatusResponse;
+                /**
+                 * Payment not found
+                 */
+                404: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: ErrorResponse;
+            };
+        };
+    };
+    '/v1/payments/resolve': {
+        get: {
+            req: ResolvePaymentData;
+            res: {
+                /**
+                 * Payment found
+                 */
+                200: ResolvePaymentResponse;
+                /**
+                 * Missing request_id parameter
+                 */
+                400: ErrorResponse;
+                /**
+                 * No payment found for the given request ID
+                 */
+                404: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: ErrorResponse;
+            };
+        };
+    };
+    '/v1/payments/{paymentId}/timeline': {
+        get: {
+            req: GetPaymentTimelineData;
+            res: {
+                /**
+                 * Timeline retrieved successfully
+                 */
+                200: PaymentTimelineResponse;
+                /**
+                 * Payment not found
+                 */
+                404: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: ErrorResponse;
+            };
+        };
+    };
+    '/v1/payments/prepare': {
+        post: {
+            req: PreparePaymentData;
+            res: {
+                /**
+                 * Payment request prepared successfully
+                 */
+                200: PreparePaymentResponse;
+                /**
+                 * Invalid request parameters
+                 */
+                400: ErrorResponse;
+                /**
+                 * Endpoint not yet implemented
+                 */
+                501: ErrorResponse;
+            };
+        };
+    };
+    '/v1/payments/authorizations': {
+        post: {
+            req: AuthorizePaymentData;
+            res: {
+                /**
+                 * Authorization decision received (authorized or declined)
+                 */
+                200: AuthorizationResult;
+                /**
+                 * The request was rejected before authorization was attempted, so no
+                 * authorization outcome exists.
+                 *
+                 */
+                400: ErrorResponse;
+                /**
+                 * The counterparty's proof was rejected (`PROOF_INVALID` or `PROOF_STALE`).
+                 * This is an authorization outcome, so the body is an `AuthorizationResult`
+                 * with `status: error`.
+                 *
+                 */
+                401: AuthorizationResult;
+                /**
+                 * Counterparty not found (no registration for the resolved DID). An
+                 * authorization outcome, so the body is an `AuthorizationResult` with
+                 * `status: error` and `error_code: COUNTERPARTY_NOT_FOUND`.
+                 *
+                 */
+                404: AuthorizationResult;
+                /**
+                 * Either shape, depending on where the failure happened. A failure before
+                 * authorization was attempted returns `ErrorResponse`. A failure carrying an
+                 * authorization outcome returns `AuthorizationResult` with `status: error`.
+                 *
+                 */
+                500: ErrorResponse | AuthorizationResult;
+                /**
+                 * Counterparty webhook error (HTTP error or connection failure). An
+                 * authorization outcome, so the body is an `AuthorizationResult` with
+                 * `status: error` and `error_code: WEBHOOK_ERROR` or
+                 * `WEBHOOK_CONNECTION_ERROR`.
+                 *
+                 */
+                502: AuthorizationResult;
+                /**
+                 * Authorization timed out (the counterparty did not respond). An
+                 * authorization outcome, so the body is an `AuthorizationResult` with
+                 * `status: timeout`.
+                 *
+                 */
+                504: AuthorizationResult;
+            };
+        };
+    };
+    '/v1/payments/quote-requests': {
+        post: {
+            req: CreateQuoteRequestData;
+            res: {
+                /**
+                 * Quote-request resolved synchronously. `status` is `ready` when quotes were collected,
+                 * or `collecting` when the sync wait cap fired before the quote deadline.
+                 *
+                 */
+                200: QuoteRequestResponse;
+                /**
+                 * Quote-request accepted; collection continues asynchronously.
+                 */
+                202: QuoteRequestAccepted;
+                /**
+                 * Invalid request. `QUOTE_DEADLINE_NOT_FUTURE` is the one worth planning for: a NEW
+                 * quote-request whose `quote_deadline` has already passed is refused, because there is
+                 * no window left to collect quotes in. It does not apply to a re-submission — an
+                 * already-used `request_id` resolves onto the batch that exists and its expired
+                 * deadline is ignored, which is what makes a retry recoverable.
+                 *
+                 */
+                400: ErrorResponse;
+                /**
+                 * The `request_id` has already been used for a quote-request with different
+                 * economics (`IDEMPOTENCY_TERMS_MISMATCH`). Re-submitting one `request_id` is how a
+                 * retry is made safe, so it must identify one batch; use a distinct `request_id`
+                 * per quote-request.
+                 *
+                 */
+                409: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: ErrorResponse;
+                /**
+                 * The request was not accepted: a dependency is temporarily unavailable, or this operation is paused (`SERVICE_PAUSED`). Nothing was submitted, so the request is safe to retry.
+                 */
+                503: ErrorResponse;
+            };
+        };
+    };
+    '/v1/payments/quote-requests/{quoteRequestId}': {
+        get: {
+            req: GetQuoteRequestStatusData;
+            res: {
+                /**
+                 * Quote-request status retrieved successfully
+                 */
+                200: QuoteRequestStatusResponse;
+                /**
+                 * Quote-request not found, or not owned by the caller.
+                 */
+                404: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: ErrorResponse;
+            };
+        };
+    };
+    '/v1/payments/awards': {
+        post: {
+            req: AwardQuoteData;
+            res: {
+                /**
+                 * Award resolved synchronously. `status` is `completed` with a fulfillment_confirmation
+                 * when settlement finished within the sync wait, or a non-terminal payment status
+                 * (e.g. `awarding`) if the cap fired first.
+                 *
+                 */
+                200: AwardResponse;
+                /**
+                 * Award accepted; settlement continues asynchronously.
+                 */
+                202: AwardAccepted;
+                /**
+                 * Invalid request (bad signatures, expired quote, or ownership mismatch)
+                 */
+                400: ErrorResponse;
+                /**
+                 * The quote, or another quote in the same batch, has already been awarded
+                 * (single-award-per-batch, FR-09).
+                 *
+                 */
+                409: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: ErrorResponse;
+            };
+        };
+    };
+    '/v1/defaults': {
+        get: {
+            req: GetDefaultsData;
+            res: {
+                /**
+                 * Chain defaults. A single object when `chain_id` was supplied, otherwise an object keyed by CAIP-2 chain id.
+                 */
+                200: GetDefaultsResult;
+                /**
+                 * The `chain_id` is not a valid CAIP-2 chain identifier
+                 */
+                400: ErrorResponse;
+                /**
+                 * The requested chain is not served by this gateway, or - when `chain_id` was omitted - no chain could be resolved at all
+                 */
+                404: ErrorResponse;
+                /**
+                 * A dependency is temporarily unavailable
+                 */
+                503: ErrorResponse;
+            };
+        };
+    };
+    '/health': {
+        get: {
+            res: {
+                /**
+                 * Service is healthy
+                 */
+                200: {
+                    status?: string;
+                };
+            };
+        };
+    };
+};
+
+/** The signed terms a recovered permit carries. */
+interface AuthTerms {
+    /** Atomic units, decimal string. */
+    amount: string;
+    /** Unix seconds. */
+    deadlineSec: number;
+}
+/** The recovered and parsed permit, so a consumer can run its own policy checks. */
+interface ParsedPermit {
+    scheme: SenderAuthMessageScheme;
+    /** EVM/Tron: permit token; Solana: mint. */
+    token: string;
+    amount: string;
+    deadlineSec: number;
+    reserver: string;
+    releaser: string;
+    /** EVM/Tron only (Permit2 spender). */
+    spender?: string;
+    /** Solana only (the signed depositor). */
+    depositor?: string;
+    /** The escrow commitments as signed: the payee and the hash of the request id. */
+    destination?: string;
+    depositRequestHash?: string;
+}
+/** How the destination commitment check ended. Only `verified` admits a payment. */
+type CommitmentOutcome = 'verified' | 'scheme_mismatch' | 'commitment_absent' | 'prehash_mismatch' | 'signer_mismatch' | 'destination_mismatch' | 'request_hash_mismatch' | 'request_malformed' | 'verifier_misconfigured' | 'quote_request_mismatch';
+/** The destination commitment check's result: the outcome and both copies of the payee. */
+interface CommitmentResult {
+    outcome: CommitmentOutcome;
+    detail: string;
+    namespace: string;
+    scheme: string;
+    signedDestination: string;
+    expectedDestination: string;
+    signedDepositRequestHash: string;
+    expectedDepositRequestHash: string;
+    /** The request's depositRequestHash v2, when the check was given one (opted in, and the strict reader admitted the request). */
+    expectedDepositRequestHashV2?: string;
+    /** Why the strict reader refused the request, with `depositRequestHashV2Mode: 'audit'`. */
+    strictDetail?: string;
+    /** The depositRequestHash version the deposit matched, once opted in with `depositRequestHashV2Mode`. */
+    depositRequestHashVersion?: 'v1' | 'v2';
+}
+/** The Solana escrow signature domain, from your chain configuration. */
+interface SolanaDomain {
+    escrowProgramId: string;
+    clusterId: string;
+    domainVersion: number;
+}
+/** One verified `signed_messages[]` entry: the signed terms, the parsed permit and the commitment. */
+interface VerifiedSenderAuth extends AuthTerms {
+    permit: ParsedPermit;
+    commitment: CommitmentResult;
+}
+/** What {@link verifyPaymentRequest} returns. */
+interface VerifyResult {
+    /** One entry per `sender_auth.signed_messages[]`, in order. */
+    results: VerifiedSenderAuth[];
+    /** The `source.account` every signature was verified to recover to. */
+    recoveredAccount: string;
+    /**
+     * The commitment check's result, once {@link verifyPaymentRequestJSON} is opted in with
+     * `depositRequestHashV2Mode`: the depositRequestHash version the deposit matched and, in audit mode,
+     * `strictDetail`. Absent otherwise.
+     */
+    commitment?: CommitmentResult;
+}
+/**
+ * Expectations for {@link verifyPaymentRequest}.
+ *
+ * Pass the first three to check the signatures against your own terms. When omitted, the token,
+ * network and amount are taken from the request itself, which proves only that the signatures
+ * are consistent with fields the request's author controls.
+ */
+interface VerifyPaymentRequestExpectations {
+    /** Authoritative source-asset address (bare token, no CAIP prefix). */
+    sourceAsset?: string;
+    /** Authoritative CAIP-2 network. Parsed from the request when omitted. */
+    network?: string;
+    /** Authoritative max source amount to bind the permit amount against. */
+    maxSourceAmount?: string;
+    /** Opt-in atum-escrow-scheme fail-fast checks. */
+    escrowContract?: string;
+    reserver?: string;
+    releaser?: string;
+    /** Solana: additionally required by the deposit-hash domain, independent of role binding. */
+    svmSignatureClusterId?: string;
+    svmSignatureDomainVersion?: number;
+    /** EVM/Tron: the Permit2 contract the signature is bound to. */
+    permit2Contract?: string;
+    /** Freshness reference, Unix seconds. Defaults to now. */
+    nowSec?: number;
+    /**
+     * How {@link verifyPaymentRequestJSON} reads depositRequestHash v2. Absent, only v1 is accepted, as
+     * before v2. `audit` also accepts v2 and reports a request the strict reader refuses; `enforce`
+     * also accepts v2 and refuses such a request. {@link verifyPaymentRequest} accepts only v1 and
+     * refuses it as `verifier_misconfigured`.
+     */
+    depositRequestHashV2Mode?: 'audit' | 'enforce';
+}
+/**
+ * Recovers every `sender_auth.signed_messages[]` entry and binds the signed terms to
+ * `expected`, returning the parsed permits and the account they all recover to.
+ *
+ * Every deposit must commit to the request's own `destination` and `request_id`, so a request
+ * whose payee or request id was changed after signing is refused.
+ *
+ * Every entry must be a bindable permit; a malformed entry throws. A caller with mixed messages
+ * (for example an EVM setup approval alongside the permit) composes the per-entry adapter calls
+ * itself. Request-shape and policy checks remain the caller's.
+ *
+ * @throws If any entry fails to recover, bind, or match `expected`.
+ * @deprecated A parsed request keeps one value for a member name that appears twice, so this
+ * checks a copy of the request rather than the text received, and it accepts only
+ * depositRequestHash v1. Use {@link verifyPaymentRequestJSON} with the request as received.
+ */
+declare function verifyPaymentRequest(request: PaymentRequest, expected?: VerifyPaymentRequestExpectations): VerifyResult;
+/**
+ * Recovers every `sender_auth.signed_messages[]` entry of the request as received and binds the
+ * signed terms to `expected`, returning the parsed permits and the account they all recover to. It
+ * refuses a repeated member name, including names that differ only in letter case, where it reads,
+ * and every deposit must commit to the request's own `destination` and request: depositRequestHash
+ * v1 by default, v1 or v2 with `expected.depositRequestHashV2Mode`, which also returns the commitment
+ * check's result as `commitment`.
+ *
+ * @throws If the JSON is ambiguous or does not decode, or if any entry fails to recover, bind, or
+ * match `expected`; {@link commitmentResultOf} returns the outcome.
+ */
+declare function verifyPaymentRequestJSON(request: string | Uint8Array, expected?: VerifyPaymentRequestExpectations): VerifyResult;
+/**
+ * The payee check alone, over the request's JSON: the deposit must commit to the request's own
+ * `destination` and `request_id`. It does not recover the signer, so it also serves a
+ * contract-account payer (ERC-1271, such as a Safe), whose signature Permit2 checks on chain.
+ * `solana` is required for a Solana source. `options.depositRequestHashV2Mode` also accepts a deposit
+ * that commits depositRequestHash v2, as it does for {@link verifyPaymentRequestJSON}.
+ *
+ * @throws If the check refuses; {@link commitmentResultOf} returns the outcome.
+ */
+declare function verifyRequestCommitment(request: string | Uint8Array, solana?: SolanaDomain, options?: Pick<VerifyPaymentRequestExpectations, 'depositRequestHashV2Mode'>): CommitmentResult;
+/** The commitment result a verification error carries, if any; log its outcome and detail. */
+declare function commitmentResultOf(error: unknown): CommitmentResult | undefined;
+
+export { type $OpenApiTs as $, type AuthTerms as A, type SignedMessage as B, type CommitmentOutcome as C, type CreateQuoteRequest as D, type ErrorResponse as E, type AuthorizationResult as F, type GetDefaultsData as G, type HealthCheckResponse as H, type AwardAccepted as I, type AwardRequest as J, type AwardResponse as K, type AwardedPayment as L, type AwardedQuote as M, type BidAward as N, type ChainDefaultsByChain as O, type PaymentRequest as P, type ChainDefaults as Q, type ResolvePaymentData as R, type SolanaDomain as S, type DataIntegrityProof as T, type DeclineReason as U, type VerifiedSenderAuth as V, type DeclineSummaryEntry as W, type FulfillmentAuthorization as X, type FulfillmentConfirmation as Y, type GetDefaultsResult as Z, type GetPaymentStatusResponse as _, type CommitmentResult as a, type OwnedAsset as a0, type PaymentBlockchainContext as a1, type PaymentFailure as a2, type PaymentResponse as a3, type PaymentStatus as a4, type PaymentSummary as a5, type PaymentTimelineResponse as a6, type PaymentTransaction as a7, type PaymentTransactions as a8, type PreparePaymentRequest as a9, type PreparePaymentResponse as aa, type Quote as ab, type QuoteRequestAccepted as ac, type QuoteRequestResponse as ad, type QuoteRequestStatusResponse as ae, type RefundSignature as af, type ResolvePaymentResponse as ag, type SenderAuth as ah, type SenderAuthMessageScheme as ai, type TimelineStep as aj, type VerifiableCredential as ak, type VerifiableCredentialAuth as al, type deposit as am, type domain as an, type error_code as ao, type fulfill as ap, type reserve as aq, type scheme as ar, type status as as, type status2 as at, type status3 as au, type status4 as av, type status5 as aw, type status6 as ax, type status7 as ay, type ParsedPermit as b, type VerifyPaymentRequestExpectations as c, type VerifyResult as d, commitmentResultOf as e, verifyPaymentRequestJSON as f, verifyRequestCommitment as g, type AuthorizePaymentData as h, type AuthorizePaymentResponse as i, type GetDefaultsResponse as j, type SubmitPaymentData as k, type SubmitPaymentResponse as l, type GetPaymentStatusData as m, type GetPaymentStatusResponse2 as n, type ResolvePaymentResponse2 as o, type GetPaymentTimelineData as p, type GetPaymentTimelineResponse as q, type PreparePaymentData as r, type PreparePaymentResponse2 as s, type CreateQuoteRequestData as t, type CreateQuoteRequestResponse as u, verifyPaymentRequest as v, type GetQuoteRequestStatusData as w, type GetQuoteRequestStatusResponse as x, type AwardQuoteData as y, type AwardQuoteResponse as z };