@atumlabs/payment-gateway-client 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,3645 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+
+type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, unknown>;
+    readonly cookies?: Record<string, unknown>;
+    readonly headers?: Record<string, unknown>;
+    readonly query?: Record<string, unknown>;
+    readonly formData?: Record<string, unknown>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    private _isResolved;
+    private _isRejected;
+    private _isCancelled;
+    readonly cancelHandlers: (() => void)[];
+    readonly promise: Promise<T>;
+    private _resolve?;
+    private _reject?;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+declare class Interceptors<T> {
+    _fns: Middleware<T>[];
+    constructor();
+    eject(fn: Middleware<T>): void;
+    use(fn: Middleware<T>): void;
+}
+type OpenAPIConfig = {
+    BASE: string;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    interceptors: {
+        request: Interceptors<AxiosRequestConfig>;
+        response: Interceptors<AxiosResponse>;
+    };
+};
+declare const OpenAPI: OpenAPIConfig;
+
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+
+/**
+ * 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).
+     * The counterparty and webhook codes (COUNTERPARTY_NOT_FOUND, COUNTERPARTY_TIMEOUT,
+     * WEBHOOK_ERROR, WEBHOOK_CONNECTION_ERROR, INTERNAL_ERROR) mirror the AuthorizationErrorCode
+     * protobuf enum. GATEWAY_TIMEOUT, PROOF_INVALID, and PROOF_STALE are produced by payment-gw
+     * itself and have no protobuf equivalent.
+     *
+     */
+    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).
+ * The counterparty and webhook codes (COUNTERPARTY_NOT_FOUND, COUNTERPARTY_TIMEOUT,
+ * WEBHOOK_ERROR, WEBHOOK_CONNECTION_ERROR, INTERNAL_ERROR) mirror the AuthorizationErrorCode
+ * protobuf enum. GATEWAY_TIMEOUT, PROOF_INVALID, and PROOF_STALE are produced by payment-gw
+ * itself and have no protobuf equivalent.
+ *
+ */
+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)
+     */
+    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.
+     *
+     */
+    quote_deadline: string;
+    /**
+     * Required. The final deadline for completing the payment. If not completed by this time the
+     * payment is cancelled and 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;
+    /**
+     * 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;
+    /**
+     * Third-party service that will independently verify your payment was delivered.
+     * Leave empty to use the default verifier.
+     *
+     */
+    fulfillment_verifier?: {
+        /**
+         * The wallet address or public key of the verification service
+         */
+        account: string;
+        /**
+         * The API endpoint URL where the verification service can be reached
+         */
+        endpoint: string;
+    };
+    /**
+     * Escrow contract address, used to protect source funds until proof of fulfillment has been verified. Leave empty to use the default.
+     *
+     */
+    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 together; blacklist takes precedence
+     * (a settler in both lists is rejected).
+     *
+     */
+    settler_requirements?: {
+        /**
+         * List of settler DIDs permitted to fulfill this request.
+         * If present, only these settlers may win.
+         * Use W3C DID format.
+         *
+         */
+        whitelist?: Array<(string)>;
+        /**
+         * List of settler DIDs excluded from fulfilling this request.
+         * Use W3C DID format.
+         *
+         */
+        blacklist?: Array<(string)>;
+    };
+};
+/**
+ * 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
+     *
+     */
+    account: string;
+};
+/**
+ * Authorization from the asset owner to execute the payment. The exact format depends on
+ * the source blockchain's authorization mechanism.
+ *
+ */
+type SenderAuth = {
+    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
+ * - `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. Format depends on the blockchain:
+     * - EVM: Hex-encoded message hash (with 0x prefix)
+     * - Solana: Base64 encoded message
+     * - Tron: Hex-encoded message hash (possibly without 0x prefix)
+     *
+     */
+    message: string;
+    /**
+     * Optional: If 'message' contains a hash, this field contains the original data
+     * before it was hashed. Useful for verification and debugging.
+     *
+     */
+    message_prehash?: string;
+    /**
+     * The cryptographic signature proving you authorized this message.
+     * Format varies by blockchain (hex for EVM/Tron, base58 for Solana).
+     *
+     */
+    signature: string;
+};
+/**
+ * Optional identity verification using cryptographic credentials.
+ * Required when regulatory compliance or KYC verification is needed for the payment.
+ *
+ */
+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
+     */
+    credentialStatus?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Cryptographic proof of credential integrity
+     */
+    proof: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Response from submitting a payment request. If processing completes within 30 seconds,
+ * the response will include a fulfillment_confirmation with full settlement details.
+ * Otherwise, you'll receive a payment_id that you can use to poll the
+ * /v1/payments/{paymentId}/status endpoint for updates.
+ *
+ */
+type PaymentResponse = {
+    /**
+     * Unique ID for tracking this payment. Save this to check status later.
+     *
+     */
+    payment_id?: string;
+    fulfillment_confirmation?: FulfillmentConfirmation;
+};
+type GetPaymentStatusResponse = {
+    /**
+     * The payment ID you're checking status for.
+     *
+     */
+    payment_id?: string;
+    /**
+     * Current status of your payment:
+     * - `pending`: Payment is being processed
+     * - `completed`: Payment successfully delivered
+     * - `failed`: Payment failed (funds returned if escrowed)
+     * - `cancelled`: Payment was cancelled before completion
+     *
+     */
+    status?: 'pending' | 'completed' | 'failed' | 'cancelled';
+    /**
+     * When the status was last updated
+     */
+    updated_at?: string;
+    fulfillment_confirmation?: FulfillmentConfirmation;
+    error?: PaymentError;
+};
+/**
+ * Current status of your payment:
+ * - `pending`: Payment is being processed
+ * - `completed`: Payment successfully delivered
+ * - `failed`: Payment failed (funds returned if escrowed)
+ * - `cancelled`: Payment was cancelled before completion
+ *
+ */
+type status2 = 'pending' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Error details when payment status is "failed".
+ * Only present when the payment has failed. Contains a machine-readable
+ * code for programmatic handling and a human-readable message for debugging.
+ *
+ */
+type PaymentError = {
+    /**
+     * Machine-readable error code in SCREAMING_SNAKE_CASE.
+     * Common codes:
+     * - `QUOTE_DEADLINE_EXPIRED`: No settlement quotes received in time
+     * - `QUOTE_SELECTION_FAILED`: Quotes received but none met requirements
+     * - `INSUFFICIENT_FUNDS`: Sender wallet has insufficient balance
+     * - `FULFILLMENT_TIMEOUT`: Settlement agent didn't complete in time
+     *
+     */
+    code: string;
+    /**
+     * Human-readable error description with additional context.
+     *
+     */
+    message: string;
+    /**
+     * Service domain where the error originated.
+     *
+     */
+    domain?: 'PAYMENT_GATEWAY' | 'SOLVER_GATEWAY' | 'SETTLER_AGENT' | 'WALLET_ORCHESTRATION' | 'VERIFICATION_SERVICE' | 'BLOCKCHAIN' | 'EXTERNAL_SERVICE';
+    blockchain_context?: PaymentBlockchainContext;
+};
+/**
+ * Service domain where the error originated.
+ *
+ */
+type domain = 'PAYMENT_GATEWAY' | 'SOLVER_GATEWAY' | 'SETTLER_AGENT' | 'WALLET_ORCHESTRATION' | 'VERIFICATION_SERVICE' | 'BLOCKCHAIN' | 'EXTERNAL_SERVICE';
+/**
+ * Blockchain-specific error context. Only present when the error
+ * originated from an on-chain operation (e.g., escrow revert,
+ * fulfillment failure).
+ *
+ */
+type PaymentBlockchainContext = {
+    /**
+     * CAIP-2 chain identifier
+     */
+    chain_id?: string;
+    /**
+     * Failed transaction hash
+     */
+    tx_hash?: string;
+    /**
+     * Block number where error occurred
+     */
+    block_number?: number;
+    /**
+     * Contract address involved in 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;
+    /**
+     * High-level status:
+     * - `pending`: Bidding, awarded, or early in settlement
+     * - `settling`: Settlement in progress (on-chain steps executing)
+     * - `completed`: Payment successfully delivered
+     * - `failed`: Payment failed
+     * - `cancelled`: Payment was cancelled
+     *
+     */
+    status: 'pending' | 'settling' | 'completed' | 'failed' | 'cancelled';
+    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?: TimelineError;
+    steps: Array<TimelineStep>;
+};
+/**
+ * High-level status:
+ * - `pending`: Bidding, awarded, or early in settlement
+ * - `settling`: Settlement in progress (on-chain steps executing)
+ * - `completed`: Payment successfully delivered
+ * - `failed`: Payment failed
+ * - `cancelled`: Payment was cancelled
+ *
+ */
+type status3 = 'pending' | 'settling' | 'completed' | 'failed' | 'cancelled';
+/**
+ * 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;
+};
+/**
+ * Structured error details when a payment has failed
+ */
+type TimelineError = {
+    /**
+     * Machine-readable error code
+     */
+    code: string;
+    /**
+     * Human-readable error description
+     */
+    message: string;
+    /**
+     * Which component reported the error
+     */
+    domain?: string;
+    /**
+     * CAIP-2 chain where the error occurred (if on-chain)
+     */
+    chain_id?: string;
+    /**
+     * Transaction hash of the failed on-chain attempt (if applicable)
+     */
+    tx_hash?: string;
+    /**
+     * Smart-contract revert reason (if the error was an on-chain revert)
+     */
+    revert_reason?: string;
+};
+type TimelineStep = {
+    /**
+     * Name of the step
+     */
+    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)
+     */
+    tx_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 status4 = 'completed' | 'in_progress' | 'pending' | 'failed' | 'skipped';
+type ErrorResponse = {
+    /**
+     * Error message
+     */
+    error?: string;
+};
+/**
+ * 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).
+     */
+    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.
+     *
+     */
+    quote_deadline: string;
+    /**
+     * Required. Final deadline for completing the payment. Past it the payment is cancelled 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;
+    /**
+     * Optional third-party service that independently verifies delivery. Leave empty for the default verifier.
+     */
+    fulfillment_verifier?: {
+        /**
+         * The wallet address or public key of the verification service
+         */
+        account: string;
+        /**
+         * The API endpoint URL where the verification service can be reached
+         */
+        endpoint: string;
+    };
+    /**
+     * Optional escrow contract address. Leave empty to use the default.
+     */
+    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.
+ */
+type DataIntegrityProof = {
+    /**
+     * Proof type identifier (e.g. EcdsaSecp256k1RecoverySignature2020).
+     */
+    type: string;
+    /**
+     * ISO 8601 timestamp when the proof was created.
+     */
+    created: string;
+    /**
+     * DID URL identifying the verification method.
+     */
+    verificationMethod: string;
+    /**
+     * Purpose of the proof (e.g. assertionMethod, authentication).
+     */
+    proofPurpose: string;
+    /**
+     * Detached JWS signature (header..signature format for ES256K-R).
+     */
+    jws?: string;
+    /**
+     * Alternative to jws: base-encoded proof value.
+     */
+    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.network/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.network/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.
+ *
+ */
+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';
+    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>;
+};
+/**
+ * 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 status5 = '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.
+ *
+ */
+type QuoteRequestAccepted = {
+    quote_request_id: string;
+    /**
+     * Always `collecting` — collection is in progress server-side.
+     */
+    status: 'collecting';
+    source?: OwnedAsset;
+    destination?: Array<OwnedAsset>;
+    fulfillment_amount?: string;
+    max_source_amount?: string;
+    fulfillment_deadline?: string;
+    quote_deadline?: string;
+};
+/**
+ * Always `collecting` — collection is in progress server-side.
+ */
+type status6 = '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 in progress; `quotes` absent.
+     * - `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. Absent while status is `collecting`.
+     */
+    quotes?: Array<AwardedQuote>;
+    /**
+     * Flat list of awarded (quote_id, payment_id) pairs. At most one entry under MVP single-award.
+     */
+    payments?: Array<AwardedPayment>;
+};
+/**
+ * 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 in progress; `quotes` absent.
+ * - `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 status7 = 'collecting' | 'ready' | 'awarded' | 'expired';
+/**
+ * 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;
+};
+/**
+ * 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 status8 = '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 status9 = 'awarding';
+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 HealthCheckResponse = {
+    status?: string;
+};
+type $OpenApiTs = {
+    '/v1/payments': {
+        post: {
+            req: SubmitPaymentData;
+            res: {
+                /**
+                 * Payment request submitted successfully
+                 */
+                200: PaymentResponse;
+                /**
+                 * Invalid request
+                 */
+                400: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: 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;
+                /**
+                 * Invalid payment request
+                 */
+                400: ErrorResponse;
+                /**
+                 * Counterparty not found (no registration for the resolved DID)
+                 */
+                404: ErrorResponse;
+                /**
+                 * Counterparty webhook error (HTTP error or connection failure)
+                 */
+                502: ErrorResponse;
+                /**
+                 * Authorization timed out (counterparty did not respond)
+                 */
+                504: ErrorResponse;
+            };
+        };
+    };
+    '/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
+                 */
+                400: ErrorResponse;
+                /**
+                 * Internal server error
+                 */
+                500: 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;
+            };
+        };
+    };
+    '/health': {
+        get: {
+            res: {
+                /**
+                 * Service is healthy
+                 */
+                200: {
+                    status?: string;
+                };
+            };
+        };
+    };
+};
+
+declare class PaymentsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Submit a payment request
+     * Initiates a payment by submitting a cryptographically signed payment request.
+     *
+     * The payment gateway will:
+     * 1. Validate the request and signatures
+     * 2. Find optimal settlement routes across chains/assets
+     * 3. Secure funds in escrow
+     * 4. Coordinate with settlement agents for execution
+     * 5. Return a real-time result if processing completes within 30 seconds,
+     * otherwise return a payment ID for status polling
+     *
+     * @param data The data for the request.
+     * @param data.requestBody
+     * @returns PaymentResponse Payment request submitted successfully
+     * @throws ApiError
+     */
+    submitPayment(data: SubmitPaymentData): CancelablePromise<SubmitPaymentResponse>;
+    /**
+     * Get payment status
+     * Retrieve the status of a payment by its ID
+     * @param data The data for the request.
+     * @param data.paymentId The ID of the payment to query
+     * @returns GetPaymentStatusResponse Payment status retrieved successfully
+     * @throws ApiError
+     */
+    getPaymentStatus(data: GetPaymentStatusData): CancelablePromise<GetPaymentStatusResponse2>;
+    /**
+     * Resolve a request ID to a payment ID
+     * Looks up the payment ID associated with a given client-supplied request ID.
+     * Used by tooling like the payment explorer so callers can look a payment up
+     * by the request ID they originally submitted.
+     *
+     * @param data The data for the request.
+     * @param data.requestId The client-supplied request ID embedded in the payment request
+     * @returns ResolvePaymentResponse Payment found
+     * @throws ApiError
+     */
+    resolvePayment(data: ResolvePaymentData): CancelablePromise<ResolvePaymentResponse2>;
+    /**
+     * Get step-by-step payment timeline
+     * Returns the settlement timeline for a payment, including every step the
+     * payment has passed through, per-step durations, chain IDs, transaction
+     * hashes, and — if the payment has failed — a structured error describing
+     * where and why it failed.
+     *
+     * @param data The data for the request.
+     * @param data.paymentId The ID of the payment to query
+     * @returns PaymentTimelineResponse Timeline retrieved successfully
+     * @throws ApiError
+     */
+    getPaymentTimeline(data: GetPaymentTimelineData): CancelablePromise<GetPaymentTimelineResponse>;
+    /**
+     * Prepare an unsigned payment request
+     * Generates an unsigned PaymentRequest object from human-readable inputs.
+     * This endpoint allows clients to:
+     * 1. Use friendly asset identifiers (e.g., "ethereum/usdc" instead of full CAIP-19)
+     * 2. Specify amounts in decimal format
+     * 3. Get back a complete PaymentRequest with typed data (eg EIP-712 for EVM-compatible chains) ready for signing
+     *
+     * The response includes everything needed to sign and submit a payment, except the signature itself.
+     *
+     * @param data The data for the request.
+     * @param data.requestBody
+     * @returns PreparePaymentResponse Payment request prepared successfully
+     * @throws ApiError
+     */
+    preparePayment(data: PreparePaymentData): CancelablePromise<PreparePaymentResponse2>;
+}
+declare class AuthorizationsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Request counterparty authorization
+     * Submits a PaymentRequest for counterparty authorization before settlement.
+     * The call blocks synchronously until the beneficiary PSP responds or the
+     * timeout expires (default 30 seconds).
+     *
+     * If authorized, the response includes the counterparty's proof which can
+     * be attached to the subsequent SubmitPayment call.
+     *
+     * Authorization and RFQ submission are separate steps. This endpoint does
+     * NOT trigger an auction — the originator must call SubmitPayment separately.
+     *
+     * @param data The data for the request.
+     * @param data.requestBody
+     * @returns AuthorizationResult Authorization decision received (authorized or declined)
+     * @throws ApiError
+     */
+    authorizePayment(data: AuthorizePaymentData): CancelablePromise<AuthorizePaymentResponse>;
+}
+declare class QuoteRequestsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Create a quote-request batch
+     * Opens a quote-request batch: broadcasts the corridor to settlement agents and collects
+     * their signed quotes. This is the first phase of the two-phase quote → award flow — the
+     * originator later picks one quote and commits in a separate POST /v1/payments/awards call.
+     * No spend authorization is supplied here; `sender_auth` is deferred to award time.
+     *
+     * Wait modes (the `wait` query parameter):
+     * - `wait=false` (default): return 202 immediately with status `collecting`; poll
+     * GET /v1/payments/quote-requests/{quoteRequestId} until status is `ready`.
+     * - `wait=true`: hold the connection for up to
+     * min(quote_deadline, quote_sync_wait_seconds) and return 200 with the collected quotes
+     * (status `ready`). If the sync cap fires before the quote deadline, return 200 with
+     * status `collecting` and poll the status endpoint.
+     *
+     * Collection continues server-side until the quote deadline regardless of the HTTP
+     * connection, so quotes remain retrievable via the status endpoint in either mode.
+     *
+     * @param data The data for the request.
+     * @param data.requestBody
+     * @param data.wait Return a handle immediately (`false`, default) or hold the connection for collected quotes (`true`).
+     * @returns QuoteRequestResponse Quote-request resolved synchronously. `status` is `ready` when quotes were collected,
+     * or `collecting` when the sync wait cap fired before the quote deadline.
+     *
+     * @returns QuoteRequestAccepted Quote-request accepted; collection continues asynchronously.
+     * @throws ApiError
+     */
+    createQuoteRequest(data: CreateQuoteRequestData): CancelablePromise<CreateQuoteRequestResponse>;
+    /**
+     * Get quote-request batch status
+     * Returns the current state of a quote-request batch: a derived status, the collected
+     * quotes (each with its settler-signed `award_deadline`), and the awarded
+     * (quote_id, payment_id) pairs once a quote has been awarded. Used for async polling,
+     * connection-drop recovery, and re-reading quotes before awarding.
+     *
+     * The `status` here describes the quote-request batch lifecycle
+     * (`collecting`/`ready`/`awarded`/`expired`) and is disjoint from the payment-status enum
+     * returned by the award and payment-status endpoints.
+     *
+     * @param data The data for the request.
+     * @param data.quoteRequestId The ID of the quote-request batch to query
+     * @returns QuoteRequestStatusResponse Quote-request status retrieved successfully
+     * @throws ApiError
+     */
+    getQuoteRequestStatus(data: GetQuoteRequestStatusData): CancelablePromise<GetQuoteRequestStatusResponse>;
+    /**
+     * Award a quote
+     * Commits to a payment by awarding one quote from a previously-collected batch. The
+     * originator submits two signatures from their wallet: `sender_auth` (the Permit2 deposit
+     * authorization) and a fully-formed `bid_award` declaration whose `authorization` carries
+     * the Escrow reserve-witness signature naming the chosen settler. The awarded quote is
+     * identified server-side by content-hashing `bid_award.fulfillment_quote_json` — there is
+     * no `quote_id` on the wire.
+     *
+     * From this call onward the `status` field describes the payment lifecycle (disjoint from the
+     * quote-request batch status). Track the payment afterward via
+     * GET /v1/payments/{paymentId}/status — a separate endpoint with its own status vocabulary
+     * (an in-progress payment reads as `pending` there).
+     *
+     * Wait modes (the `wait` query parameter):
+     * - `wait=false` (default): return 202 immediately with `payment_id` and status `awarding`;
+     * poll GET /v1/payments/{paymentId}/status.
+     * - `wait=true`: hold the connection for up to payment_sync_wait_seconds and
+     * return 200 with the payment result. If the sync cap fires first, return 200 with a
+     * non-terminal status (`awarding`); poll GET /v1/payments/{paymentId}/status.
+     *
+     * @param data The data for the request.
+     * @param data.requestBody
+     * @param data.wait Return a handle immediately (`false`, default) or hold the connection for the payment result (`true`).
+     * @returns AwardResponse 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.
+     *
+     * @returns AwardAccepted Award accepted; settlement continues asynchronously.
+     * @throws ApiError
+     */
+    awardQuote(data: AwardQuoteData): CancelablePromise<AwardQuoteResponse>;
+}
+declare class HealthService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Health check
+     * Returns the health status of the service
+     * @returns unknown Service is healthy
+     * @throws ApiError
+     */
+    healthCheck(): CancelablePromise<HealthCheckResponse>;
+}
+
+type HttpRequestConstructor$1 = new (config: OpenAPIConfig) => BaseHttpRequest;
+declare class PaymentGatewayClient$1 {
+    readonly authorizations: AuthorizationsService;
+    readonly health: HealthService;
+    readonly payments: PaymentsService;
+    readonly quoteRequests: QuoteRequestsService;
+    readonly request: BaseHttpRequest;
+    constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor$1);
+}
+
+interface Logger {
+    debug(obj: unknown, msg?: string): void;
+    info(obj: unknown, msg?: string): void;
+    warn(obj: unknown, msg?: string): void;
+    error(obj: unknown, msg?: string): void;
+    child(bindings: Record<string, unknown>): Logger;
+}
+
+interface Counter {
+    add(value: number, attributes?: Record<string, unknown>): void;
+}
+interface Histogram {
+    record(value: number, attributes?: Record<string, unknown>): void;
+}
+interface InstrumentOptions {
+    description?: string;
+    unit?: string;
+}
+interface Meter {
+    createCounter(name: string, options?: InstrumentOptions): Counter;
+    createHistogram(name: string, options?: InstrumentOptions): Histogram;
+}
+
+/**
+ * Resolves the `issued_at` timestamp for a Solana deposit authorization from the
+ * cluster's on-chain clock instead of the local wall clock.
+ *
+ * The escrow validates `now_sec >= issued_at` against Solana's `Clock` sysvar
+ * (crates/replay/src/check.rs). That on-chain clock is global consensus and only
+ * moves forward, so a value read at build time is a safe lower bound at
+ * settlement, which removes the `Escrow_FutureTransaction` failure that a raw
+ * `Date.now()` (client wall clock, possibly ahead of the lagging cluster clock)
+ * can trigger.
+ *
+ * The read is best-effort: on any failure, timeout, or unresolved RPC it falls
+ * back to `Date.now()` minus a skew buffer, so a flaky public endpoint degrades
+ * to the previous behavior rather than blocking the payment.
+ */
+
+/** Reads the cluster's on-chain unix timestamp (seconds) from an RPC endpoint. */
+type SolanaClusterUnixTimeReader = (rpcUrl: string, timeoutMs: number) => Promise<bigint>;
+
+/**
+ * Chain defaults returned by the payment gateway /defaults endpoint.
+ */
+interface ChainDefaults {
+    escrowContract: string;
+    quoteSelector: string;
+    fulfillmentVerifierAccount: string;
+    fulfillmentVerifierEndpoint: string;
+    fulfillmentProxy: string;
+    permit2Contract?: string;
+    /**
+     * V3 Solana escrow domain-separation fields, surfaced by payment-gw
+     * `/defaults` for Solana source chains. Used to build the EscrowDomain that the
+     * V3 deposit hash binds to. Absent for EVM/Tron.
+     */
+    svmSignatureClusterId?: string;
+    svmSignatureDomainVersion?: number;
+}
+/**
+ * Result of building a sender auth message for a specific chain.
+ */
+interface AuthMessageResult {
+    messageScheme: SenderAuthMessageScheme;
+    messageHash: string;
+    messagePrehash: string;
+}
+/**
+ * Chain-specific overrides for the request-body contract fields
+ * (`quote_selector`, `fulfillment_verifier`). Some chains must rewrite the raw
+ * /defaults values before they go on the wire — e.g. Tron normalizes base58
+ * (`T…`) addresses to the canonical 20-byte hex the on-chain verifier and the
+ * signed permit witness use. A chain that needs no rewrite returns undefined
+ * and the caller falls back to the raw defaults. Applied identically on the
+ * payment and quote paths, so their contract fields never diverge.
+ */
+interface ContractFieldOverrides {
+    quote_selector?: string;
+    fulfillment_verifier?: {
+        account: string;
+        endpoint: string;
+    };
+}
+/**
+ * Chain adapter that handles all chain-specific logic:
+ * message building (SDK), key formatting, and signing (CLI).
+ */
+interface ChainAdapter {
+    /**
+     * Turnkey account address format (e.g. `ADDRESS_FORMAT_ETHEREUM`), used to map a
+     * wallet account back to this chain's namespace.
+     */
+    turnkeyAddressFormat: string;
+    /**
+     * Build the sender_auth message (hash + prehash). May be async: the Solana
+     * adapter reads the on-chain cluster clock to ground `issued_at`.
+     */
+    buildAuthMessage(params: {
+        sourceAsset: string;
+        depositor: string;
+        fulfillmentAmount: string;
+        requestId: string;
+        sourceDefaults: ChainDefaults;
+        deadlineSeconds?: number;
+        /** Solana-only: override the RPC used to read the cluster clock for issued_at. */
+        solanaRpcUrl?: string;
+        /** Solana-only: injectable clock reader, primarily a test seam. */
+        solanaClockReader?: SolanaClusterUnixTimeReader;
+        /** Solana-only: optional logger; warns if the cluster clock read fails and issued_at falls back to the wall clock. */
+        solanaLogger?: Logger;
+    }): Promise<AuthMessageResult>;
+    /**
+     * Resolve chain-specific overrides for the request-body contract fields
+     * (`quote_selector`, `fulfillment_verifier`). Both preparePaymentRequest and
+     * prepareQuoteRequest resolve these fields through this one method, so the
+     * payment and quote paths always carry byte-identical contract fields.
+     * Returns undefined when the chain needs no rewrite (EVM); Tron normalizes
+     * base58 → canonical hex.
+     */
+    resolveContractOverrides?(sourceDefaults: ChainDefaults): ContractFieldOverrides | undefined;
+    /** Normalize private key format for this chain. */
+    formatPrivateKey(key: string): string;
+    /**
+     * Reject a malformed raw key value-free (throwing `Invalid private key`)
+     * before it reaches the chain's signing library. Chains whose key decoding
+     * already fails without echoing the key (e.g. Solana's bs58/length checks)
+     * omit this; EVM/Tron implement it because `ethers.Wallet` embeds the key
+     * value verbatim in its error for malformed input.
+     */
+    validatePrivateKey?(key: string): void;
+    /**
+     * Sign a sender-auth signed_messages[i] entry, returning a 0x-prefixed
+     * hex signature. The adapter chooses the appropriate signing scheme
+     * based on its chain:
+     *   - EVM:    EIP-712 typed-data signing over signedMessage.message_prehash
+     *             (which is shaped to be a direct ethers.signTypedData arg set).
+     *   - Tron:   TIP-712 typed-data signing (chain-specific quirks).
+     *   - Solana: ed25519 over a chain-specific canonicalized digest.
+     */
+    sign(signedMessage: SignedMessage, privateKey: string): Promise<string>;
+    /**
+     * Derive the base58 public key of the signing key, for chains whose signatures
+     * are NOT public-key-recoverable and must therefore ship the signer's pubkey
+     * alongside the signature. Solana (Ed25519) implements this; EVM/Tron do not
+     * (secp256k1 signatures are recoverable via ecrecover, so the verifier derives
+     * the signer from the signature itself). The result is attached to
+     * sender_auth.signed_messages[0].payload.delegate_signer so the settler can feed
+     * it to the on-chain Ed25519 verify instruction.
+     */
+    deriveDelegateSigner?(privateKey: string): string;
+    /**
+     * Assert the private key derives `address`, so a wrong key/sender pair fails
+     * fast (mirrors the Turnkey pinnedAddress check) instead of signing as the
+     * wrong depositor and only failing downstream. Throws on mismatch. The error
+     * names the addresses (public) but never the key.
+     */
+    verifyAddressMatchesKey?(privateKey: string, address: string): void;
+}
+
+/** Result of signing a sender_auth message. */
+interface SenderSignature {
+    /** 0x-prefixed signature hex (65-byte secp256k1 for EVM/Tron, 64-byte ed25519 for Solana). */
+    signature: string;
+    /**
+     * base58 signer public key for non-recoverable schemes (Solana), attached to
+     * the signed message's payload.delegate_signer. Absent for EVM/Tron, whose
+     * secp256k1 signatures are recoverable.
+     */
+    delegateSigner?: string;
+}
+/** Signs a single sender_auth signed message for a payment request. */
+interface SenderSigner {
+    sign(signedMessage: SignedMessage): Promise<SenderSignature>;
+}
+/** Turnkey provider configuration (shared by the SDK and the CLI env loader). */
+interface TurnkeyConfig {
+    organizationId: string;
+    walletId: string;
+    apiPublicKey: string;
+    apiPrivateKey: string;
+    /**
+     * Chain-native address the signer is expected to resolve to. Verified against
+     * the address Turnkey returns at initialize(); a mismatch fails fast rather
+     * than signing as the wrong depositor.
+     */
+    pinnedAddress?: string;
+    /**
+     * Optional observability threaded to the Turnkey network path (default noop).
+     * SDK consumers can wire their own logger and meter; the CLI leaves them unset.
+     */
+    logger?: Logger;
+    meter?: Meter;
+}
+/** Options selecting a sender-signing provider. Defaults to the private-key provider. */
+type SenderSignerOptions = {
+    provider?: 'raw';
+    privateKey: string;
+    pinnedAddress?: string;
+} | ({
+    provider: 'turnkey';
+} & TurnkeyConfig);
+
+/**
+ * Private-key sender signer. Delegates to the chain adapter so the local-key
+ * signing path is unchanged. The adapter validates the key in the constructor,
+ * so a malformed EVM/Tron key can't leak via ethers even on direct construction.
+ */
+declare class RawSenderSigner implements SenderSigner {
+    private readonly adapter;
+    private readonly privateKey;
+    constructor(adapter: ChainAdapter, privateKey: string);
+    sign(signedMessage: SignedMessage): Promise<SenderSignature>;
+}
+
+/** Typed contract for the lazily-loaded ./turnkey-impl module; also the test's conformance target. */
+interface TurnkeyImplModule {
+    turnkeySign: (chainPrefix: string, cfg: {
+        organizationId: string;
+        walletId: string;
+        apiPublicKey: string;
+        apiPrivateKey: string;
+        pinnedAddress?: string;
+        logger?: Logger;
+        meter?: Meter;
+    }, message: string, messagePrehash: string | undefined) => Promise<SenderSignature>;
+}
+/** Turnkey-backed sender signer for a single source chain; the heavy impl is loaded lazily. */
+declare class TurnkeySenderSigner implements SenderSigner {
+    private readonly chainPrefix;
+    private readonly cfg;
+    private readonly loader;
+    constructor(chainPrefix: string, cfg: TurnkeyConfig, loader?: () => Promise<TurnkeyImplModule>);
+    sign(signedMessage: SignedMessage): Promise<SenderSignature>;
+}
+
+/**
+ * Build a SenderSigner for the given CAIP-2 source chain. Defaults to the
+ * private-key provider (unchanged local signing); pass
+ * `{ provider: 'turnkey', ... }` to sign the sender_auth message via a Turnkey
+ * wallet instead.
+ */
+declare function createSenderSigner(sourceChainId: string, opts: SenderSignerOptions): SenderSigner;
+/**
+ * Resolve a Turnkey wallet's sender addresses keyed by CAIP-2 namespace, in one
+ * query. The Turnkey impl is loaded lazily so a plain SDK import stays free of
+ * @solana/web3.js.
+ */
+declare function resolveTurnkeyAddresses(cfg: TurnkeyConfig): Promise<Record<string, string>>;
+
+declare const $AuthorizationResult: {
+    readonly type: "object";
+    readonly description: "The result of a counterparty authorization request. Contains either\nthe PSP's authorization decision (authorized/declined with proof) or\nan error indicating why authorization could not be completed.\n";
+    readonly required: readonly ["payment_id", "counterparty_did", "status"];
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly description: "Correlation key for this authorization";
+            readonly example: "0x1234abcd";
+        };
+        readonly counterparty_did: {
+            readonly type: "string";
+            readonly description: "The beneficiary PSP's DID";
+            readonly example: "did:pkh:eip155:1:0xdeadbeef";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly description: "Authorization outcome. \"authorized\" or \"declined\" when the PSP responded.\n\"error\" or \"timeout\" when the authorization could not be completed.\n";
+            readonly enum: readonly ["authorized", "declined", "error", "timeout"];
+            readonly example: "authorized";
+        };
+        readonly authorization_response: {
+            readonly type: "object";
+            readonly description: "The PSP's raw authorization response (present when status is authorized or declined)";
+            readonly additionalProperties: true;
+        };
+        readonly error_code: {
+            readonly type: "string";
+            readonly description: "Machine-readable error code (present when status is error or timeout).\nThe counterparty and webhook codes (COUNTERPARTY_NOT_FOUND, COUNTERPARTY_TIMEOUT,\nWEBHOOK_ERROR, WEBHOOK_CONNECTION_ERROR, INTERNAL_ERROR) mirror the AuthorizationErrorCode\nprotobuf enum. GATEWAY_TIMEOUT, PROOF_INVALID, and PROOF_STALE are produced by payment-gw\nitself and have no protobuf equivalent.\n";
+            readonly enum: readonly ["COUNTERPARTY_NOT_FOUND", "COUNTERPARTY_TIMEOUT", "WEBHOOK_ERROR", "WEBHOOK_CONNECTION_ERROR", "INTERNAL_ERROR", "GATEWAY_TIMEOUT", "PROOF_INVALID", "PROOF_STALE"];
+            readonly 'x-enum-description': "The counterparty and webhook codes mirror the AuthorizationErrorCode protobuf enum\n(without the AUTHORIZATION_ERROR_CODE_ prefix for readability in HTTP responses).\nGATEWAY_TIMEOUT, PROOF_INVALID, and PROOF_STALE are payment-gw-local codes with no protobuf equivalent.\n";
+        };
+        readonly error_message: {
+            readonly type: "string";
+            readonly description: "Human-readable error description";
+        };
+        readonly webhook_http_status: {
+            readonly type: "integer";
+            readonly description: "HTTP status code from the PSP webhook (only for WEBHOOK_ERROR)";
+        };
+    };
+};
+declare const $PaymentRequest: {
+    readonly type: "object";
+    readonly description: "Structured payment request with sender authorization and optional W3C Verifiable Credentials";
+    readonly required: readonly ["version", "request_id", "source", "destination", "fulfillment_amount", "sender_auth", "quote_deadline", "fulfillment_deadline"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Semver-shaped declaration version (MAJOR.MINOR). The major component is locked to this schema's\nparent directory (v1 → major must be 1). Producers MUST emit the canonical value exported by the\nbindings' Version constant; the canonical bumps on each additive minor evolution.\n";
+            readonly pattern: "^1\\.[0-9]+$";
+            readonly example: "1.0";
+        };
+        readonly request_id: {
+            readonly type: "string";
+            readonly description: "Unique identifier for this payment request (used for idempotency)";
+            readonly example: "req_123456789";
+        };
+        readonly source: {
+            readonly $ref: "#/components/schemas/OwnedAsset";
+        };
+        readonly destination: {
+            readonly type: "array";
+            readonly description: "Array of destination assets for the settlement agent to choose from (at least one required)";
+            readonly minItems: 1;
+            readonly items: {
+                readonly $ref: "#/components/schemas/OwnedAsset";
+            };
+        };
+        readonly fulfillment_amount: {
+            readonly type: "string";
+            readonly description: "The exact amount to be received at the destination (in the smallest unit, e.g., wei for ETH, cents for USD).\n";
+            readonly example: "1000000";
+        };
+        readonly max_source_amount: {
+            readonly type: "string";
+            readonly description: "The maximum amount willing to be spent from the source (in the smallest unit).\n";
+            readonly example: "1000000";
+        };
+        readonly quote_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Required. The deadline for receiving price quotes from settlement providers. After this\npoint no new quotes are accepted. The gateway injects no default and validates the value\nis in the future. The originator must supply it, and a request that omits it or supplies\na past value is rejected with 400.\n";
+            readonly example: "2024-12-25T10:30:00Z";
+        };
+        readonly fulfillment_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Required. The final deadline for completing the payment. If not completed by this time the\npayment is cancelled and eligible for a refund. The gateway injects no default and validates\nthe value is in the future. The originator must supply it, and a request that omits it or\nsupplies a past value is rejected with 400.\n";
+            readonly example: "2024-12-25T11:00:00Z";
+        };
+        readonly settler_auth_required: {
+            readonly type: "object";
+            readonly description: "Policy requirements for settler authentication. Keys are policy names, values indicate if the policy is required.\n";
+            readonly additionalProperties: {
+                readonly type: "boolean";
+            };
+        };
+        readonly sender_auth: {
+            readonly $ref: "#/components/schemas/SenderAuth";
+        };
+        readonly originator_auth: {
+            readonly $ref: "#/components/schemas/VerifiableCredentialAuth";
+        };
+        readonly quote_selector: {
+            readonly type: "string";
+            readonly description: "Wallet address or public key of a trusted service that will automatically select \nthe best exchange rate for your payment. Leave empty to use the default selector.\n";
+            readonly example: "0x742d35Cc6634C0532925a3b844Bc9e7595f4136";
+        };
+        readonly fulfillment_verifier: {
+            readonly type: "object";
+            readonly description: "Third-party service that will independently verify your payment was delivered.\nLeave empty to use the default verifier.\n";
+            readonly required: readonly ["account", "endpoint"];
+            readonly properties: {
+                readonly account: {
+                    readonly type: "string";
+                    readonly description: "The wallet address or public key of the verification service";
+                    readonly example: "0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4431F";
+                };
+                readonly endpoint: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly description: "The API endpoint URL where the verification service can be reached";
+                    readonly example: "https://verifier.atum.network/api/v1/verify";
+                };
+            };
+        };
+        readonly escrow_contract_address: {
+            readonly type: "string";
+            readonly description: "Escrow contract address, used to protect source funds until proof of fulfillment has been verified. Leave empty to use the default.\n";
+            readonly example: "0x742d35Cc6634C0532925a3b844Bc9e7595f4136";
+        };
+        readonly fulfillment_proxy: {
+            readonly type: "string";
+            readonly description: "Fulfillment Proxy contract address, used to emit proof of fulfillment on the destination chain. Leave empty to use the default.\n";
+            readonly example: "0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4431F";
+        };
+        readonly settler_requirements: {
+            readonly type: "object";
+            readonly description: "Optional settler filtering requirements.\nIf whitelist is present, only whitelisted settlers may win.\nIf blacklist is present, blacklisted settlers are excluded.\nBoth can be specified together; blacklist takes precedence\n(a settler in both lists is rejected).\n";
+            readonly properties: {
+                readonly whitelist: {
+                    readonly type: "array";
+                    readonly description: "List of settler DIDs permitted to fulfill this request.\nIf present, only these settlers may win.\nUse W3C DID format.\n";
+                    readonly minItems: 1;
+                    readonly maxItems: 100;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly pattern: "^did:[a-z][a-z0-9]*:[a-zA-Z0-9._:%-]+$";
+                    };
+                    readonly example: readonly ["did:pkh:eip155:1:0x742d35Cc6634C0532925a3b844Bc9e7595f4136"];
+                };
+                readonly blacklist: {
+                    readonly type: "array";
+                    readonly description: "List of settler DIDs excluded from fulfilling this request.\nUse W3C DID format.\n";
+                    readonly minItems: 1;
+                    readonly maxItems: 100;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly pattern: "^did:[a-z][a-z0-9]*:[a-zA-Z0-9._:%-]+$";
+                    };
+                    readonly example: readonly ["did:pkh:eip155:1:0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4432F"];
+                };
+            };
+        };
+    };
+};
+declare const $FulfillmentConfirmation: {
+    readonly type: "object";
+    readonly description: "Confirmation details after a payment has been successfully delivered.\nContains proof of delivery and transaction details for both source and destination chains.\n";
+    readonly required: readonly ["payment_id", "request_id", "fulfillment_timestamp", "source_chain_id", "destination_chain_id"];
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly description: "Unique identifier for this payment transaction.\nUse this to track the payment across all systems.\n";
+            readonly example: "0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f";
+        };
+        readonly request_id: {
+            readonly type: "string";
+            readonly description: "Your original request ID that was provided when creating the payment.\nHelps match confirmations to your internal systems.\n";
+            readonly example: "req_123456789";
+        };
+        readonly fulfillment_timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Timestamp when the fulfillment was completed";
+        };
+        readonly source_chain_id: {
+            readonly type: "string";
+            readonly description: "The blockchain where funds were locked in escrow, using CAIP-2 format.\nCAIP-2 is a standard way to identify blockchains: {namespace}:{reference}\nExamples:\n- \"eip155:1\" for Ethereum mainnet\n- \"eip155:42161\" for Arbitrum\n- \"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp\" for Solana\n- \"tron:mainnet\" for Tron\n";
+            readonly example: "eip155:1";
+        };
+        readonly destination_chain_id: {
+            readonly type: "string";
+            readonly description: "The blockchain where the payment was delivered, using CAIP-2 format.\nCAIP-2 is a standard way to identify blockchains: {namespace}:{reference}\nExamples:\n- \"eip155:1\" for Ethereum mainnet\n- \"eip155:42161\" for Arbitrum\n- \"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp\" for Solana\n- \"tron:mainnet\" for Tron\n";
+            readonly example: "eip155:42161";
+        };
+        readonly source_tx_hash: {
+            readonly type: "string";
+            readonly description: "Transaction hash of the escrow reservation on the source chain";
+            readonly example: "0xa1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456";
+        };
+        readonly destination_tx_hash: {
+            readonly type: "string";
+            readonly description: "Transaction hash of the fulfillment on the destination chain";
+            readonly example: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        };
+        readonly source_block_number: {
+            readonly type: "integer";
+            readonly description: "Block number where the source transaction was confirmed";
+        };
+        readonly destination_block_number: {
+            readonly type: "integer";
+            readonly description: "Block number where the destination transaction was confirmed";
+        };
+    };
+    readonly 'x-go-type': "fulfillmentconfirmation.SchemaJson";
+    readonly 'x-go-type-import': {
+        readonly name: "fulfillmentconfirmation";
+        readonly path: "github.com/atum-labs/protocol/schemas/apis/fulfillment-confirmation/v1/bindings/go";
+    };
+};
+declare const $OwnedAsset: {
+    readonly type: "object";
+    readonly description: "Represents a cryptocurrency or token in a specific wallet.\nThis tells the system what asset you're sending/receiving and which wallet to use.\n";
+    readonly required: readonly ["asset_identifier", "account"];
+    readonly properties: {
+        readonly asset_identifier: {
+            readonly type: "string";
+            readonly description: "A unique identifier for the asset using CAIP-19 format.\nCAIP-19 is a standard way to identify blockchain assets: {chain_id}/{asset_namespace}:{asset_reference}\nExamples:\n- Ethereum USDC: \"eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48\"\n- Arbitrum USDC: \"eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831\"\n- Solana USDC: \"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v\"\n- Tron USDT: \"tron:mainnet/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\"\n";
+            readonly pattern: "^[a-z0-9]+:[a-zA-Z0-9_-]+/[a-z0-9-]{3,8}:[-.%a-zA-Z0-9]{1,128}(/[-.%a-zA-Z0-9]{1,78})?$";
+            readonly example: "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+        };
+        readonly account: {
+            readonly type: "string";
+            readonly description: "The wallet address that owns this asset.\nFormat depends on the blockchain:\n- Ethereum/EVM: 0x-prefixed hex address (42 characters)\n- Solana: Base58 encoded address\n- Tron: T-prefixed Base58 address\n";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+            readonly example: "0x742d35Cc6634C0532925a3b844Bc9e7595f4136";
+        };
+    };
+};
+declare const $SenderAuth: {
+    readonly type: "object";
+    readonly description: "Authorization from the asset owner to execute the payment. The exact format depends on \nthe source blockchain's authorization mechanism.\n";
+    readonly required: readonly ["message_scheme", "signed_messages"];
+    readonly properties: {
+        readonly verifiable_credential: {
+            readonly $ref: "#/components/schemas/VerifiableCredentialAuth";
+        };
+        readonly message_scheme: {
+            readonly $ref: "#/components/schemas/SenderAuthMessageScheme";
+        };
+        readonly signed_messages: {
+            readonly type: "array";
+            readonly description: "Array of signed messages (at least one required)";
+            readonly minItems: 1;
+            readonly items: {
+                readonly $ref: "#/components/schemas/SignedMessage";
+            };
+        };
+    };
+};
+declare const $SenderAuthMessageScheme: {
+    readonly type: "string";
+    readonly description: "The signature method used for authorizing this payment:\n- `EVM_PERMIT2`: Gasless token approvals for Ethereum/EVM chains\n- `SOLANA`: Standard Solana transaction signatures\n- `TRON`: Tron transaction signatures\n";
+    readonly enum: readonly ["EVM_PERMIT2", "EVM_PERMIT2_ESCROW", "SOLANA", "TRON"];
+};
+declare const $SignedMessage: {
+    readonly type: "object";
+    readonly description: "A message that has been cryptographically signed to prove authorization.\nThe signature proves you control the wallet that's sending funds.\n";
+    readonly required: readonly ["message", "signature"];
+    readonly properties: {
+        readonly message: {
+            readonly type: "string";
+            readonly description: "The data that was signed. Format depends on the blockchain:\n- EVM: Hex-encoded message hash (with 0x prefix)\n- Solana: Base64 encoded message\n- Tron: Hex-encoded message hash (possibly without 0x prefix)\n";
+            readonly example: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        };
+        readonly message_prehash: {
+            readonly type: "string";
+            readonly description: "Optional: If 'message' contains a hash, this field contains the original data\nbefore it was hashed. Useful for verification and debugging.\n";
+            readonly example: "{\"permit\":{\"token\":\"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48\",\"amount\":\"1000000\"}}";
+        };
+        readonly signature: {
+            readonly type: "string";
+            readonly description: "The cryptographic signature proving you authorized this message.\nFormat varies by blockchain (hex for EVM/Tron, base58 for Solana).\n";
+            readonly example: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab1c";
+        };
+    };
+};
+declare const $VerifiableCredentialAuth: {
+    readonly type: "object";
+    readonly description: "Optional identity verification using cryptographic credentials.\nRequired when regulatory compliance or KYC verification is needed for the payment.\n";
+    readonly required: readonly ["verifiable_credential", "verification_method_id", "signature"];
+    readonly properties: {
+        readonly verifiable_credential: {
+            readonly $ref: "#/components/schemas/VerifiableCredential";
+        };
+        readonly verification_method_id: {
+            readonly type: "string";
+            readonly description: "Reference to verification method from the DID Document";
+        };
+        readonly signature: {
+            readonly type: "string";
+            readonly description: "Cryptographic signature matching the verification method type";
+        };
+    };
+};
+declare const $VerifiableCredential: {
+    readonly type: "object";
+    readonly description: "W3C Verifiable Credential structure conforming to the W3C Verifiable Credentials Data Model v1.1";
+    readonly required: readonly ["@context", "id", "type", "issuer", "issuanceDate", "credentialSubject", "proof"];
+    readonly properties: {
+        readonly '@context': {
+            readonly type: "array";
+            readonly description: "JSON-LD context array, must include 'https://www.w3.org/2018/credentials/v1'";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["https://www.w3.org/2018/credentials/v1"];
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly description: "Unique identifier for this credential";
+        };
+        readonly type: {
+            readonly type: "array";
+            readonly description: "Credential types, must include 'VerifiableCredential'";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["VerifiableCredential", "KYCVerifiedCredential"];
+        };
+        readonly issuer: {
+            readonly oneOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "object";
+            }];
+            readonly description: "DID or issuer object of the credential issuer";
+        };
+        readonly issuanceDate: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "When the credential was issued";
+        };
+        readonly expirationDate: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "When the credential expires";
+        };
+        readonly credentialSubject: {
+            readonly type: "object";
+            readonly description: "Claims about the credential subject (structure varies by issuer)";
+            readonly additionalProperties: true;
+        };
+        readonly credentialStatus: {
+            readonly type: "object";
+            readonly description: "Information for credential revocation checking";
+            readonly additionalProperties: true;
+        };
+        readonly proof: {
+            readonly type: "object";
+            readonly description: "Cryptographic proof of credential integrity";
+            readonly additionalProperties: true;
+        };
+    };
+};
+declare const $PaymentResponse: {
+    readonly type: "object";
+    readonly description: "Response from submitting a payment request. If processing completes within 30 seconds,\nthe response will include a fulfillment_confirmation with full settlement details.\nOtherwise, you'll receive a payment_id that you can use to poll the\n/v1/payments/{paymentId}/status endpoint for updates.\n";
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly description: "Unique ID for tracking this payment. Save this to check status later.\n";
+            readonly example: "550e8400-e29b-41d4-a716-446655440000";
+        };
+        readonly fulfillment_confirmation: {
+            readonly $ref: "#/components/schemas/FulfillmentConfirmation";
+        };
+    };
+};
+declare const $GetPaymentStatusResponse: {
+    readonly type: "object";
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly description: "The payment ID you're checking status for.\n";
+            readonly example: "550e8400-e29b-41d4-a716-446655440000";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["pending", "completed", "failed", "cancelled"];
+            readonly description: "Current status of your payment:\n- `pending`: Payment is being processed\n- `completed`: Payment successfully delivered\n- `failed`: Payment failed (funds returned if escrowed)\n- `cancelled`: Payment was cancelled before completion\n";
+        };
+        readonly updated_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "When the status was last updated";
+        };
+        readonly fulfillment_confirmation: {
+            readonly $ref: "#/components/schemas/FulfillmentConfirmation";
+        };
+        readonly error: {
+            readonly $ref: "#/components/schemas/PaymentError";
+        };
+    };
+};
+declare const $PaymentError: {
+    readonly type: "object";
+    readonly description: "Error details when payment status is \"failed\".\nOnly present when the payment has failed. Contains a machine-readable\ncode for programmatic handling and a human-readable message for debugging.\n";
+    readonly required: readonly ["code", "message"];
+    readonly properties: {
+        readonly code: {
+            readonly type: "string";
+            readonly description: "Machine-readable error code in SCREAMING_SNAKE_CASE.\nCommon codes:\n- `QUOTE_DEADLINE_EXPIRED`: No settlement quotes received in time\n- `QUOTE_SELECTION_FAILED`: Quotes received but none met requirements\n- `INSUFFICIENT_FUNDS`: Sender wallet has insufficient balance\n- `FULFILLMENT_TIMEOUT`: Settlement agent didn't complete in time\n";
+            readonly example: "QUOTE_DEADLINE_EXPIRED";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable error description with additional context.\n";
+            readonly example: "No quotes received within the auction window";
+        };
+        readonly domain: {
+            readonly type: "string";
+            readonly description: "Service domain where the error originated.\n";
+            readonly enum: readonly ["PAYMENT_GATEWAY", "SOLVER_GATEWAY", "SETTLER_AGENT", "WALLET_ORCHESTRATION", "VERIFICATION_SERVICE", "BLOCKCHAIN", "EXTERNAL_SERVICE"];
+            readonly example: "PAYMENT_GATEWAY";
+        };
+        readonly blockchain_context: {
+            readonly $ref: "#/components/schemas/PaymentBlockchainContext";
+        };
+    };
+};
+declare const $PaymentBlockchainContext: {
+    readonly type: "object";
+    readonly description: "Blockchain-specific error context. Only present when the error\noriginated from an on-chain operation (e.g., escrow revert,\nfulfillment failure).\n";
+    readonly properties: {
+        readonly chain_id: {
+            readonly type: "string";
+            readonly description: "CAIP-2 chain identifier";
+            readonly example: "eip155:42161";
+        };
+        readonly tx_hash: {
+            readonly type: "string";
+            readonly description: "Failed transaction hash";
+            readonly example: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        };
+        readonly block_number: {
+            readonly type: "integer";
+            readonly description: "Block number where error occurred";
+            readonly example: 12345678;
+        };
+        readonly contract_address: {
+            readonly type: "string";
+            readonly description: "Contract address involved in the error";
+            readonly example: "0x1234567890abcdef1234567890abcdef12345678";
+        };
+        readonly revert_reason: {
+            readonly type: "string";
+            readonly description: "Smart contract revert reason";
+            readonly example: "Insufficient balance";
+        };
+        readonly gas_used: {
+            readonly type: "string";
+            readonly description: "Gas consumed before failure";
+            readonly example: "21000";
+        };
+        readonly estimated_gas_needed: {
+            readonly type: "string";
+            readonly description: "Estimated gas needed for success";
+            readonly example: "50000";
+        };
+    };
+};
+declare const $PreparePaymentRequest: {
+    readonly type: "object";
+    readonly description: "Human-readable payment request parameters for generating an unsigned PaymentRequest.\nAsset identifiers use a CAIP-19-like format with \"/\" separator and support friendly names.\n";
+    readonly required: readonly ["request_id", "source_asset", "source_account", "destination_asset", "destination_account"];
+    readonly properties: {
+        readonly request_id: {
+            readonly type: "string";
+            readonly description: "Unique identifier for tracking this payment request.\nUsed for idempotency and matching responses to requests.\n";
+            readonly example: "req_123456789";
+        };
+        readonly source_asset: {
+            readonly type: "string";
+            readonly description: "Source asset in human-readable CAIP-19-like format: {chain}/{asset}\nSupports both friendly names and full CAIP-19 identifiers:\n- \"ethereum/usdc\" (friendly names)\n- \"eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48\" (full CAIP-19)\n";
+            readonly example: "ethereum/usdc";
+        };
+        readonly source_account: {
+            readonly type: "string";
+            readonly description: "Wallet address that will send the payment";
+            readonly example: "0x742d35Cc6634C0532925a3b844Bc9e7595f4136";
+        };
+        readonly destination_asset: {
+            readonly type: "string";
+            readonly description: "Destination asset in human-readable CAIP-19-like format: {chain}/{asset}\nSupports both friendly names and full CAIP-19 identifiers:\n- \"arbitrum/usdc\"\n- \"eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831\"\n";
+            readonly example: "arbitrum/usdc";
+        };
+        readonly destination_account: {
+            readonly type: "string";
+            readonly description: "Wallet address that will receive the payment";
+            readonly example: "0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4431F";
+        };
+        readonly amount: {
+            readonly type: "string";
+            readonly description: "Simple amount specification in decimal format (e.g., \"1.50\" for $1.50 USDC).\nUse this OR specify both max_source_amount and fulfillment_amount.\nCannot be used together with max_source_amount/fulfillment_amount.\n";
+            readonly example: "1.50";
+        };
+        readonly max_source_amount: {
+            readonly type: "string";
+            readonly description: "Maximum amount willing to spend from source (in decimal format).\nMust be specified together with fulfillment_amount.\nCannot be used together with amount field.\n";
+            readonly example: "1.60";
+        };
+        readonly fulfillment_amount: {
+            readonly type: "string";
+            readonly description: "Exact amount to be fulfilled at destination (in decimal format).\nMust be specified together with max_source_amount.\nCannot be used together with amount field.\n";
+            readonly example: "1.50";
+        };
+        readonly quote_deadline_seconds: {
+            readonly type: "integer";
+            readonly description: "Seconds until quote deadline (from now).\nHow long to wait for settlement provider quotes.\n";
+            readonly default: 10;
+            readonly example: 10;
+        };
+        readonly fulfillment_deadline_seconds: {
+            readonly type: "integer";
+            readonly description: "Seconds until fulfillment deadline (from now).\nFinal deadline for completing the payment.\n";
+            readonly default: 3600;
+            readonly example: 3600;
+        };
+    };
+};
+declare const $PreparePaymentResponse: {
+    readonly type: "object";
+    readonly description: "Complete unsigned PaymentRequest ready for signing.\nContains all resolved technical details and typed data ready for signing.\n";
+    readonly required: readonly ["payment_request"];
+    readonly properties: {
+        readonly payment_request: {
+            readonly $ref: "#/components/schemas/PaymentRequest";
+            readonly description: "Complete PaymentRequest with signature field set to null.\nClient should fill in the signature field(s) in\nsender_auth.signed_messages, either by signing the message_hash\nfield in signed_messages or by using typed data signing on the\nmessage_prehash field in signed messages, and then submit the full\nobject to POST /v1/payments.\n";
+        };
+    };
+};
+declare const $ResolvePaymentResponse: {
+    readonly type: "object";
+    readonly required: readonly ["payment_id"];
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly description: "The payment ID that corresponds to the given request ID";
+            readonly example: "0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f";
+        };
+    };
+};
+declare const $PaymentTimelineResponse: {
+    readonly type: "object";
+    readonly description: "Step-by-step view of a payment's settlement lifecycle. Includes a route\nsummary, a list of steps with timings, and if the payment failed, a\nstructured error describing where and why.\n";
+    readonly required: readonly ["payment_id", "status", "created_at", "updated_at", "steps"];
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly example: "0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["pending", "settling", "completed", "failed", "cancelled"];
+            readonly description: "High-level status:\n- `pending`: Bidding, awarded, or early in settlement\n- `settling`: Settlement in progress (on-chain steps executing)\n- `completed`: Payment successfully delivered\n- `failed`: Payment failed\n- `cancelled`: Payment was cancelled\n";
+        };
+        readonly created_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly updated_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly total_duration_ms: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Total time from first step to last completed step (only set for terminal states)";
+        };
+        readonly summary: {
+            readonly $ref: "#/components/schemas/PaymentSummary";
+        };
+        readonly error: {
+            readonly $ref: "#/components/schemas/TimelineError";
+        };
+        readonly steps: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/TimelineStep";
+            };
+        };
+    };
+};
+declare const $PaymentSummary: {
+    readonly type: "object";
+    readonly description: "Top-level context about the payment (parties, assets, amounts)";
+    readonly properties: {
+        readonly source_asset: {
+            readonly type: "string";
+            readonly description: "CAIP-19 identifier of the source asset";
+            readonly example: "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+        };
+        readonly source_account: {
+            readonly type: "string";
+            readonly example: "0x742d35Cc6634C0532925a3b844Bc9e7595f4136";
+        };
+        readonly dest_asset: {
+            readonly type: "string";
+            readonly example: "eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+        };
+        readonly dest_account: {
+            readonly type: "string";
+            readonly example: "0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4431F";
+        };
+        readonly fulfillment_amount: {
+            readonly type: "string";
+            readonly description: "Raw fulfillment amount in smallest token units";
+            readonly example: "1000000";
+        };
+        readonly display_amount: {
+            readonly type: "string";
+            readonly description: "Human-readable formatted amount with symbol, e.g. \"1.00 USDC\".\nOnly set when the source asset's decimals are known via the token registry.\n";
+            readonly example: "1.00 USDC";
+        };
+        readonly max_source_amount: {
+            readonly type: "string";
+            readonly description: "Raw max source amount in smallest token units";
+            readonly example: "1005000";
+        };
+        readonly request_id: {
+            readonly type: "string";
+            readonly example: "req_123456789";
+        };
+    };
+};
+declare const $TimelineError: {
+    readonly type: "object";
+    readonly description: "Structured error details when a payment has failed";
+    readonly required: readonly ["code", "message"];
+    readonly properties: {
+        readonly code: {
+            readonly type: "string";
+            readonly description: "Machine-readable error code";
+            readonly example: "ESCROW_DEPOSIT_FAILED";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable error description";
+        };
+        readonly domain: {
+            readonly type: "string";
+            readonly description: "Which component reported the error";
+            readonly example: "SETTLER_AGENT";
+        };
+        readonly chain_id: {
+            readonly type: "string";
+            readonly description: "CAIP-2 chain where the error occurred (if on-chain)";
+            readonly example: "eip155:1";
+        };
+        readonly tx_hash: {
+            readonly type: "string";
+            readonly description: "Transaction hash of the failed on-chain attempt (if applicable)";
+        };
+        readonly revert_reason: {
+            readonly type: "string";
+            readonly description: "Smart-contract revert reason (if the error was an on-chain revert)";
+        };
+    };
+};
+declare const $TimelineStep: {
+    readonly type: "object";
+    readonly required: readonly ["name", "label", "status"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Name of the step";
+            readonly example: "BID_AWARDED";
+        };
+        readonly label: {
+            readonly type: "string";
+            readonly description: "Human-readable label";
+            readonly example: "Best Bid Selected";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["completed", "in_progress", "pending", "failed", "skipped"];
+            readonly description: "Current status of this step:\n- `completed`: Step finished successfully\n- `in_progress`: Step currently executing\n- `pending`: Step hasn't started yet\n- `failed`: Step errored out\n- `skipped`: Step will never execute because an earlier step failed\n";
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "When the step completed (if it has)";
+        };
+        readonly duration_ms: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Time this step took, measured from the previous step";
+        };
+        readonly chain_id: {
+            readonly type: "string";
+            readonly description: "CAIP-2 chain this step happened on (if on-chain)";
+            readonly example: "eip155:1";
+        };
+        readonly tx_hash: {
+            readonly type: "string";
+            readonly description: "Transaction hash associated with this step (if on-chain)";
+        };
+        readonly details: {
+            readonly type: "object";
+            readonly description: "Additional step-specific data (e.g. block_number, settler, reason)";
+            readonly additionalProperties: true;
+        };
+    };
+};
+declare const $ErrorResponse: {
+    readonly type: "object";
+    readonly properties: {
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error message";
+            readonly example: "Invalid request: missing required field";
+        };
+    };
+};
+declare const $CreateQuoteRequest: {
+    readonly type: "object";
+    readonly description: "Request body for opening a quote-request batch. Structurally the existing PaymentRequest\nwith `sender_auth` omitted (the spend authorization is deferred to the award call); see\nschemas/declarations/PaymentRequest/v1/schema.json.\n";
+    readonly required: readonly ["version", "request_id", "source", "destination", "fulfillment_amount", "quote_deadline", "fulfillment_deadline"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Semver-shaped declaration version (MAJOR.MINOR), locked to major 1 for v1. Producers emit\nthe canonical value exported by the bindings' Version constant.\n";
+            readonly pattern: "^1\\.[0-9]+$";
+            readonly example: "1.0";
+        };
+        readonly request_id: {
+            readonly type: "string";
+            readonly description: "Client-supplied idempotency key for this quote-request. The same request_id from the\nsame originator returns the same quote_request_id. Independent of the award-call request_id.\n";
+            readonly example: "qr-2026-04-29-001";
+        };
+        readonly source: {
+            readonly $ref: "#/components/schemas/OwnedAsset";
+        };
+        readonly destination: {
+            readonly type: "array";
+            readonly description: "Array of destination assets for the settlement agent to choose from (at least one required).";
+            readonly minItems: 1;
+            readonly items: {
+                readonly $ref: "#/components/schemas/OwnedAsset";
+            };
+        };
+        readonly fulfillment_amount: {
+            readonly type: "string";
+            readonly description: "The exact amount to be received at the destination (smallest unit, e.g. wei or cents).";
+            readonly example: "100000000";
+        };
+        readonly max_source_amount: {
+            readonly type: "string";
+            readonly description: "Optional cap on what the originator is willing to spend from source (smallest unit).\nQuotes with source_amount above this are filtered. No cap applied if omitted.\n";
+            readonly example: "101000000";
+        };
+        readonly quote_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Required. End of the collection window. After this point no new quotes are accepted.\nThe gateway injects no default and never mutates the originator-supplied body, so the\nvalue is carried through verbatim to the award call. It must be supplied and must be in\nthe future. Must be strictly earlier than fulfillment_deadline.\n";
+            readonly example: "2026-04-29T12:00:03Z";
+        };
+        readonly fulfillment_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Required. Final deadline for completing the payment. Past it the payment is cancelled and\neligible for refund. The gateway injects no default and never mutates the\noriginator-supplied body, so the value is carried through verbatim to the award call. It\nmust be supplied and must be in the future. Must be strictly later than quote_deadline.\n";
+            readonly example: "2026-04-29T12:30:00Z";
+        };
+        readonly settler_auth_required: {
+            readonly type: "object";
+            readonly description: "Policy requirements for settler authentication. Keys are policy names, values indicate if required.";
+            readonly additionalProperties: {
+                readonly type: "boolean";
+            };
+        };
+        readonly originator_auth: {
+            readonly $ref: "#/components/schemas/VerifiableCredentialAuth";
+        };
+        readonly quote_selector: {
+            readonly type: "string";
+            readonly description: "Wallet address or public key of a trusted service that auto-selects the best rate.\nLeave empty to use the default selector.\n";
+            readonly example: "0x742d35Cc6634C0532925a3b844Bc9e7595f4136";
+        };
+        readonly fulfillment_verifier: {
+            readonly type: "object";
+            readonly description: "Optional third-party service that independently verifies delivery. Leave empty for the default verifier.";
+            readonly required: readonly ["account", "endpoint"];
+            readonly properties: {
+                readonly account: {
+                    readonly type: "string";
+                    readonly description: "The wallet address or public key of the verification service";
+                    readonly example: "0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4431F";
+                };
+                readonly endpoint: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly description: "The API endpoint URL where the verification service can be reached";
+                    readonly example: "https://verifier.atum.network/api/v1/verify";
+                };
+            };
+        };
+        readonly escrow_contract_address: {
+            readonly type: "string";
+            readonly description: "Optional escrow contract address. Leave empty to use the default.";
+            readonly example: "0x742d35Cc6634C0532925a3b844Bc9e7595f4136";
+        };
+        readonly fulfillment_proxy: {
+            readonly type: "string";
+            readonly description: "Optional fulfillment-proxy contract address on the destination chain. Leave empty to use the default.";
+            readonly example: "0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4431F";
+        };
+        readonly settler_requirements: {
+            readonly type: "object";
+            readonly description: "Optional settler filtering. If whitelist is present, only whitelisted settlers may win.\nIf blacklist is present, blacklisted settlers are excluded. Both can be specified;\nblacklist takes precedence (a settler in both is rejected).\n";
+            readonly properties: {
+                readonly whitelist: {
+                    readonly type: "array";
+                    readonly description: "Settler DIDs permitted to fulfill this request (W3C DID format). If present, only these may win.";
+                    readonly minItems: 1;
+                    readonly maxItems: 100;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly pattern: "^did:[a-z][a-z0-9]*:[a-zA-Z0-9._:%-]+$";
+                    };
+                    readonly example: readonly ["did:pkh:eip155:1:0x742d35Cc6634C0532925a3b844Bc9e7595f4136"];
+                };
+                readonly blacklist: {
+                    readonly type: "array";
+                    readonly description: "Settler DIDs excluded from fulfilling this request (W3C DID format).";
+                    readonly minItems: 1;
+                    readonly maxItems: 100;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly pattern: "^did:[a-z][a-z0-9]*:[a-zA-Z0-9._:%-]+$";
+                    };
+                    readonly example: readonly ["did:pkh:eip155:1:0x892BB2e4F6b14a2B5b82Ba8d33E5925D42D4432F"];
+                };
+            };
+        };
+        readonly '@context': {
+            readonly type: "array";
+            readonly description: "Optional JSON-LD context URLs — present when the originator wraps the request in a W3C\nData Integrity envelope so a downstream verifier can recover the signer identity.\n";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly proof: {
+            readonly $ref: "#/components/schemas/DataIntegrityProof";
+        };
+        readonly verifiableCredential: {
+            readonly type: "array";
+            readonly description: "Optional document-level W3C Verifiable Credentials (e.g. KnownToAtum about the request producer).";
+            readonly items: {
+                readonly $ref: "#/components/schemas/VerifiableCredential";
+            };
+        };
+    };
+};
+declare const $DataIntegrityProof: {
+    readonly type: "object";
+    readonly description: "W3C Data Integrity proof conforming to the Data Integrity 1.0 specification.";
+    readonly required: readonly ["type", "created", "verificationMethod", "proofPurpose"];
+    readonly properties: {
+        readonly type: {
+            readonly type: "string";
+            readonly description: "Proof type identifier (e.g. EcdsaSecp256k1RecoverySignature2020).";
+            readonly example: "EcdsaSecp256k1RecoverySignature2020";
+        };
+        readonly created: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the proof was created.";
+            readonly example: "2026-04-29T12:00:00Z";
+        };
+        readonly verificationMethod: {
+            readonly type: "string";
+            readonly description: "DID URL identifying the verification method.";
+            readonly example: "did:pkh:eip155:42161:0xabc...#blockchainAccountId";
+        };
+        readonly proofPurpose: {
+            readonly type: "string";
+            readonly description: "Purpose of the proof (e.g. assertionMethod, authentication).";
+            readonly example: "assertionMethod";
+        };
+        readonly jws: {
+            readonly type: "string";
+            readonly description: "Detached JWS signature (header..signature format for ES256K-R).";
+        };
+        readonly proofValue: {
+            readonly type: "string";
+            readonly description: "Alternative to jws: base-encoded proof value.";
+        };
+    };
+};
+declare const $Quote: {
+    readonly type: "object";
+    readonly description: "One collected quote — the content-hash identifier plus the verbatim settler-signed FulfillmentQuote.";
+    readonly required: readonly ["quote_id", "fulfillment_quote"];
+    readonly properties: {
+        readonly quote_id: {
+            readonly type: "string";
+            readonly description: "Canonical content-hash of the signed quote bytes; identifies the quote server-side at\naward time. Provided as a convenience — the gateway re-derives it from\nbid_award.fulfillment_quote_json.\n";
+            readonly example: "0x4e7f...c2a1";
+        };
+        readonly fulfillment_quote: {
+            readonly type: "object";
+            readonly description: "The settler-signed FulfillmentQuote (structurally the canonical FulfillmentQuote/v1\ndeclaration at https://schemas.atum.network/declarations/FulfillmentQuote/v1), returned\nverbatim as an opaque signed document. A client recomputes quote_hash over the returned\nbytes and verifies the settler signature, then re-embeds them into\nbid_award.fulfillment_quote_json at award. quote_hash is canonicalization-based\n(URDNA2015), so it is stable across JSON key-order/whitespace normalization. The\nreturned bytes are hash-equivalent to, but not necessarily byte-identical with, what the\nsettler emitted (quotes are stored as JSONB, which normalizes on write). The gateway\nstill never re-serializes the quote through a typed struct (that renormalizes timestamp\nvalues and WOULD change quote_hash), so the Go binding exposes it as a raw JSON passthrough.\n";
+            readonly 'x-go-type': "json.RawMessage";
+        };
+    };
+};
+declare const $AwardedQuote: {
+    readonly type: "object";
+    readonly description: "A collected quote in the status response, annotated with its award linkage.";
+    readonly required: readonly ["quote_id", "fulfillment_quote"];
+    readonly properties: {
+        readonly quote_id: {
+            readonly type: "string";
+            readonly example: "0x9a3b...e8d4";
+        };
+        readonly fulfillment_quote: {
+            readonly type: "object";
+            readonly description: "The settler-signed FulfillmentQuote (structurally the canonical FulfillmentQuote/v1\ndeclaration at https://schemas.atum.network/declarations/FulfillmentQuote/v1), returned\nverbatim as an opaque signed document. A client recomputes quote_hash over the returned\nbytes and verifies the settler signature, then re-embeds them into\nbid_award.fulfillment_quote_json at award. quote_hash is canonicalization-based\n(URDNA2015), so it is stable across JSON key-order/whitespace normalization. The\nreturned bytes are hash-equivalent to, but not necessarily byte-identical with, what the\nsettler emitted (quotes are stored as JSONB, which normalizes on write). The gateway\nstill never re-serializes the quote through a typed struct (that renormalizes timestamp\nvalues and WOULD change quote_hash), so the Go binding exposes it as a raw JSON passthrough.\n";
+            readonly 'x-go-type': "json.RawMessage";
+        };
+        readonly awarded_payment_id: {
+            readonly type: "string";
+            readonly nullable: true;
+            readonly description: "payment_id if this quote was awarded; null otherwise. Under MVP single-award, at most\none quote per batch carries a non-null value.\n";
+            readonly example: "py_9876fedc-ba98-7654-3210-fedcba987654";
+        };
+    };
+};
+declare const $AwardedPayment: {
+    readonly type: "object";
+    readonly description: "A (quote_id, payment_id) pair for an awarded quote in a batch.";
+    readonly required: readonly ["quote_id", "payment_id"];
+    readonly properties: {
+        readonly quote_id: {
+            readonly type: "string";
+            readonly example: "0x9a3b...e8d4";
+        };
+        readonly payment_id: {
+            readonly type: "string";
+            readonly example: "py_9876fedc-ba98-7654-3210-fedcba987654";
+        };
+    };
+};
+declare const $QuoteRequestResponse: {
+    readonly type: "object";
+    readonly description: "Synchronous response to POST /v1/payments/quote-requests. Self-contained — the corridor\nfields are echoed at the response root so a drop-recovery client can build the award call\nwithout retaining the original request body.\n";
+    readonly required: readonly ["quote_request_id", "status"];
+    readonly properties: {
+        readonly quote_request_id: {
+            readonly type: "string";
+            readonly description: "Gateway-generated resource ID for the batch, used in subsequent status reads and awards.";
+            readonly example: "qr_a1b2c3d4-5678-90ef-1234-567890abcdef";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["collecting", "ready"];
+            readonly description: "Collection-phase outcome of the create call:\n- `ready` — collection complete; `quotes` populated. If no settler bid, this is still\n  `ready` with an empty `quotes` array (a successful \"no quotes available\" result —\n  distinct from `expired`, which only applies to collected quotes that later lapse).\n- `collecting` — the sync wait cap fired before the quote deadline; poll the status endpoint for quotes.\nThe `awarded` and `expired` lifecycle states are observed only via the status endpoint, not here.\n";
+            readonly example: "ready";
+        };
+        readonly source: {
+            readonly $ref: "#/components/schemas/OwnedAsset";
+        };
+        readonly destination: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/OwnedAsset";
+            };
+        };
+        readonly fulfillment_amount: {
+            readonly type: "string";
+            readonly example: "100000000";
+        };
+        readonly max_source_amount: {
+            readonly type: "string";
+            readonly example: "101000000";
+        };
+        readonly fulfillment_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2026-04-29T12:30:00Z";
+        };
+        readonly quote_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2026-04-29T12:00:03Z";
+        };
+        readonly quotes: {
+            readonly type: "array";
+            readonly description: "Collected quotes. Present when status is `ready` — an empty array if no settler bid.";
+            readonly items: {
+                readonly $ref: "#/components/schemas/Quote";
+            };
+        };
+    };
+};
+declare const $QuoteRequestAccepted: {
+    readonly type: "object";
+    readonly description: "Asynchronous (202) response to POST /v1/payments/quote-requests. Returns the batch handle\nplus the echoed corridor; quotes are retrieved via the status endpoint.\n";
+    readonly required: readonly ["quote_request_id", "status"];
+    readonly properties: {
+        readonly quote_request_id: {
+            readonly type: "string";
+            readonly example: "qr_a1b2c3d4-5678-90ef-1234-567890abcdef";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["collecting"];
+            readonly description: "Always `collecting` — collection is in progress server-side.";
+            readonly example: "collecting";
+        };
+        readonly source: {
+            readonly $ref: "#/components/schemas/OwnedAsset";
+        };
+        readonly destination: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/OwnedAsset";
+            };
+        };
+        readonly fulfillment_amount: {
+            readonly type: "string";
+            readonly example: "100000000";
+        };
+        readonly max_source_amount: {
+            readonly type: "string";
+            readonly example: "101000000";
+        };
+        readonly fulfillment_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2026-04-29T12:30:00Z";
+        };
+        readonly quote_deadline: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2026-04-29T12:00:03Z";
+        };
+    };
+};
+declare const $QuoteRequestStatusResponse: {
+    readonly type: "object";
+    readonly description: "Response to GET /v1/payments/quote-requests/{quoteRequestId}. The `status` enum describes\nthe quote-request batch lifecycle and is disjoint from the payment-status enum.\n";
+    readonly required: readonly ["quote_request_id", "status"];
+    readonly properties: {
+        readonly quote_request_id: {
+            readonly type: "string";
+            readonly example: "qr_a1b2c3d4-5678-90ef-1234-567890abcdef";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["collecting", "ready", "awarded", "expired"];
+            readonly description: "Derived batch lifecycle, computed at read time (not a stored state machine). Disjoint\nfrom the payment-status enum returned by the award and payment-status endpoints.\n- `collecting` — collection window in progress; `quotes` absent.\n- `ready` — collection complete; none awarded yet; either at least one quote is still\n  within its `award_deadline`, or no settler bid (empty `quotes` array — the successful\n  \"no quotes available\" result).\n- `awarded` — a quote produced a payment row; no further awards accepted (MVP).\n- `expired` — collection closed, nothing awarded, and every collected quote is now past\n  its `award_deadline` (\"quotes lapsed\"). An empty batch is `ready`, not `expired` — the\n  two are deliberately distinct (\"no quotes available\" vs \"quotes lapsed\").\n";
+            readonly example: "awarded";
+        };
+        readonly quotes: {
+            readonly type: "array";
+            readonly description: "Collected quotes with award linkage. Absent while status is `collecting`.";
+            readonly items: {
+                readonly $ref: "#/components/schemas/AwardedQuote";
+            };
+        };
+        readonly payments: {
+            readonly type: "array";
+            readonly description: "Flat list of awarded (quote_id, payment_id) pairs. At most one entry under MVP single-award.";
+            readonly items: {
+                readonly $ref: "#/components/schemas/AwardedPayment";
+            };
+        };
+    };
+};
+declare const $AwardRequest: {
+    readonly type: "object";
+    readonly description: "Request body for POST /v1/payments/awards. Carries the two originator-signed artifacts:\n`sender_auth` (Permit2 deposit authorization) and a fully-formed `bid_award` declaration.\nThe awarded quote is derived server-side from bid_award.fulfillment_quote_json — no\nexplicit quote_id on the wire.\n";
+    readonly required: readonly ["request_id", "sender_auth", "bid_award"];
+    readonly properties: {
+        readonly request_id: {
+            readonly type: "string";
+            readonly description: "Client-supplied idempotency key for this award call. Independent of the quote-request's request_id.";
+            readonly example: "award-2026-04-29-001";
+        };
+        readonly sender_auth: {
+            readonly $ref: "#/components/schemas/SenderAuth";
+        };
+        readonly bid_award: {
+            readonly $ref: "#/components/schemas/BidAward";
+        };
+    };
+};
+declare const $BidAward: {
+    readonly type: "object";
+    readonly description: "Fully-formed, originator-signed bid award. Mirrors schemas/declarations/BidAward/v1/schema.json.\n`authorization` carries the Escrow reserve-witness signature naming the chosen settler;\n`fulfillment_quote_json` is the verbatim settler-signed quote string received in the quote\nresponse (carrying the settler's proof).\n";
+    readonly required: readonly ["version", "authorization", "fulfillment_quote_json"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly pattern: "^1\\.[0-9]+$";
+            readonly description: "Semver-shaped declaration version (MAJOR.MINOR), locked to major 1 for v1. Producers emit\nthe canonical value exported by the bindings' Version constant.\n";
+            readonly example: "1.0";
+        };
+        readonly authorization: {
+            readonly $ref: "#/components/schemas/SignedMessage";
+        };
+        readonly fulfillment_quote_json: {
+            readonly type: "string";
+            readonly description: "The settler-signed FulfillmentQuote received in the quote response, forwarded verbatim.\nVerification is canonicalization-based — the settler's W3C Data Integrity proof is checked\nover the canonicalized form, and `quote_id` is derived as the canonical content-hash — so a\nJSON decode/re-encode that only changes key order or whitespace does not invalidate it.\nClients SHOULD still forward the received bytes as-is rather than rebuild the object; the\nSDK helpers do this and also expose settler-proof verification.\n";
+        };
+        readonly '@context': {
+            readonly type: "array";
+            readonly description: "Optional JSON-LD context URLs when the award is wrapped in a W3C Data Integrity envelope.";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly proof: {
+            readonly $ref: "#/components/schemas/DataIntegrityProof";
+        };
+        readonly verifiableCredential: {
+            readonly type: "array";
+            readonly description: "Optional W3C Verifiable Credentials attesting the award producer.";
+            readonly items: {
+                readonly $ref: "#/components/schemas/VerifiableCredential";
+            };
+        };
+    };
+};
+declare const $AwardResponse: {
+    readonly type: "object";
+    readonly description: "Synchronous response to POST /v1/payments/awards. The `status` field describes the payment\nlifecycle. Note there are two distinct status surfaces for a Quote-API payment, with\ndifferent vocabularies: (1) this award response (`awarding`/`completed`/…), and\n(2) the separate GET /v1/payments/{paymentId}/status endpoint you poll afterward, which\nreports the same payment under its own values (an in-progress payment reads as `pending`\nthere). Both are disjoint from the quote-request batch status on the quote-request endpoints.\n";
+    readonly required: readonly ["payment_id", "status"];
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly example: "py_9876fedc-ba98-7654-3210-fedcba987654";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["awarding", "completed", "failed", "cancelled"];
+            readonly description: "Payment lifecycle status on the award response:\n- `completed` — settlement finished within the sync wait (includes fulfillment_confirmation).\n- `awarding` — settlement still in progress when the sync cap fired (or on wait=false);\n  poll GET /v1/payments/{paymentId}/status.\n- `failed` — settlement reached a terminal failure (e.g. the settler could not fulfill, or\n  an on-chain step was rejected).\n- `cancelled` — the payment was terminated before settlement completed and will not proceed.\n`failed` and `cancelled` are terminal states surfaced here only when they occur within the\nsync wait; otherwise the response is `awarding` and the terminal state is read from the\npayment-status endpoint.\n";
+            readonly example: "completed";
+        };
+        readonly fulfillment_confirmation: {
+            readonly $ref: "#/components/schemas/FulfillmentConfirmation";
+        };
+    };
+};
+declare const $AwardAccepted: {
+    readonly type: "object";
+    readonly description: "Asynchronous (202) response to POST /v1/payments/awards — just the payment handle.";
+    readonly required: readonly ["payment_id", "status"];
+    readonly properties: {
+        readonly payment_id: {
+            readonly type: "string";
+            readonly example: "py_9876fedc-ba98-7654-3210-fedcba987654";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["awarding"];
+            readonly description: "Always `awarding` — settlement is in progress server-side.";
+            readonly example: "awarding";
+        };
+    };
+};
+
+type ApiResult<TData = any> = {
+    readonly body: TData;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly url: string;
+};
+
+declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: unknown;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}
+
+/**
+ * EVM Permit2 PermitWitnessTransferFrom deposit prehash + EIP-712 digest.
+ *
+ * Byte-for-byte counterpart of the sibling Go encoder (deposit_encoder.go,
+ * `EscrowDepositEncoder`). This is the sender-authorization scheme the Atum
+ * protocol uses on EVM chains: it authorizes Permit2 to move tokens into the
+ * escrow contract, with a DepositWitness {reserver, releaser}.
+ *
+ * The sender signs the digest this produces, and the serialized prehash travels
+ * to the settler as `message_prehash`, so BOTH the digest and the JSON
+ * serialization (top-level key order, and `chainId` as a lowercase hex string
+ * matching the Go encoder's %#x form) must stay pinned to the Go output. See
+ * deposit-encoder.test.ts.
+ */
+/**
+ * The Permit2 contract address deployed at the same address on all supported
+ * EVM chains; the EIP-712 domain verifyingContract for PermitWitnessTransferFrom.
+ */
+declare const PERMIT2_CONTRACT_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+interface PermitWitnessTransferFromParams {
+    /** EIP-155 chain ID. */
+    chainId: number;
+    /** The Permit2 contract (PERMIT2_CONTRACT_ADDRESS). */
+    verifyingContract: string;
+    /** TokenPermissions: source token + amount (smallest units, decimal string). */
+    token: string;
+    amount: string;
+    /** The escrow contract address (spender). */
+    spender: string;
+    nonce: bigint;
+    deadline: bigint;
+    /** DepositWitness (V3): reserver (quote selector) + releaser (fulfillment verifier). */
+    reserver: string;
+    releaser: string;
+}
+/**
+ * Build the structured prehash for PermitWitnessTransferFrom. The shape is a
+ * direct argument set for `wallet.signTypedData(domain, types, message)`:
+ *  - `domain` carries only Permit2's on-chain EIP712Domain fields (name,
+ *    chainId, verifyingContract; no `version`, no `salt`).
+ *  - `types` omits an EIP712Domain entry (ethers derives it from the domain
+ *    object's keys and rejects an explicit one).
+ *  - `chainId` is emitted as a lowercase hex string to match the Go encoder's
+ *    %#x serialization and the settler's `message_prehash` contract; the EIP-712
+ *    digest itself is invariant to the number-vs-hex representation.
+ */
+declare function createPermitWitnessTransferFromPrehash(params: PermitWitnessTransferFromParams): {
+    types: {
+        PermitWitnessTransferFrom: {
+            name: string;
+            type: string;
+        }[];
+        TokenPermissions: {
+            name: string;
+            type: string;
+        }[];
+        DepositWitness: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: string;
+    domain: {
+        name: string;
+        chainId: string;
+        verifyingContract: string;
+    };
+    message: {
+        permitted: {
+            token: string;
+            amount: string;
+        };
+        spender: string;
+        nonce: string;
+        deadline: string;
+        witness: {
+            reserver: string;
+            releaser: string;
+        };
+    };
+};
+/**
+ * Hash a PermitWitnessTransferFrom prehash into its EIP-712 digest (0x-prefixed
+ * 32-byte hex). Accepts the object returned by
+ * createPermitWitnessTransferFromPrehash (or an equivalent parsed from JSON).
+ */
+declare function hashPermitWitnessTransferFrom(prehash: {
+    domain: any;
+    types: any;
+    message: any;
+}): string;
+
+/**
+ * EVM Permit2 PermitWitnessTransferFrom sender-auth scheme.
+ *
+ * The encoder now lives in the shared @atum-labs/evm-escrow-encoding package
+ * (byte-parity with the Go EscrowDepositEncoder). This module re-exports it so
+ * the pg-client public API and the EVM chain adapter keep the same import
+ * surface.
+ */
+
+/** Hash a request ID string to a 32-byte identifier. V1 legacy, unused by the V3 deposit witness. */
+declare function hashRequestId(requestId: string): string;
+
+/**
+ * Masks a chain ID to 4 bytes for Tron TIP-712 compatibility.
+ *
+ * Tron's EIP-712 implementation uses a 4-byte chain ID (uint32),
+ * unlike EVM which uses the full numeric value.
+ *
+ * @param chainId - The raw chain ID
+ * @returns The chain ID masked to 32 bits (unsigned)
+ */
+declare function maskChainId(chainId: number): number;
+
+/**
+ * Tron address normalization, byte-for-byte faithful to the Go gateway
+ * (tvm_address.go `NormalizeAddress` / `ConvertBase58ToHex`). This is the
+ * originator side where a fat-fingered "T…" address originates, so it must
+ * reject exactly what the on-chain verifier rejects — otherwise a typo'd or
+ * malformed address would be signed here and only fail downstream.
+ *
+ * Shared by the paymentId derivation (payment-id.ts) and the Permit2 deposit
+ * encoder (deposit-encoder.ts), and re-exported for SDK consumers.
+ */
+/**
+ * Convert a Tron base58 address (e.g. "TYaKH9ApqbdftVGSnTMPVL9kp1S5AQBQSs") to
+ * its 21-byte hex form (0x41 mainnet prefix ‖ 20-byte address), without a `0x`
+ * prefix. `normalizeAddress` then strips the 0x41 to get the bare 20-byte form
+ * that TIP-712 hashes.
+ *
+ * A Tron base58 address is base58check: 0x41 ‖ 20-byte address ‖ 4-byte
+ * checksum (25 bytes), where the checksum is the first 4 bytes of
+ * sha256(sha256(0x41 ‖ address)). The checksum MUST be validated: the Go
+ * gateway (address.Base58ToAddress) rejects a bad checksum, so accepting one
+ * here would sign a wrong/typo'd address that only fails on-chain later.
+ */
+declare function base58ToHex(base58Address: string): string;
+/**
+ * Normalize a Tron address (base58, or hex with an optional 0x / 0x41 prefix) to
+ * the canonical TIP-712 hex form: 0x-prefixed, 20 bytes (40 hex chars). This is
+ * the wire format `wallet.signTypedData` expects for an `address`.
+ */
+declare function normalizeAddress(address: string): string;
+
+/**
+ * TVM (Tron) Permit2 PermitWitnessTransferFrom deposit prehash + TIP-712 digest.
+ *
+ * Byte-for-byte counterpart of the sibling Go encoder (deposit_encoder.go,
+ * `EscrowDepositEncoder`). Same shape as the EVM deposit encoder, with the
+ * Tron-specific normalization applied here: the chainId is masked to its lower
+ * 4 bytes (Tron's TIP-712 domain uses a uint32 chainId) and every address is
+ * converted from base58 to bare 20-byte hex (0x41 prefix stripped).
+ *
+ * The sender signs the digest this produces, and the serialized prehash travels
+ * to the settler as `message_prehash`, so BOTH the digest and the JSON
+ * serialization (key order, and `chainId` as a lowercase hex string) must stay
+ * pinned to the Go output. See deposit-encoder.test.ts.
+ *
+ * V3: DepositWitness is `{reserver, releaser}` — `requestId` is gone.
+ */
+/**
+ * Parameters for a TVM V3 Permit2 deposit prehash. Addresses may be base58 or
+ * hex; they are normalized to bare 20-byte hex internally.
+ */
+interface TvmPermitWitnessTransferFromParams {
+    chainId: number;
+    permit2Address: string;
+    tokenAddress: string;
+    amount: string;
+    spenderAddress: string;
+    nonce: bigint;
+    deadline: bigint;
+    reserverAddress: string;
+    releaserAddress: string;
+}
+/**
+ * Build the V3 TIP-712 prehash for a Permit2 deposit on Tron, shaped for direct
+ * `wallet.signTypedData(domain, types, message)` consumption:
+ *  - `domain` carries only name, chainId (pre-masked, lowercase hex string),
+ *    verifyingContract — Permit2's on-chain EIP712Domain has no version/salt.
+ *  - `types` omits an EIP712Domain entry (ethers derives it from the domain keys).
+ *  - all addresses are hex-normalized (0x41 prefix stripped).
+ */
+declare function createTvmPermitWitnessTransferFromPrehash(params: TvmPermitWitnessTransferFromParams): {
+    types: {
+        PermitWitnessTransferFrom: {
+            name: string;
+            type: string;
+        }[];
+        TokenPermissions: {
+            name: string;
+            type: string;
+        }[];
+        DepositWitness: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: string;
+    domain: {
+        name: string;
+        chainId: string;
+        verifyingContract: string;
+    };
+    message: {
+        permitted: {
+            token: string;
+            amount: string;
+        };
+        spender: string;
+        nonce: string;
+        deadline: string;
+        witness: {
+            reserver: string;
+            releaser: string;
+        };
+    };
+};
+/**
+ * Hash a TVM Permit2 prehash into its TIP-712 digest (0x-prefixed 32-byte hex).
+ * The Tron-specific work (chainId mask, address normalization) already happened
+ * in createTvmPermitWitnessTransferFromPrehash.
+ */
+declare function hashTvmPermitWitnessTransferFrom(prehash: {
+    domain: any;
+    types: any;
+    message: any;
+}): string;
+
+/**
+ * Encodes a bigint as 8-byte little-endian Uint8Array.
+ * This matches Solana/Borsh convention and Rust's `to_le_bytes()`.
+ */
+declare function encodeU64LE(value: bigint): Uint8Array;
+
+declare const MAX_VALID_SLOT: number;
+
+/**
+ * Solana deposit message sender auth scheme implementation.
+ *
+ * This module provides utilities for creating and hashing Solana deposit
+ * authorization messages for the Atum payment gateway.
+ *
+ * The deposit message is a 199-byte binary structure hashed with Keccak-256:
+ *   keccak256("deposit" || payment_id[32] || depositor[32] || mint[32] ||
+ *             amount[8,LE] || reserver[32] || releaser[32] ||
+ *             nonce[8,LE] || issued_at[8,LE] || deadline[8,LE])
+ *
+ * encodeU64LE, generateSolanaNonce (generateNonce), and MAX_VALID_SLOT are
+ * imported from the shared @atum-labs/solana-escrow-encoding package and
+ * re-exported here to preserve the public API. The V1 hashSolanaDeposit,
+ * base58ToBytes, payment-id generation, and prehash creation stay local: the
+ * package has no non-domain-separated V1 hash, and the local base58/hex helpers
+ * carry the exact error messages the client tests assert. The V3 deposit hash
+ * already delegates to the package (hashSolanaDepositV3 → computeDepositHash).
+ *
+ * The canonical reference is the @atum-labs/solana-escrow-encoding package in
+ * this repo (contracts/svm/escrow-encoding), the TypeScript sibling of the
+ * on-chain Solana escrow program and the Go signing library.
+ */
+
+/** Replay horizon in seconds — deposit deadline must be within this window of issuedAt. */
+declare const REPLAY_HORIZON_SECS = 128;
+/** Total number of replay-protection buckets. */
+declare const TOTAL_BUCKETS = 131072;
+/** Exact byte size of a serialized deposit message (7 + 32*5 + 8*3). */
+declare const DEPOSIT_MESSAGE_SIZE = 199;
+/**
+ * Parameters for constructing a Solana deposit authorization message.
+ */
+interface SolanaDepositParams {
+    /** Base58 Solana public key of the depositor. */
+    depositor: string;
+    /** Base58 SPL token mint address. */
+    mint: string;
+    /** Token amount in smallest units (uint64). */
+    amount: bigint;
+    /** Base58 public key authorized to reserve funds (quote selector). */
+    reserver: string;
+    /** Base58 public key authorized to release/refund funds (fulfillment verifier). */
+    releaser: string;
+    /** Replay protection nonce (uint64). */
+    nonce: bigint;
+    /** Unix timestamp (seconds) when the authorization was created (uint64). */
+    issuedAt: bigint;
+    /** Unix timestamp (seconds) when the deposit authorization expires (uint64). */
+    deadline: bigint;
+    /** Original request ID string (used for payment ID generation). */
+    requestId: string;
+}
+/**
+ * Decodes a Base58-encoded Solana public key to a 32-byte Uint8Array. Kept local
+ * rather than using Pubkey.fromBase58: the client tests assert this exact
+ * "Invalid Solana public key length" message.
+ */
+declare function base58ToBytes(address: string): Uint8Array;
+/**
+ * Converts a Uint8Array to a 0x-prefixed hex string.
+ */
+declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Converts a hex string (with or without 0x prefix) to a Uint8Array.
+ */
+declare function hexToBytes(hex: string): Uint8Array;
+/**
+ * Generates a 32-byte payment ID from the request ID and deposit parameters.
+ *
+ * Formula: keccak256(requestId_str || "deposit" || depositor[32] ||
+ *                    amount[8,LE] || reserver[32] || releaser[32] ||
+ *                    nonce[8,LE] || issuedAt[8,LE] || deadline[8,LE])
+ *
+ * TODO: the V3 gateway simplified this to
+ * just keccak256(requestID). When we migrate to v3, this function should change
+ * to: return keccak256(toUtf8Bytes(requestId)); and the params argument can be
+ * removed. The gateway reads payment_id from the prehash so both approaches work.
+ *
+ * @returns 0x-prefixed hex string (32 bytes)
+ */
+declare function generateSolanaPaymentId(requestId: string, params: Omit<SolanaDepositParams, 'requestId'>): string;
+/**
+ * Prehash structure for a Solana deposit message.
+ * Uses base58 addresses and string numbers for settler parsing.
+ */
+interface SolanaDepositPrehash {
+    payment_id: string;
+    depositor: string;
+    mint: string;
+    amount: string;
+    reserver: string;
+    releaser: string;
+    nonce: string;
+    issued_at: string;
+    deadline: string;
+}
+/**
+ * Creates the JSON prehash structure for a Solana deposit message.
+ * The prehash contains base58 addresses and string numbers, matching the
+ * format the settler agent expects in `message_prehash`.
+ *
+ * @param paymentId 0x-prefixed hex string (32 bytes) from generateSolanaPaymentId()
+ * @param params The deposit parameters
+ * @returns The structured prehash object
+ */
+declare function createSolanaDepositPrehash(paymentId: string, params: SolanaDepositParams): SolanaDepositPrehash;
+/**
+ * Computes the keccak256 deposit hash from a prehash structure.
+ *
+ * Formula: keccak256("deposit" || payment_id[32] || depositor[32] || mint[32] ||
+ *                    amount[8,LE] || reserver[32] || releaser[32] ||
+ *                    nonce[8,LE] || issued_at[8,LE] || deadline[8,LE])
+ *
+ * Total input: 199 bytes (7 + 32*5 + 8*3)
+ *
+ * TODO: Replace with computeDepositHash from @atum-labs/solana-escrow-encoding once public.
+ * The bindings version uses EscrowDepositParams with Pubkey objects instead of base58 strings,
+ * so this function will need to convert from prehash strings to the bindings' types.
+ *
+ * @param prehash The structured prehash from createSolanaDepositPrehash()
+ * @returns 0x-prefixed hex string (32 bytes)
+ */
+declare function hashSolanaDeposit(prehash: SolanaDepositPrehash): string;
+/**
+ * Generates a valid nonce for Solana replay protection (upper 32 bits: random
+ * bucket, lower 8 bits: random slot 0..MAX_VALID_SLOT). Delegates to the shared
+ * package's generateNonce (which uses a CSPRNG with rejection sampling).
+ *
+ * @returns A bigint nonce suitable for the deposit message
+ */
+declare function generateSolanaNonce(): bigint;
+
+/**
+ * Payment Gateway TypeScript Client
+ *
+ * Main entry point that combines auto-generated API client code with
+ * manually-crafted utilities for the Atum payment gateway.
+ */
+
+declare const PAYMENT_REQUEST_VERSION = "1.0";
+
+/**
+ * Applies a SenderSigner to an unsigned PaymentRequest, signing every entry in
+ * signed_messages (filling each signature, and payload.delegate_signer where the
+ * chain requires it). Mirrors the CLI signing step for SDK consumers. The gateway
+ * verifies every signed message, so a multi-message request must have them all
+ * signed; the common single-message case is signed exactly as before.
+ */
+declare function signPaymentRequest(request: PaymentRequest, signer: SenderSigner): Promise<PaymentRequest>;
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+declare const defaultGateway: string;
+/**
+ * Default quote-collection window for {@link PaymentGatewayClient.prepareQuoteRequest}
+ * (`quote_deadline = now + this`, in seconds). Chosen as the largest value that still
+ * lands under the gateway's `quote_sync_wait_seconds` cap (5s): a sync (`?wait=true`)
+ * request holds for `min(quote_deadline − receipt, cap)`, so ≤5s returns `ready` with
+ * quotes inline while ≥6s returns a poll-instead `collecting`. 5s also gives the widest
+ * collection window under that cap — enough to catch slower / backup settlers, where a
+ * shorter window can drop them — plus headroom against client↔gateway clock skew. A
+ * caller on a badly-skewed clock can still pass a larger `quoteDeadlineSeconds`.
+ */
+declare const DEFAULT_QUOTE_DEADLINE_SECONDS = 5;
+/** Default settlement horizon (`fulfillment_deadline = now + this`, seconds); shared by both request builders. */
+declare const DEFAULT_FULFILLMENT_DEADLINE_SECONDS = 3600;
+/**
+ * Default `quote_deadline` the single-shot payment path ({@link PaymentGatewayClient.preparePaymentRequest})
+ * stamps (seconds) when the caller passes no `quoteDeadlineSeconds`. Higher than the
+ * quote-request default because the payment path is not bound by the quote sync-wait cap.
+ */
+declare const DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS = 10;
+/**
+ * Extended PaymentGatewayClient with convenience methods
+ */
+declare class PaymentGatewayClient extends PaymentGatewayClient$1 {
+    private baseUrl;
+    constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor);
+    /**
+     * Fetches chain defaults from the payment gateway.
+     *
+     * @param chainId The CAIP-2 chain identifier (e.g., "eip155:42161")
+     * @returns The chain defaults including escrow, quote selector, and fulfillment verifier
+     */
+    fetchChainDefaults(chainId: string): Promise<ChainDefaults>;
+    /**
+     * Prepares a payment request with defaults, ready for signing.
+     *
+     * @param params Payment parameters
+     * @returns A complete PaymentRequest object without the signature
+     */
+    preparePaymentRequest(params: {
+        depositor: string;
+        fulfillmentAmount: string;
+        sourceAsset: string;
+        destinationAccount: string;
+        destinationAsset: string;
+        maxSourceAmount?: string;
+        requestId?: string;
+        requestIdPrefix?: string;
+        settlerRequirements?: {
+            whitelist?: string[];
+            blacklist?: string[];
+        };
+        deadlineSeconds?: number;
+        quoteDeadlineSeconds?: number;
+        fulfillmentDeadlineSeconds?: number;
+        /** Solana-only: override the RPC used to read the cluster clock for issued_at. */
+        solanaRpcUrl?: string;
+    }): Promise<PaymentRequest>;
+    /**
+     * Prepares a quote-request body (`CreateQuoteRequest`), ready to POST to
+     * `/v1/payments/quote-requests`. This is the quote-phase counterpart to
+     * `preparePaymentRequest`: it builds the same corridor shape but **without
+     * `sender_auth`** — quote-time is the unauthenticated browse step, so no
+     * signing (and no private key) is required. The spend authorization arrives
+     * later, at the award call.
+     *
+     * Both deadlines are populated here because the gateway requires them and
+     * injects no defaults — it never mutates the originator-supplied body.
+     * `quote_deadline` bounds the collection window (default
+     * `DEFAULT_QUOTE_DEADLINE_SECONDS`); `fulfillment_deadline` bounds settlement
+     * (default `DEFAULT_FULFILLMENT_DEADLINE_SECONDS`). `quote_deadline` must be
+     * strictly earlier than `fulfillment_deadline` (enforced server-side; guarded
+     * here for a clear client-side error).
+     *
+     * `quote_deadline` is stamped client-side and the gateway rejects it unless it
+     * is strictly in the gateway's future, so a caller whose clock may lag the
+     * gateway should pass a larger `quoteDeadlineSeconds` (see
+     * `DEFAULT_QUOTE_DEADLINE_SECONDS` for why the default is what it is).
+     *
+     * Like `preparePaymentRequest`, this fetches the source/destination chain
+     * defaults and populates the SAME contract fields (`escrow_contract_address`,
+     * `quote_selector`, `fulfillment_verifier`, `fulfillment_proxy`). These are not
+     * optional in practice: the gateway requires `fulfillment_verifier` to build the
+     * QuoteRequested event it broadcasts to settlers, so the quote-request body
+     * must carry the identical contract fields the payment flow does. The ONLY
+     * field this drops relative to `preparePaymentRequest` is `sender_auth`, which
+     * is supplied at award time (quote-time is unauthenticated — no signing, no
+     * private key).
+     *
+     * @param params Quote-request parameters
+     * @returns A complete `CreateQuoteRequest` body (no signature step needed)
+     */
+    prepareQuoteRequest(params: {
+        depositor: string;
+        fulfillmentAmount: string;
+        sourceAsset: string;
+        destinationAccount: string;
+        destinationAsset: string;
+        maxSourceAmount?: string;
+        requestId?: string;
+        requestIdPrefix?: string;
+        settlerRequirements?: {
+            whitelist?: string[];
+            blacklist?: string[];
+        };
+        quoteDeadlineSeconds?: number;
+        fulfillmentDeadlineSeconds?: number;
+    }): Promise<CreateQuoteRequest>;
+}
+
+export { $AuthorizationResult, $AwardAccepted, $AwardRequest, $AwardResponse, $AwardedPayment, $AwardedQuote, $BidAward, $CreateQuoteRequest, $DataIntegrityProof, $ErrorResponse, $FulfillmentConfirmation, $GetPaymentStatusResponse, type $OpenApiTs, $OwnedAsset, $PaymentBlockchainContext, $PaymentError, $PaymentRequest, $PaymentResponse, $PaymentSummary, $PaymentTimelineResponse, $PreparePaymentRequest, $PreparePaymentResponse, $Quote, $QuoteRequestAccepted, $QuoteRequestResponse, $QuoteRequestStatusResponse, $ResolvePaymentResponse, $SenderAuth, $SenderAuthMessageScheme, $SignedMessage, $TimelineError, $TimelineStep, $VerifiableCredential, $VerifiableCredentialAuth, ApiError, type ApiRequestOptions, type ApiResult, type AuthorizationResult, AuthorizationsService, type AuthorizePaymentData, type AuthorizePaymentResponse, type AwardAccepted, type AwardQuoteData, type AwardQuoteResponse, type AwardRequest, type AwardResponse, type AwardedPayment, type AwardedQuote, type BidAward, CancelError, CancelablePromise, type CreateQuoteRequest, type CreateQuoteRequestData, type CreateQuoteRequestResponse, DEFAULT_FULFILLMENT_DEADLINE_SECONDS, DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS, DEFAULT_QUOTE_DEADLINE_SECONDS, DEPOSIT_MESSAGE_SIZE, type DataIntegrityProof, type ErrorResponse, type FulfillmentConfirmation, type GetPaymentStatusData, type GetPaymentStatusResponse, type GetPaymentStatusResponse2, type GetPaymentTimelineData, type GetPaymentTimelineResponse, type GetQuoteRequestStatusData, type GetQuoteRequestStatusResponse, type HealthCheckResponse, HealthService, Interceptors, MAX_VALID_SLOT, type OnCancel, OpenAPI, type OpenAPIConfig, type OwnedAsset, PAYMENT_REQUEST_VERSION, PERMIT2_CONTRACT_ADDRESS, type PaymentBlockchainContext, type PaymentError, PaymentGatewayClient, type PaymentRequest, type PaymentResponse, type PaymentSummary, type PaymentTimelineResponse, PaymentsService, type PermitWitnessTransferFromParams, type PreparePaymentData, type PreparePaymentRequest, type PreparePaymentResponse, type PreparePaymentResponse2, type Quote, type QuoteRequestAccepted, type QuoteRequestResponse, type QuoteRequestStatusResponse, QuoteRequestsService, REPLAY_HORIZON_SECS, RawSenderSigner, type ResolvePaymentData, type ResolvePaymentResponse, type ResolvePaymentResponse2, type SenderAuth, type SenderAuthMessageScheme, type SenderSignature, type SenderSigner, type SenderSignerOptions, type SignedMessage, type SolanaDepositParams, type SolanaDepositPrehash, type SubmitPaymentData, type SubmitPaymentResponse, TOTAL_BUCKETS, type TimelineError, type TimelineStep, type TurnkeyConfig, TurnkeySenderSigner, type TvmPermitWitnessTransferFromParams, type VerifiableCredential, type VerifiableCredentialAuth, base58ToBytes, base58ToHex, bytesToHex, createPermitWitnessTransferFromPrehash, createSenderSigner, createSolanaDepositPrehash, createTvmPermitWitnessTransferFromPrehash, defaultGateway, type domain, encodeU64LE, type error_code, generateSolanaNonce, generateSolanaPaymentId, hashPermitWitnessTransferFrom, hashRequestId, hashSolanaDeposit, hashTvmPermitWitnessTransferFrom, hexToBytes, maskChainId, normalizeAddress, resolveTurnkeyAddresses, signPaymentRequest, type status, type status2, type status3, type status4, type status5, type status6, type status7, type status8, type status9 };