@distilled.cloud/coinbase 1.0.0-rc.8 → 1.0.0-rc.9

package/lib/services/cdp.d.ts

@@ -14,6 +14,10 @@ export interface EndUserEvmAccount {
     address: string;
     /** The date and time when the account was created, in ISO 8601 format. */
     createdAt: string;
+    /** The date and time when the account's private key was first exported, in ISO 8601 format. This is set on the first export and preserved on subsequent exports; it is not updated on re-export. */
+    exportedAt?: string | null;
+    /** The date and time when the account's key was ejected (marked for deletion), in ISO 8601 format. Populated when the account has been ejected. The account record remains queryable after this timestamp is set; it reflects when ejection was requested, not when the key material is purged. */
+    ejectedAt?: string | null;
 }
 export declare const EndUserEvmAccount: S.Schema<EndUserEvmAccount>;
 export interface AddEndUserEvmAccountResponse {
@@ -55,12 +59,663 @@ export interface EndUserSolanaAccount {
     address: string;
     /** The date and time when the account was created, in ISO 8601 format. */
     createdAt: string;
+    /** The date and time when the account's private key was first exported, in ISO 8601 format. This is set on the first export and preserved on subsequent exports; it is not updated on re-export. */
+    exportedAt?: string | null;
+    /** The date and time when the account's key was ejected (marked for deletion), in ISO 8601 format. Populated when the account has been ejected. The account record remains queryable after this timestamp is set; it reflects when ejection was requested, not when the key material is purged. */
+    ejectedAt?: string | null;
 }
 export declare const EndUserSolanaAccount: S.Schema<EndUserSolanaAccount>;
 export interface AddEndUserSolanaAccountResponse {
     solanaAccount: EndUserSolanaAccount;
 }
 export declare const AddEndUserSolanaAccountResponse: S.Schema<AddEndUserSolanaAccountResponse>;
+/** Optional metadata as key-value pairs. Use this to store additional structured information on a resource, such as customer IDs, order references, or any application-specific data. Up to 10 key/value pairs may be provided. Keys and values are both strings. Keys must be ≤ 40 characters; values must be ≤ 500 characters. */
+export type Metadata = {
+    [key: string]: string | undefined;
+};
+export declare const Metadata: S.Schema<Metadata>;
+/** Customer-facing display data for a payment operation, shown to the payer. */
+export interface OperationCustomerDisplay {
+    /** A short reference code for this payment operation, visible to the payer. */
+    referenceCode?: string;
+}
+export declare const OperationCustomerDisplay: S.Schema<OperationCustomerDisplay>;
+export interface AuthorizeCoinbasePaymentSessionRequest {
+    /** The unique identifier of the payment session to authorize via Coinbase. */
+    paymentSessionId: string;
+    metadata?: Metadata;
+    /** Optional customer-facing display data for this authorization, shown to the payer. Falls back to the session's `orderCode` when `referenceCode` is omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+    /** An optional merchant-provided internal identifier for this Coinbase authorization, from the merchant's own system—not visible to the payer. */
+    externalReferenceId?: string;
+}
+export declare const AuthorizeCoinbasePaymentSessionRequest: S.Schema<AuthorizeCoinbasePaymentSessionRequest>;
+/** The current status of a payment action (authorization, capture, void, or refund). */
+export type PaymentActionStatus = "pending" | "succeeded" | "failed";
+export declare const PaymentActionStatus: any;
+/** An error that occurred during a payment operation. */
+export interface PaymentError {
+    /** A machine-readable error code. */
+    code?: string;
+    /** A human-readable description of the error. */
+    message?: string;
+    /** The UTC ISO 8601 timestamp at which the error occurred. */
+    occurredAt?: string;
+}
+export declare const PaymentError: S.Schema<PaymentError>;
+/** The blockchain network supported for payment session sources. Testnet networks are only available in sandbox environments. */
+export type PaymentSourceNetwork = "arbitrum" | "arbitrum-sepolia" | "avalanche" | "base" | "base-sepolia" | "ethereum" | "ethereum-sepolia" | "optimism" | "optimism-sepolia" | "polygon" | "polygon-amoy";
+export declare const PaymentSourceNetwork: any;
+/** A blockchain wallet address used as a payment source. */
+export interface PaymentSourceWallet {
+    /** The blockchain address of the payer. */
+    address: string;
+    /** The blockchain network for the payment. */
+    network?: PaymentSourceNetwork;
+    /** The asset used for the payment. */
+    asset?: string;
+}
+export declare const PaymentSourceWallet: S.Schema<PaymentSourceWallet>;
+/** A Coinbase account authenticated via OAuth, used as a payment source. */
+export interface PaymentSourceCoinbase {
+    /** The unique identifier of the payer within Coinbase. */
+    coinbaseUserId: string;
+}
+export declare const PaymentSourceCoinbase: S.Schema<PaymentSourceCoinbase>;
+/** The source of the payment. Can be either an onchain wallet address or a Coinbase account authenticated via OAuth. */
+export type PaymentSessionSource = PaymentSourceWallet | PaymentSourceCoinbase;
+export declare const PaymentSessionSource: S.Schema<PaymentSessionSource>;
+/** An onchain transaction associated with a payment action. */
+export interface OnchainTransaction {
+    /** The blockchain transaction hash. */
+    transactionHash: string;
+    /** The blockchain network the transaction occurred on. */
+    network: PaymentSourceNetwork;
+}
+export declare const OnchainTransaction: S.Schema<OnchainTransaction>;
+/** The onchain transactions associated with this authorization. */
+export type AuthorizationOnchainTransactionsList = Array<OnchainTransaction>;
+export declare const AuthorizationOnchainTransactionsList: S.Schema<AuthorizationOnchainTransactionsList>;
+/** A hold placed on the payer's funds. Once authorized, the merchant can capture (collect) the funds. Only one authorization is allowed per session. */
+export interface Authorization {
+    /** The unique identifier of the authorization. */
+    authorizationId?: string;
+    /** The ID of the payment session this authorization belongs to. */
+    paymentSessionId?: string;
+    /** The current status of the authorization. */
+    status?: PaymentActionStatus;
+    /** A decimal representation of the authorized amount, denominated in the session's `asset`. */
+    amount?: string;
+    error?: PaymentError;
+    /** A human-readable message describing the outcome or status for display. Returned for x402 authorizations; omitted for other authorization flows unless documented otherwise. */
+    message?: string;
+    metadata?: Metadata;
+    /** A merchant-provided internal identifier for this authorization, from the merchant's own system—not visible to the payer. Present only when supplied on the authorization request. */
+    externalReferenceId?: string;
+    /** Customer-facing display data for this authorization, shown to the payer. Present when supplied on the authorization request or when the session's `orderCode` fallback applies; otherwise omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+    /** The payer for this authorization. For wallet authorizations, this is the blockchain address that signed the payloads. For Coinbase authorizations, this is the authenticated Coinbase account. This value is also reflected on the parent payment session's `source` field after a successful authorization. */
+    source?: PaymentSessionSource;
+    /** The onchain transactions associated with this authorization. */
+    onchainTransactions?: AuthorizationOnchainTransactionsList;
+    /** The UTC ISO 8601 timestamp at which the authorization was created. */
+    createdAt?: string;
+    /** The UTC ISO 8601 timestamp at which the authorization was last updated. */
+    updatedAt?: string;
+}
+export declare const Authorization: S.Schema<Authorization>;
+/** A processed onchain payload containing the payload ID and the payer's signature or transaction hash. The `signature` value depends on the original payload `type`: - `eip3009` / `permit2` / `spend_permission` — a hex-encoded signature from `eth_signTypedData_v4`. - `erc20_approval` — a hex-encoded transaction hash from `eth_sendTransaction`. */
+export interface OnchainSignedPayload {
+    /** The unique identifier of the signed payload. */
+    payloadId?: string;
+    /** The hex-encoded output from processing the payload. For `eip3009`, `permit2`, and `spend_permission` types, this is the cryptographic signature returned by `eth_signTypedData_v4`. For `erc20_approval` types, this is the transaction hash returned by `eth_sendTransaction`. */
+    signature?: string;
+}
+export declare const OnchainSignedPayload: S.Schema<OnchainSignedPayload>;
+/** The processed payloads from the payer, corresponding to the payloads in the selected authorization option. */
+export type AuthorizeWalletPaymentSessionRequestSignedPayloadsList = Array<OnchainSignedPayload>;
+export declare const AuthorizeWalletPaymentSessionRequestSignedPayloadsList: S.Schema<AuthorizeWalletPaymentSessionRequestSignedPayloadsList>;
+export interface AuthorizeWalletPaymentSessionRequest {
+    /** The unique identifier of the payment session to authorize. */
+    paymentSessionId: string;
+    /** The identifier of the chosen authorization option. Must match an `optionId` from the wallet authorization options response. */
+    optionId: string;
+    /** The processed payloads from the payer, corresponding to the payloads in the selected authorization option. */
+    signedPayloads: AuthorizeWalletPaymentSessionRequestSignedPayloadsList;
+    metadata?: Metadata;
+    /** Optional customer-facing display data for this authorization, shown to the payer. Falls back to the session's `orderCode` when `referenceCode` is omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+    /** An optional merchant-provided internal identifier for this wallet authorization, from the merchant's own system—not visible to the payer. */
+    externalReferenceId?: string;
+}
+export declare const AuthorizeWalletPaymentSessionRequest: S.Schema<AuthorizeWalletPaymentSessionRequest>;
+export interface AuthorizeX402PaymentSessionRequest {
+    /** The unique identifier of the payment session to authorize with x402. */
+    paymentSessionId: string;
+}
+export declare const AuthorizeX402PaymentSessionRequest: S.Schema<AuthorizeX402PaymentSessionRequest>;
+export interface CancelPaymentSessionRequest {
+    /** The unique identifier of the payment session to cancel. */
+    paymentSessionId: string;
+    /** The reason for cancelling the payment session. */
+    cancellationReason?: string;
+}
+export declare const CancelPaymentSessionRequest: S.Schema<CancelPaymentSessionRequest>;
+/** The blockchain network supported for payment session targets. Testnet networks are only available in sandbox environments. */
+export type PaymentTargetNetwork = "base" | "base-sepolia";
+export declare const PaymentTargetNetwork: any;
+/** A blockchain wallet address used as a payment target (merchant recipient). */
+export interface PaymentTargetWallet {
+    /** The blockchain address of the recipient. */
+    address: string;
+    /** The blockchain network for the payment. */
+    network?: PaymentTargetNetwork | (string & {});
+}
+export declare const PaymentTargetWallet: S.Schema<PaymentTargetWallet>;
+/** The Account specific details for the transfer. */
+export interface TransfersAccount {
+    /** The ID of the Account. */
+    accountId: string;
+    /** The asset symbol. Supported values are `usdc`, `eurc`, `usd`, and `eur`. */
+    asset: string;
+}
+export declare const TransfersAccount: S.Schema<TransfersAccount>;
+/** The target of the payment. */
+export type PaymentSessionTarget = PaymentTargetWallet | TransfersAccount;
+export declare const PaymentSessionTarget: S.Schema<PaymentSessionTarget>;
+/** Deadlines for each stage of the payment session lifecycle. All fields are optional; when omitted from a create request, the following defaults apply: `authorizationExpiresAt` = now + 1 day, `captureExpiresAt` = now + 7 days, `refundExpiresAt` = now + 30 days. Expiries must satisfy `authorizationExpiresAt` ≤ `captureExpiresAt` ≤ `refundExpiresAt`. The API returns a 400 error if this constraint is violated. Each deadline acts as a guard — after it passes, the corresponding action is rejected, but the session remains in its current status. No automatic state transitions occur; the merchant must take explicit action (e.g., cancel or void) to move the session to a terminal state. */
+export interface PaymentExpiries {
+    /** The UTC ISO 8601 timestamp after which authorization attempts are rejected. Defaults to now + 1 day if omitted. The session remains in its current pre-authorization status; the merchant must explicitly cancel the session. */
+    authorizationExpiresAt?: string;
+    /** The UTC ISO 8601 timestamp after which capture attempts are rejected. Defaults to now + 7 days if omitted. The session remains in its current status; the merchant must explicitly void to release uncaptured funds. */
+    captureExpiresAt?: string;
+    /** The UTC ISO 8601 timestamp after which refund attempts are rejected. Defaults to now + 30 days if omitted. The session remains in its current status; the refund window is simply closed. */
+    refundExpiresAt?: string;
+}
+export declare const PaymentExpiries: S.Schema<PaymentExpiries>;
+/** The most recent meaningful event on the payment session. For session-level milestones the value is one of `created` or `canceled`. For action outcomes the value follows the pattern `{action}_{result}` — e.g. `authorization_succeeded`, `capture_pending`, `refund_failed`. */
+export type PaymentSessionStatus = "created" | "canceled" | "authorization_pending" | "authorization_succeeded" | "authorization_failed" | "capture_pending" | "capture_succeeded" | "capture_failed" | "void_pending" | "void_succeeded" | "void_failed" | "refund_pending" | "refund_succeeded" | "refund_failed";
+export declare const PaymentSessionStatus: any;
+/** Running totals tracking how funds move through the session. All amounts are decimal representations denominated in the session's `asset`. */
+export interface PaymentSessionBalances {
+    /** Authorized funds not yet captured or voided. Decreases with each capture or void. */
+    capturable?: string;
+    /** Total funds captured across all captures. */
+    captured?: string;
+    /** Captured funds not yet refunded. Equals `captured` minus `refunded`. */
+    refundable?: string;
+    /** Total funds refunded across all refunds. */
+    refunded?: string;
+}
+export declare const PaymentSessionBalances: S.Schema<PaymentSessionBalances>;
+/** The authorizations for this payment session. */
+export type PaymentSessionAuthorizationsList = Array<Authorization>;
+export declare const PaymentSessionAuthorizationsList: S.Schema<PaymentSessionAuthorizationsList>;
+/** The onchain transactions associated with this capture. */
+export type CaptureOnchainTransactionsList = Array<OnchainTransaction>;
+export declare const CaptureOnchainTransactionsList: S.Schema<CaptureOnchainTransactionsList>;
+/** A collection of authorized funds. Multiple partial captures are allowed up to the authorized amount. Each capture settles funds to the merchant's target. */
+export interface Capture {
+    /** The unique identifier of the capture. */
+    captureId?: string;
+    /** The ID of the payment session this capture belongs to. */
+    paymentSessionId?: string;
+    /** The current status of the capture. */
+    status?: PaymentActionStatus;
+    /** A decimal representation of the captured amount, denominated in the session's `asset`. */
+    amount?: string;
+    /** When `true`, this capture is treated as the final one for the authorization. Any remaining capturable balance is released back to the payer immediately after the capture settles. When `false`, the remaining capturable balance stays held and is available for subsequent partial captures (subject to `captureExpiresAt`). Has no effect if `amount` equals the full capturable balance, since no remaining balance exists to release. */
+    finalCapture: boolean;
+    error?: PaymentError;
+    metadata?: Metadata;
+    /** A merchant-provided internal identifier for this capture, from the merchant's own system—not visible to the payer. A manual capture uses the caller-provided value; an auto-capture reuses the authorization's value and omits it when the authorization omitted it. It never falls back to `PaymentSession.externalReferenceId`. */
+    externalReferenceId?: string;
+    /** Customer-facing display data for this capture, shown to the payer. A manual capture falls back to the session's `orderCode` when `referenceCode` is omitted; an auto-capture reuses the authorization's `referenceCode`. */
+    customerDisplay?: OperationCustomerDisplay;
+    /** The onchain transactions associated with this capture. */
+    onchainTransactions?: CaptureOnchainTransactionsList;
+    /** The UTC ISO 8601 timestamp at which the capture was created. */
+    createdAt?: string;
+    /** The UTC ISO 8601 timestamp at which the capture was last updated. */
+    updatedAt?: string;
+}
+export declare const Capture: S.Schema<Capture>;
+/** The captures for this payment session. */
+export type PaymentSessionCapturesList = Array<Capture>;
+export declare const PaymentSessionCapturesList: S.Schema<PaymentSessionCapturesList>;
+/** The onchain transactions associated with this void. */
+export type VoidOnchainTransactionsList = Array<OnchainTransaction>;
+export declare const VoidOnchainTransactionsList: S.Schema<VoidOnchainTransactionsList>;
+/** A release of uncaptured authorized funds back to the payer. Voids release all remaining capturable funds in a single operation, including after partial refunds as long as a capturableAmount remains. */
+export interface Void {
+    /** The unique identifier of the void. */
+    voidId?: string;
+    /** The ID of the payment session this void belongs to. */
+    paymentSessionId?: string;
+    /** The current status of the void. */
+    status?: PaymentActionStatus;
+    /** A decimal representation of the voided amount, denominated in the session's `asset`. */
+    amount?: string;
+    error?: PaymentError;
+    metadata?: Metadata;
+    /** A merchant-provided internal identifier for this void, from the merchant's own system—not visible to the payer. Present only when supplied on the create void request. */
+    externalReferenceId?: string;
+    /** Customer-facing display data for this void, shown to the payer. Present when supplied on the create void request or when the session's `orderCode` fallback applies; otherwise omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+    /** The onchain transactions associated with this void. */
+    onchainTransactions?: VoidOnchainTransactionsList;
+    /** The UTC ISO 8601 timestamp at which the void was created. */
+    createdAt?: string;
+    /** The UTC ISO 8601 timestamp at which the void was last updated. */
+    updatedAt?: string;
+}
+export declare const Void: S.Schema<Void>;
+/** The voids for this payment session. */
+export type PaymentSessionVoidsList = Array<Void>;
+export declare const PaymentSessionVoidsList: S.Schema<PaymentSessionVoidsList>;
+/** An onchain address from which funds are pulled to fund the refund. Network and asset are inferred from the payment session. */
+export interface RefundWallet {
+    /** The onchain crypto address from which to fund the refund. */
+    address: string;
+}
+export declare const RefundWallet: S.Schema<RefundWallet>;
+/** The source from which a refund is funded. */
+export type RefundSource = TransfersAccount | RefundWallet;
+export declare const RefundSource: S.Schema<RefundSource>;
+/** The onchain transactions associated with this refund. */
+export type RefundOnchainTransactionsList = Array<OnchainTransaction>;
+export declare const RefundOnchainTransactionsList: S.Schema<RefundOnchainTransactionsList>;
+/** A return of previously captured funds to the payer. Multiple partial refunds are allowed up to the total captured amount. */
+export interface Refund {
+    /** The unique identifier of the refund. */
+    refundId?: string;
+    /** The ID of the payment session this refund belongs to. */
+    paymentSessionId?: string;
+    /** The source from which the refund is funded. Can be a CDP account or an onchain address. */
+    source?: RefundSource;
+    /** The current status of the refund. */
+    status?: PaymentActionStatus;
+    /** A decimal representation of the refunded amount, denominated in the session's `asset`. */
+    amount?: string;
+    /** The reason for the refund. */
+    reason?: string;
+    error?: PaymentError;
+    metadata?: Metadata;
+    /** A merchant-provided internal identifier for this refund, from the merchant's own system—not visible to the payer. Present only when supplied on the create refund request. */
+    externalReferenceId?: string;
+    /** Customer-facing display data for this refund, shown to the payer. Present when supplied on the create refund request or when the session's `orderCode` fallback applies; otherwise omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+    /** The onchain transactions associated with this refund. */
+    onchainTransactions?: RefundOnchainTransactionsList;
+    /** The UTC ISO 8601 timestamp at which the refund was created. */
+    createdAt?: string;
+    /** The UTC ISO 8601 timestamp at which the refund was last updated. */
+    updatedAt?: string;
+}
+export declare const Refund: S.Schema<Refund>;
+/** The refunds for this payment session. */
+export type PaymentSessionRefundsList = Array<Refund>;
+export declare const PaymentSessionRefundsList: S.Schema<PaymentSessionRefundsList>;
+/** Redirect URLs used to direct the payer after a web-based payment flow completes or fails. */
+export interface PaymentRedirect {
+    /** The URL to redirect the payer to on payment failure. */
+    failureUrl?: string;
+    /** The URL to redirect the payer to on payment success. */
+    successUrl?: string;
+}
+export declare const PaymentRedirect: S.Schema<PaymentRedirect>;
+/** The amount to present to the payer, which may differ from the authoritative settlement amount and asset. Commonly used when the payer's local currency differs from the settlement currency (e.g., charging in USD but displaying the equivalent in CAD). Stored and returned as-is — no cross-validation is performed against the authoritative `amount` and `asset`. Both `amount` and `currency` must be provided together. */
+export interface CustomerDisplayDisplayAmount {
+    /** The display amount as a decimal string (e.g., `"1.37"`). */
+    amount: string;
+    /** An ISO 4217 currency code in lowercase for the display amount (e.g., `cad`, `usd`). */
+    currency: string;
+}
+export declare const CustomerDisplayDisplayAmount: S.Schema<CustomerDisplayDisplayAmount>;
+/** Merchant-provided display data shown to the payer during checkout. All fields are informational only — stored and returned as-is, with no effect on payment processing, settlement, or validation. */
+export interface CustomerDisplay {
+    /** The merchant name to display on the payment UI. When provided, this overrides the default name derived from the entity's profile. Useful when a merchant operates multiple storefronts or brands under a single entity. */
+    merchantName?: string;
+    /** The amount to present to the payer, which may differ from the authoritative settlement amount and asset. Commonly used when the payer's local currency differs from the settlement currency (e.g., charging in USD but displaying the equivalent in CAD). Stored and returned as-is — no cross-validation is performed against the authoritative `amount` and `asset`. Both `amount` and `currency` must be provided together. */
+    displayAmount?: CustomerDisplayDisplayAmount;
+    /** A customer-visible code for the overall order. When omitted, CDP generates one and returns it. It must not contain personally identifiable information (PII) or payment credentials. */
+    orderCode?: string;
+}
+export declare const CustomerDisplay: S.Schema<CustomerDisplay>;
+/** Tracks the full lifecycle of a payment from creation through settlement. Typical flow: **Create** → **Authorize** (via payment method) → **Capture**. Optional: **Void** to release uncaptured funds, or **Refund** to return captured funds. */
+export interface PaymentSession {
+    /** The unique identifier of the payment session. */
+    paymentSessionId?: string;
+    /** The ID of the entity that owns the payment session. */
+    entityId?: string;
+    /** A decimal representation of the payment amount, denominated in `asset`. */
+    amount?: string;
+    /** The symbol of the asset for the payment amount. */
+    asset?: string;
+    /** The target of the payment session. */
+    target?: PaymentSessionTarget;
+    /** When true, a capture is automatically created after a successful authorization. When false or omitted, the merchant must create captures manually via the captures endpoint. */
+    autoCapture?: boolean;
+    expiries?: PaymentExpiries;
+    /** The source of the payment session. Set after a successful authorization. Not present before authorization. */
+    source?: PaymentSessionSource;
+    /** The most recent meaningful event on the payment session. */
+    status?: PaymentSessionStatus;
+    balances?: PaymentSessionBalances;
+    /** The authorizations for this payment session. */
+    authorizations?: PaymentSessionAuthorizationsList;
+    /** The captures for this payment session. */
+    captures?: PaymentSessionCapturesList;
+    /** The voids for this payment session. */
+    voids?: PaymentSessionVoidsList;
+    /** The refunds for this payment session. */
+    refunds?: PaymentSessionRefundsList;
+    /** A URL to the hosted payment page where the payer can complete this payment session. */
+    url?: string;
+    /** URL for the hosted x402 payment flow. This endpoint expects an HTTP **POST** request (for example, submitting the x402 payment via request headers); do not treat it as a page opened with GET alone. Only present when the payment target supports a wallet source. */
+    x402Url?: string;
+    redirect?: PaymentRedirect;
+    customerDisplay?: CustomerDisplay;
+    metadata?: Metadata;
+    /** A merchant-provided internal identifier for this payment session, from the merchant's own system—not visible to the payer. It must not contain personally identifiable information (PII) or payment credentials. */
+    externalReferenceId?: string;
+    /** The reason the payment session was canceled. Only present when the session has been canceled. */
+    cancellationReason?: string;
+    /** The UTC ISO 8601 timestamp at which the payment session was created. */
+    createdAt?: string;
+    /** The UTC ISO 8601 timestamp at which the payment session was last updated. */
+    updatedAt?: string;
+}
+export declare const PaymentSession: S.Schema<PaymentSession>;
+export interface CapturePaymentSessionRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** A decimal representation of the amount to capture, denominated in the session's `asset`. If omitted, the full remaining capturable amount is captured. */
+    amount?: string;
+    /** When `true`, this capture is treated as the final one for the authorization. Any remaining capturable balance is released back to the payer immediately after the capture settles. When `false`, the remaining capturable balance stays held and is available for subsequent partial captures (subject to `captureExpiresAt`). Has no effect if `amount` equals the full capturable balance, since no remaining balance exists to release. */
+    finalCapture: boolean;
+    metadata?: Metadata;
+    /** An optional merchant-provided internal identifier for this manual capture, from the merchant's own system—not visible to the payer. */
+    externalReferenceId?: string;
+    /** Optional customer-facing display data for this manual capture, shown to the payer. Falls back to the session's `orderCode` when `referenceCode` is omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+}
+export declare const CapturePaymentSessionRequest: S.Schema<CapturePaymentSessionRequest>;
+/** The type of the customer. Required on create; accepted but ignored on update. */
+export type CustomerType = "individual";
+export declare const CustomerType: any;
+/** Request to enable or disable a capability. */
+export interface CapabilityInput {
+    /** Whether to request this capability. */
+    requested: boolean;
+}
+export declare const CapabilityInput: S.Schema<CapabilityInput>;
+/** The capabilities to request for a Customer. Each capability can be individually requested. The requirements to enable each capability will be returned in the response. */
+export interface CapabilitiesMapInput {
+    /** Hold cryptocurrency in a Coinbase custodial account. */
+    custodyCrypto?: CapabilityInput;
+    /** Hold fiat currency in a Coinbase custodial account. */
+    custodyFiat?: CapabilityInput;
+    /** Hold stablecoin in a Coinbase custodial account. */
+    custodyStablecoin?: CapabilityInput;
+    /** Trade cryptocurrency. */
+    tradeCrypto?: CapabilityInput;
+    /** Trade stablecoin. */
+    tradeStablecoin?: CapabilityInput;
+    /** Transfer cryptocurrency to another party. */
+    transferCrypto?: CapabilityInput;
+    /** Transfer fiat currency to another party. */
+    transferFiat?: CapabilityInput;
+    /** Transfer stablecoin to another party. */
+    transferStablecoin?: CapabilityInput;
+}
+export declare const CapabilitiesMapInput: S.Schema<CapabilitiesMapInput>;
+/** Primary residential address. Only US addresses are currently supported. Non-US `countryCode` values are rejected with a 400. */
+export interface IndividualInputAddress {
+    /** Primary street address. */
+    line1?: string;
+    /** Secondary address information. */
+    line2?: string;
+    /** City or locality. */
+    city?: string;
+    /** State, province, or region. */
+    state?: string;
+    /** Postal or ZIP code. */
+    postCode?: string;
+    /** ISO 3166-1 alpha-2 country code (2 characters). See https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes. */
+    countryCode?: string;
+}
+export declare const IndividualInputAddress: S.Schema<IndividualInputAddress>;
+/** Date of birth with lenient formatting. Accepts both zero-padded ("04", "07") and single-digit ("4", "7") values for day and month. */
+export interface DateOfBirthLenient {
+    /** Day of birth (1-31). Both single-digit ("7") and zero-padded ("07") formats are accepted. */
+    day?: string;
+    /** Month of birth (1-12). Both single-digit ("4") and zero-padded ("04") formats are accepted. */
+    month?: string;
+    /** Year of birth (four digits). */
+    year?: string;
+}
+export declare const DateOfBirthLenient: S.Schema<DateOfBirthLenient>;
+/** Primary purpose for using Coinbase services. */
+export type IndividualInputPurposeOfAccount = "investing" | "long_term_investment" | "short_term_investment" | "trading" | "trading_on_coinbase" | "trading_on_other_exchanges" | "day_trading" | "arbitrage_trading" | "online_purchases" | "online_payments" | "payments_or_gifts" | "payments_to_friends" | "transfer_crypto" | "investing_on_other_exchanges" | "business" | "other";
+export declare const IndividualInputPurposeOfAccount: any;
+/** Primary source of funds for the account. */
+export type IndividualInputSourceOfFunds = "salary" | "employment_business_income" | "investments" | "savings" | "pension" | "business_earnings" | "crypto_assets" | "inheritance" | "sale_of_assets" | "sale_of_company_shares_or_dividends" | "sale_of_property" | "sale_of_other_assets" | "credit_or_loan" | "government_benefits_or_credits" | "legal_settlement" | "family_or_third_party" | "lottery_or_gambling" | "crypto_mining" | "other";
+export declare const IndividualInputSourceOfFunds: any;
+/** Current employment status. */
+export type IndividualInputEmploymentStatus = "employed_fulltime" | "employed_parttime" | "self_employed" | "employed_government_official" | "employed_company_officer_or_board_member" | "employed_crypto_related_business" | "personal_trader_or_angel_investor" | "crypto_miner" | "student" | "retired" | "homemaker" | "unemployed" | "dependent";
+export declare const IndividualInputEmploymentStatus: any;
+/** Industry or occupation. */
+export type IndividualInputOccupation = "agriculture" | "arts_and_media" | "casinos_and_gaming" | "construction" | "cryptocurrency" | "defense" | "education" | "energy_oil_and_gas" | "energy_other" | "entertainment" | "finance" | "financial_services_non_crypto" | "fintech_non_crypto_software_development" | "fintech_non_crypto_internet_only_financial_institution" | "fintech_non_crypto_other" | "food_and_hospitality" | "government" | "health_and_fitness" | "healthcare" | "healthcare_other" | "healthcare_pharmaceuticals" | "mining" | "mining_crypto" | "non_profit_and_charity" | "pharma_industry" | "politics" | "professional_services" | "property_and_construction_building_work" | "property_and_construction_commercial_and_management" | "property_and_construction_design" | "real_estate" | "retail_fashion" | "retail_food_and_beverage" | "retail_jewelry_and_antiques" | "retail_other" | "retail_pharmacy" | "technology" | "technology_and_it" | "transportation" | "all_other_industries_and_services" | "dependent_student_unemployed" | "other";
+export declare const IndividualInputOccupation: any;
+/** Expected annual volume of activity on the account, expressed as a dollar range. Use the dollar-honest ids below: - `under_1k`: $0 – $1,000 - `1k_to_10k`: $1,000 – $10,000 - `10k_to_100k`: $10,000 – $100,000 - `100k_to_250k`: $100,000 – $250,000 - `250k_to_750k`: $250,000 – $750,000 - `750k_to_1_5m`: $750,000 – $1.5M - `1_5m_plus`: $1.5M+ */
+export type IndividualInputExpectedVolume = "under_1k" | "1k_to_10k" | "10k_to_100k" | "100k_to_250k" | "250k_to_750k" | "750k_to_1_5m" | "1_5m_plus";
+export declare const IndividualInputExpectedVolume: any;
+/** Individual customer data submitted on create / update requests. Fields are organized by the capabilities they unlock; not all are required for all customers (the requirements depend on which capabilities are requested). Read responses return the narrower `Individual` object (only `firstName`, `lastName`, and `email`), not this full request shape. */
+export interface IndividualInput {
+    /** First name (given name). */
+    firstName?: string;
+    /** Last name (family name/surname). */
+    lastName?: string;
+    /** Primary residential address. Only US addresses are currently supported. Non-US `countryCode` values are rejected with a 400. */
+    address?: IndividualInputAddress;
+    /** Last 4 digits of the Social Security Number (US only). Used for identity verification. */
+    ssnLast4?: string;
+    /** Date of birth. */
+    dateOfBirth?: DateOfBirthLenient;
+    /** Full Social Security Number (US only). */
+    fullSsn?: string;
+    /** ISO 3166-1 alpha-2 country code representing the customer's citizenship. */
+    citizenship?: string;
+    /** Email address for the customer. */
+    email?: string;
+    /** Phone number in [E.164](https://en.wikipedia.org/wiki/E.164) format. */
+    phoneNumber?: string;
+    /** Primary purpose for using Coinbase services. */
+    purposeOfAccount?: IndividualInputPurposeOfAccount | (string & {});
+    /** Primary source of funds for the account. */
+    sourceOfFunds?: IndividualInputSourceOfFunds | (string & {});
+    /** Current employment status. */
+    employmentStatus?: IndividualInputEmploymentStatus | (string & {});
+    /** Industry or occupation. */
+    occupation?: IndividualInputOccupation | (string & {});
+    /** Expected annual volume of activity on the account, expressed as a dollar range. Use the dollar-honest ids below: - `under_1k`: $0 – $1,000 - `1k_to_10k`: $1,000 – $10,000 - `10k_to_100k`: $10,000 – $100,000 - `100k_to_250k`: $100,000 – $250,000 - `250k_to_750k`: $250,000 – $750,000 - `750k_to_1_5m`: $750,000 – $1.5M - `1_5m_plus`: $1.5M+ */
+    expectedVolume?: IndividualInputExpectedVolume | (string & {});
+}
+export declare const IndividualInput: S.Schema<IndividualInput>;
+/** The project IDs that this customer is associated with. */
+export type CreateCustomerRequestProjectIdsList = Array<string>;
+export declare const CreateCustomerRequestProjectIdsList: S.Schema<CreateCustomerRequestProjectIdsList>;
+/** A single Terms of Service acceptance recorded for a Customer. Submit one entry per required document listed in `Customer.requirements.tos.tosVersions[]` (returned on `Get Customer`, `Create Customer`, and `Update Customer`). `language` records the single translation the Customer actually reviewed. When new required Terms of Service versions are published, only the new `versionId`s appear in `Customer.requirements.tos.tosVersions[]`; submit acceptances for only those new version(s). */
+export interface TosAcceptance {
+    /** The `versionId` of the Terms of Service document being accepted, as listed in `Customer.requirements.tos.tosVersions[]`. */
+    versionId: string;
+    /** BCP 47 language tag of the Terms of Service translation the Customer reviewed. At write time the server rejects values that are not listed under `languages` on the matching required document for this Customer (same `versionId` as listed in `Customer.requirements.tos.tosVersions[]`). */
+    language: string;
+    /** Timestamp at which the Customer accepted the Terms of Service, in ISO 8601 / RFC 3339 format. The server may validate or reject obviously non-credible timestamps; when enforcement tightens, the authoritative acceptance time may be recorded server-side instead of trusting client-supplied values alone. */
+    acceptedAt: string;
+}
+export declare const TosAcceptance: S.Schema<TosAcceptance>;
+/** Terms of Service acceptances to record on the customer. Submit one entry per required version surfaced inline on `requirements.tos.tosVersions[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `tos` requirement is unsatisfied). The server rejects each acceptance whose `language` is not listed under `languages` on the matching required version with `errorType: "unsupported_tos_language"`. When new required Terms of Service versions are published, only the new `versionId`s appear in `requirements.tos.tosVersions[]`; submit acceptances for only those new version(s). Omit `tosAcceptances` on a partial update to leave previously recorded acceptances unchanged. Sending `tosAcceptances: []` is invalid (`errorType: "invalid_request"`) because it would clear all acceptances without replacing them; omit the field entirely when you are not updating Terms of Service acceptances. */
+export type CreateCustomerRequestTosAcceptancesList = Array<TosAcceptance>;
+export declare const CreateCustomerRequestTosAcceptancesList: S.Schema<CreateCustomerRequestTosAcceptancesList>;
+/** The tax form being attested to, as listed in `Customer.requirements.taxAttestation.taxForms[]`. Must be `us_w9` for this variant. */
+export type UsW9AttestationForm = "us_w9";
+export declare const UsW9AttestationForm: any;
+/** Tax attestation for IRS Form W-9, used for US persons. Carries the W-9-specific backup withholding certification alongside the fields common to every form (`edeliveryConsent`, `acceptedAt`). */
+export interface UsW9Attestation {
+    /** The tax form being attested to, as listed in `Customer.requirements.taxAttestation.taxForms[]`. Must be `us_w9` for this variant. */
+    form: UsW9AttestationForm | (string & {});
+    /** Whether the Customer consents to electronic delivery (e-delivery) of tax documents. Both `true` and `false` are recorded as submitted. */
+    edeliveryConsent: boolean;
+    /** Timestamp at which the Customer completed the tax attestation, in ISO 8601 / RFC 3339 format. The server may reject obviously non-credible timestamps. */
+    acceptedAt: string;
+    /** Whether the Customer is exempt from backup withholding, as certified on IRS Form W-9. */
+    isExemptBackupWithholding: boolean;
+}
+export declare const UsW9Attestation: S.Schema<UsW9Attestation>;
+/** Tax attestations to record on the customer. Submit one entry per required form surfaced inline on `requirements.taxAttestation.taxForms[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `taxAttestation` requirement is unsatisfied). The required fields per entry depend on `form`; see `TaxAttestation`. This field is ingestion-only and is never returned on read. Omit `taxAttestations` on a partial update to leave previously recorded attestations unchanged. Sending `taxAttestations: []` is invalid (`errorType: "invalid_request"`) because it would clear all attestations without replacing them; omit the field entirely when you are not updating tax attestations. */
+export type CreateCustomerRequestTaxAttestationsList = Array<UsW9Attestation>;
+export declare const CreateCustomerRequestTaxAttestationsList: S.Schema<CreateCustomerRequestTaxAttestationsList>;
+/** Compliance context for a request. Carries per-request compliance signals, such as the IP address of the individual (i.e., end-customer) that initiated the request. This object is request-only — it is never echoed back in responses. Inner fields are write-only. */
+export interface Compliance {
+    /** IPv4 or IPv6 address of the individual (i.e., end-customer) that initiated this request. NOT the IP of the partner server making the API call. */
+    requesterIpAddress?: string;
+}
+export declare const Compliance: S.Schema<Compliance>;
+export interface CreateCustomerRequest {
+    /** The type of the customer. Required on create; accepted but ignored on update. */
+    type: CustomerType | (string & {});
+    /** Capabilities to request for the customer. */
+    capabilities?: CapabilitiesMapInput;
+    /** Information about an Individual customer. Not all fields are required for all customers; the requirements depend on which capabilities are requested. Submit only fields that are required by the capabilities that have been requested. */
+    individual?: IndividualInput;
+    /** The project IDs that this customer is associated with. */
+    projectIds?: CreateCustomerRequestProjectIdsList;
+    /** Terms of Service acceptances to record on the customer. Submit one entry per required version surfaced inline on `requirements.tos.tosVersions[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `tos` requirement is unsatisfied). The server rejects each acceptance whose `language` is not listed under `languages` on the matching required version with `errorType: "unsupported_tos_language"`. When new required Terms of Service versions are published, only the new `versionId`s appear in `requirements.tos.tosVersions[]`; submit acceptances for only those new version(s). Omit `tosAcceptances` on a partial update to leave previously recorded acceptances unchanged. Sending `tosAcceptances: []` is invalid (`errorType: "invalid_request"`) because it would clear all acceptances without replacing them; omit the field entirely when you are not updating Terms of Service acceptances. */
+    tosAcceptances?: CreateCustomerRequestTosAcceptancesList;
+    /** Tax attestations to record on the customer. Submit one entry per required form surfaced inline on `requirements.taxAttestation.taxForms[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `taxAttestation` requirement is unsatisfied). The required fields per entry depend on `form`; see `TaxAttestation`. This field is ingestion-only and is never returned on read. Omit `taxAttestations` on a partial update to leave previously recorded attestations unchanged. Sending `taxAttestations: []` is invalid (`errorType: "invalid_request"`) because it would clear all attestations without replacing them; omit the field entirely when you are not updating tax attestations. */
+    taxAttestations?: CreateCustomerRequestTaxAttestationsList;
+    compliance?: Compliance;
+}
+export declare const CreateCustomerRequest: S.Schema<CreateCustomerRequest>;
+/** The status of a capability. Based on recoverability: - `unrequested`: Capability has not been requested by the customer - `pending`: Customer can take action to resolve (requirements `due` or `rejected`) - `active`: Capability is enabled and can be used - `inactive`: Permanently blocked - no customer action possible */
+export type CapabilityStatus = "unrequested" | "pending" | "active" | "inactive";
+export declare const CapabilityStatus: any;
+/** The current state of a capability for a customer. The `status` field is always present. When `requested` is `false`, the status will be `unrequested`. */
+export interface Capability {
+    /** Whether the customer has explicitly requested this capability. */
+    requested: boolean;
+    /** Current status of the capability. When `requested` is `false`, status is `unrequested`. When `requested` is `true`, status is one of `pending`, `active`, or `inactive`. */
+    status: CapabilityStatus;
+}
+export declare const Capability: S.Schema<Capability>;
+/** The current state of each capability for a Customer. Each capability shows whether it has been requested and its current status. */
+export interface CapabilitiesMap {
+    /** Hold cryptocurrency in a Coinbase custodial account. */
+    custodyCrypto?: Capability;
+    /** Hold fiat currency in a Coinbase custodial account. */
+    custodyFiat?: Capability;
+    /** Hold stablecoin in a Coinbase custodial account. */
+    custodyStablecoin?: Capability;
+    /** Trade cryptocurrency. */
+    tradeCrypto?: Capability;
+    /** Trade stablecoin. */
+    tradeStablecoin?: Capability;
+    /** Transfer cryptocurrency to another party. */
+    transferCrypto?: Capability;
+    /** Transfer fiat currency to another party. */
+    transferFiat?: Capability;
+    /** Transfer stablecoin to another party. */
+    transferStablecoin?: Capability;
+}
+export declare const CapabilitiesMap: S.Schema<CapabilitiesMap>;
+/** The current status of a requirement: - `due`: Must be submitted and no set deadline has passed - `past_due`: Must be submitted and a set deadline has passed - `pending`: Submitted, awaiting verification - `rejected`: Verification failed - customer must resubmit For a Terms of Service requirement, `past_due` applies if any unaccepted version has a deadline set in the past. Otherwise the status is `due`, including when a version has no deadline and requires immediate acceptance, or when every set deadline is in the future and acceptance is in grace. When verification passes, the requirement disappears from the response entirely. */
+export type RequirementStatus = "due" | "past_due" | "pending" | "rejected";
+export declare const RequirementStatus: any;
+/** The name of a capability. Capabilities represent granular functional permissions that determine what actions a customer can perform. Each capability must be explicitly requested before use. */
+export type CapabilityName = "custodyCrypto" | "custodyFiat" | "custodyStablecoin" | "tradeCrypto" | "tradeStablecoin" | "transferCrypto" | "transferFiat" | "transferStablecoin";
+export declare const CapabilityName: any;
+/** List of capabilities affected by this requirement, sorted alphabetically. Only present for `due`, `past_due`, `pending`, or `rejected` statuses. */
+export type RequirementImpactList = Array<CapabilityName>;
+export declare const RequirementImpactList: S.Schema<RequirementImpactList>;
+/** BCP 47 language tags this Terms of Service document can be viewed and accepted in. The list is non-empty (every published document carries at least one language). Append the chosen tag to `url` as `?lang=<tag>` to fetch the localized document, and submit the same tag as `language` on the corresponding `TosAcceptance` to record which translation the Customer reviewed. */
+export type TermsOfServiceLanguagesList = Array<string>;
+export declare const TermsOfServiceLanguagesList: S.Schema<TermsOfServiceLanguagesList>;
+/** Metadata for one Terms of Service document a Customer may need to accept. Each entry represents one logical document (identified by `versionId`) that may be published in multiple languages — `languages` lists the BCP 47 language tags the document is available to view and accept in. An optional `deadline` records the end of a grace period: a future deadline is non-blocking `due`, an elapsed deadline is `past_due`, and no deadline means acceptance is required immediately with status `due`. `url` is the canonical, language-agnostic document URL; partners append `?lang=<tag>` (where `<tag>` is one of `languages`) to retrieve a specific translation, and omit the parameter to let the documentation site choose a default. This API does not serve Terms of Service body content; this schema describes metadata only. */
+export interface TermsOfService {
+    /** Stable identifier for this Terms of Service document. Submit this value as `versionId` on a `TosAcceptance` to record acceptance. */
+    versionId: string;
+    /** Optional deadline by which the Customer must accept this Terms of Service version, in ISO 8601 / RFC 3339 format. A future deadline is non-blocking grace with requirement status `due`; an elapsed deadline produces `past_due`. When omitted, acceptance is required immediately and the requirement status remains `due`. */
+    deadline?: string;
+    /** BCP 47 language tags this Terms of Service document can be viewed and accepted in. The list is non-empty (every published document carries at least one language). Append the chosen tag to `url` as `?lang=<tag>` to fetch the localized document, and submit the same tag as `language` on the corresponding `TosAcceptance` to record which translation the Customer reviewed. */
+    languages: TermsOfServiceLanguagesList;
+    /** Canonical, language-agnostic URL where the Terms of Service document is hosted (for example, `https://docs.cdp.coinbase.com/legal/terms/us_individual`). Append `?lang=<tag>` (where `<tag>` is one of `languages`) to retrieve a specific translation; without the parameter, the documentation site renders a default translation. */
+    url: string;
+}
+export declare const TermsOfService: S.Schema<TermsOfService>;
+/** Required Terms of Service versions the Customer has not yet accepted, with the metadata needed to render an acceptance UI (each entry carries a stable `versionId`, the BCP 47 `languages` the version is published in, an optional per-version `deadline`, and a language-agnostic `url`). A missing deadline means acceptance is required immediately while the requirement status remains `due`; only a set deadline in the past produces `past_due`. This field appears only under the requirement key `tos`; do not infer meaning from `tosVersions` on other requirement keys. Only populated for the `tos` requirement; omitted on every other requirement key. Submit each `versionId` back via `tosAcceptances[].versionId` on `Update Customer` (or `Create Customer`) together with `language` and `acceptedAt` to clear the requirement. */
+export type RequirementTosVersionsList = Array<TermsOfService>;
+export declare const RequirementTosVersionsList: S.Schema<RequirementTosVersionsList>;
+/** Identifier for a tax attestation form a Customer may need to complete. The same identifier is surfaced on `Customer.requirements.taxAttestation.taxForms[]` (the forms a Customer still needs to attest to) and submitted back as `form` on `Customer.taxAttestations[]` to record the attestation. */
+export type TaxForm = "us_w9";
+export declare const TaxForm: any;
+/** Required tax attestation forms the Customer has not yet completed. This field appears only under the requirement key `taxAttestation`. Submit each `form` back via `taxAttestations[].form` on `Update Customer` (or `Create Customer`) together with the other fields required for that form to clear the requirement. */
+export type RequirementTaxFormsList = Array<TaxForm>;
+export declare const RequirementTaxFormsList: S.Schema<RequirementTaxFormsList>;
+/** A single requirement that a customer must submit to enable capabilities. Requirements are only shown for requested capabilities. */
+export interface Requirement {
+    status: RequirementStatus;
+    /** Optional aggregate deadline by which this requirement must be satisfied. For the `tos` requirement, this is the earliest set deadline among the unaccepted required Terms of Service versions listed in `tosVersions`. It is omitted only when none of the unaccepted versions has a deadline. Do not infer `past_due` or whether the requirement blocks from this aggregate field alone; inspect each version's deadline. */
+    deadline?: string;
+    /** List of capabilities affected by this requirement, sorted alphabetically. Only present for `due`, `past_due`, `pending`, or `rejected` statuses. */
+    impact?: RequirementImpactList;
+    /** Required Terms of Service versions the Customer has not yet accepted, with the metadata needed to render an acceptance UI (each entry carries a stable `versionId`, the BCP 47 `languages` the version is published in, an optional per-version `deadline`, and a language-agnostic `url`). A missing deadline means acceptance is required immediately while the requirement status remains `due`; only a set deadline in the past produces `past_due`. This field appears only under the requirement key `tos`; do not infer meaning from `tosVersions` on other requirement keys. Only populated for the `tos` requirement; omitted on every other requirement key. Submit each `versionId` back via `tosAcceptances[].versionId` on `Update Customer` (or `Create Customer`) together with `language` and `acceptedAt` to clear the requirement. */
+    tosVersions?: RequirementTosVersionsList;
+    /** Required tax attestation forms the Customer has not yet completed. This field appears only under the requirement key `taxAttestation`. Submit each `form` back via `taxAttestations[].form` on `Update Customer` (or `Create Customer`) together with the other fields required for that form to clear the requirement. */
+    taxForms?: RequirementTaxFormsList;
+}
+export declare const Requirement: S.Schema<Requirement>;
+/** Map of requirements to be submitted. Each key is the field name (e.g., "ssnLast4"), with values to describe its state. Requirements are only shown for requested capabilities. When a requirement is verified, it disappears from this map. For the `tos` key, each entry in `tosVersions[]` has its own optional deadline. The requirement-level `deadline` is an aggregate of those rows: the earliest set deadline among unaccepted versions, not a separate clock. A version with no deadline requires immediate acceptance but keeps the aggregate status `due`. A future deadline is also `due` and represents non-blocking grace. The aggregate status is `past_due` only when at least one unaccepted version has a deadline set in the past. Do not infer status or blocking behavior from omission of the aggregate deadline. */
+export type RequirementsMap = {
+    [key: string]: Requirement | undefined;
+};
+export declare const RequirementsMap: S.Schema<RequirementsMap>;
+/** Individual customer data returned on read — the `individual` object on Get / Create / Update Customer responses. Only contact-identity fields are echoed back; every other field accepted on the `IndividualInput` object (`address`, `ssnLast4`, `dateOfBirth`, `fullSsn`, `citizenship`, `phoneNumber`, and the CDD fields) is ingestion-only and never returned. */
+export interface Individual {
+    /** First name (given name). */
+    firstName?: string;
+    /** Last name (family name/surname). */
+    lastName?: string;
+    /** Email address for the customer. */
+    email?: string;
+}
+export declare const Individual: S.Schema<Individual>;
+/** The project IDs that this customer is associated with. */
+export type CustomerProjectIdsList = Array<string>;
+export declare const CustomerProjectIdsList: S.Schema<CustomerProjectIdsList>;
+/** Terms of Service acceptances recorded for the customer. */
+export type CustomerTosAcceptancesList = Array<TosAcceptance>;
+export declare const CustomerTosAcceptancesList: S.Schema<CustomerTosAcceptancesList>;
+/** A customer record returned on read (Get / Create / Update Customer). */
+export interface Customer {
+    customerId: string;
+    type: CustomerType;
+    /** Current state of each capability for this customer. Each capability shows whether it has been requested and its current status. */
+    capabilities: CapabilitiesMap;
+    /** Map of requirements to be submitted. Each key is the field name, with values to describe its state. Requirements are only shown for requested capabilities. When a requirement is fulfilled, it disappears from this map. */
+    requirements: RequirementsMap;
+    /** Timestamp when the customer was created. */
+    createdAt?: string;
+    /** Timestamp when the customer was last updated. */
+    updatedAt?: string;
+    individual?: Individual;
+    /** The project IDs that this customer is associated with. */
+    projectIds?: CustomerProjectIdsList;
+    /** Terms of Service acceptances recorded for the customer. */
+    tosAcceptances?: CustomerTosAcceptancesList;
+}
+export declare const Customer: S.Schema<Customer>;
 export interface CreateDelegationForEndUserAccountRequest {
     /** The ID of the end user. */
     userId: string;
@@ -79,8 +734,13 @@ export interface CreateDelegationForEndUserAccountResponse {
     expiresAt: string;
 }
 export declare const CreateDelegationForEndUserAccountResponse: S.Schema<CreateDelegationForEndUserAccountResponse>;
-export type DepositDestinationType = "crypto";
-export declare const DepositDestinationType: any;
+export type DepositDestinationTypeCase0 = "crypto";
+export declare const DepositDestinationTypeCase0: any;
+export type DepositDestinationTypeCase1 = "fiat";
+export declare const DepositDestinationTypeCase1: any;
+/** The type of deposit destination. */
+export type DepositDestinationType = DepositDestinationTypeCase0 | DepositDestinationTypeCase1;
+export declare const DepositDestinationType: S.Schema<DepositDestinationType>;
 /** The account and asset where incoming deposits should be credited. */
 export interface DepositDestinationTargetAccount {
     /** The ID of the CDP Account to which deposited funds should be transferred. */
@@ -89,39 +749,77 @@ export interface DepositDestinationTargetAccount {
     asset: string;
 }
 export declare const DepositDestinationTargetAccount: S.Schema<DepositDestinationTargetAccount>;
-/** Optional metadata as key-value pairs. Use this to store additional structured information on a resource, such as customer IDs, order references, or any application-specific data. Up to 10 key/value pairs may be provided. Keys and values are both strings. Keys must be ≤ 40 characters; values must be ≤ 500 characters. */
-export type Metadata = {
-    [key: string]: string | undefined;
-};
-export declare const Metadata: S.Schema<Metadata>;
-/** The blockchain network for the payment. Supported networks depend on the account type. See [API and Network Support](https://docs.cdp.coinbase.com/api-reference/payment-apis/supported-networks-assets#by-asset-and-network) for more details. */
-export type Network = "base" | "ethereum" | "solana" | "aptos" | "arbitrum" | "arbitrum-sepolia" | "optimism" | "polygon" | "world" | "world-sepolia";
-export declare const Network: any;
+/** The blockchain network for crypto payments, transfers, and deposit destinations. */
+export type PaymentNetwork = "base" | "ethereum" | "solana" | "arbitrum" | "optimism" | "monad" | "sui" | "avacchain" | "tempo";
+export declare const PaymentNetwork: any;
+/** The target of the payment is an onchain address. */
+export interface OnchainAddress {
+    /** The onchain crypto address of the recipient. Examples: - EVM address: 0xabc1234567890abcdef1234567890abcdef123456 - Solana address: HpabPRRCFbBKSuJr5PdkVvQc85FyxyTWkFM2obBRSvHT - XRP address: rhccc5p23aKiCGFcEqqnjEfLRZ6xEvfy3s */
+    address: string;
+    network: PaymentNetwork | (string & {});
+    /** The destination tag of the onchain address. Destination tags are used by certain networks (primarily XRP/Ripple) to identify specific recipients when multiple users share a single address. The tag ensures funds are credited to the correct account within the shared address. Examples by network: - XRP/Ripple: Numeric values like "1234567890" or "123456" - Stellar (XLM): Memos which can be text, ID, or hash format Note: Most networks (Ethereum, Bitcoin, Solana) do not use destination tags. */
+    destinationTag?: string;
+    /** Asset symbol of the payment received by the recipient. Supported values are `usdc` and `eurc`. */
+    asset: string;
+}
+export declare const OnchainAddress: S.Schema<OnchainAddress>;
+/** The intended target for deposited funds. */
+export type DepositDestinationTarget = DepositDestinationTargetAccount | OnchainAddress;
+export declare const DepositDestinationTarget: S.Schema<DepositDestinationTarget>;
 /** Crypto-specific details for creating a deposit destination. */
 export interface CreateDepositDestinationCrypto {
-    network: Network | (string & {});
+    network: PaymentNetwork | (string & {});
 }
 export declare const CreateDepositDestinationCrypto: S.Schema<CreateDepositDestinationCrypto>;
 export interface CreateCryptoDepositDestinationRequest {
     /** The ID of the Account, which is a UUID prefixed by the string `account_`, that owns the deposit destination. */
     accountId: string;
-    type: DepositDestinationType | (string & {});
-    target?: DepositDestinationTargetAccount;
+    type: DepositDestinationType;
+    target?: DepositDestinationTarget;
     metadata?: Metadata;
+    compliance?: Compliance;
     /** Crypto-specific details. Required when `type` is `crypto`. */
     crypto: CreateDepositDestinationCrypto;
 }
 export declare const CreateCryptoDepositDestinationRequest: S.Schema<CreateCryptoDepositDestinationRequest>;
-export interface CreateDepositDestinationRequest {
-    body: CreateCryptoDepositDestinationRequest;
+/** The fiat currency for the deposit destination. */
+export type CreateDepositDestinationFiatCurrency = "usd";
+export declare const CreateDepositDestinationFiatCurrency: any;
+/** A payment rail supported by a fiat deposit destination. */
+export type DepositDestinationPaymentRail = "ach" | "fedwire";
+export declare const DepositDestinationPaymentRail: any;
+/** Fiat-specific request fields for creating a deposit destination. The server determines the account type and provisioning method based on the account's eligibility. Optionally specify a `paymentRail` to target a specific payment rail, which may influence banking partner selection. */
+export interface CreateDepositDestinationFiat {
+    /** The fiat currency for the deposit destination. */
+    currency: CreateDepositDestinationFiatCurrency | (string & {});
+    /** Optional. The desired payment rail. When omitted, the server provisions the default banking partner and returns all rails the account supports. When specified, the server selects a banking partner that supports the requested rail. */
+    paymentRail?: DepositDestinationPaymentRail | (string & {});
+}
+export declare const CreateDepositDestinationFiat: S.Schema<CreateDepositDestinationFiat>;
+export interface CreateFiatDepositDestinationRequest {
+    /** The ID of the Account, which is a UUID prefixed by the string `account_`, that owns the deposit destination. */
+    accountId: string;
+    type: DepositDestinationType;
+    target?: DepositDestinationTarget;
+    metadata?: Metadata;
+    compliance?: Compliance;
+    /** Fiat-specific details. Required when `type` is `fiat`. */
+    fiat: CreateDepositDestinationFiat;
 }
+export declare const CreateFiatDepositDestinationRequest: S.Schema<CreateFiatDepositDestinationRequest>;
+/** Request to create a new deposit destination. Provide the type-specific details matching the chosen `type`. */
+export type CreateDepositDestinationRequest = CreateCryptoDepositDestinationRequest | CreateFiatDepositDestinationRequest;
 export declare const CreateDepositDestinationRequest: S.Schema<CreateDepositDestinationRequest>;
+export interface CreateDepositDestinationRequest2 {
+    body: CreateDepositDestinationRequest;
+}
+export declare const CreateDepositDestinationRequest2: S.Schema<CreateDepositDestinationRequest2>;
 /** The type of deposit destination. */
 export type CryptoDepositDestinationType = "crypto";
 export declare const CryptoDepositDestinationType: any;
 /** Crypto-specific deposit destination details. In responses, this object is always present. Contains the network and address for the deposit destination. */
 export interface DepositDestinationCrypto {
-    network: Network;
+    network: PaymentNetwork;
     address: string;
 }
 export declare const DepositDestinationCrypto: S.Schema<DepositDestinationCrypto>;
@@ -136,7 +834,7 @@ export interface CryptoDepositDestination {
     type: CryptoDepositDestinationType;
     /** Crypto-specific details for this deposit destination. Always populated in responses. Contains the network and address. */
     crypto: DepositDestinationCrypto;
-    target?: DepositDestinationTargetAccount;
+    target?: DepositDestinationTarget;
     status: DepositDestinationStatus;
     metadata?: Metadata;
     /** The timestamp when the deposit destination was created. */
@@ -145,8 +843,154 @@ export interface CryptoDepositDestination {
     updatedAt: string;
 }
 export declare const CryptoDepositDestination: S.Schema<CryptoDepositDestination>;
-export type CreateDepositDestinationResponse = CryptoDepositDestination;
+/** The type of deposit destination. */
+export type FiatDepositDestinationType = "fiat";
+export declare const FiatDepositDestinationType: any;
+/** The type of bank account, based on the account identification scheme (e.g., `us_bank`). */
+export type BankAccountUSAccountType = "us_bank";
+export declare const BankAccountUSAccountType: any;
+/** The fiat currency for the deposit destination. */
+export type BankAccountUSCurrency = "usd";
+export declare const BankAccountUSCurrency: any;
+/** The payment rails this account can receive deposits on. */
+export type BankAccountUSSupportedRailsList = Array<DepositDestinationPaymentRail>;
+export declare const BankAccountUSSupportedRailsList: S.Schema<BankAccountUSSupportedRailsList>;
+/** A US bank account identified by ABA routing number and account number. */
+export interface BankAccountUS {
+    /** The type of bank account, based on the account identification scheme (e.g., `us_bank`). */
+    accountType: BankAccountUSAccountType;
+    /** The fiat currency for the deposit destination. */
+    currency: BankAccountUSCurrency;
+    /** The name of the bank holding the account. */
+    bankName: string;
+    /** The name of the account beneficiary. */
+    beneficiaryName: string;
+    /** The ABA routing number of the bank. */
+    routingNumber: string;
+    /** The bank account number. */
+    accountNumber: string;
+    /** The address of the bank. Present when required by the receiving institution. */
+    bankAddress?: string;
+    /** A reference code that must be included in the payment memo or reference field so the receiving institution can route the deposit to the correct account. Only present when required by the receiving institution. */
+    referenceCode?: string;
+    /** The payment rails this account can receive deposits on. */
+    supportedRails: BankAccountUSSupportedRailsList;
+}
+export declare const BankAccountUS: S.Schema<BankAccountUS>;
+/** A fiat deposit destination. Represents a single bank account provisioned at a single banking partner. Each deposit destination has one status and one lifecycle. The `fiat` object contains the bank account details, keyed by account type. */
+export interface FiatDepositDestination {
+    depositDestinationId: string;
+    accountId: string;
+    /** The type of deposit destination. */
+    type: FiatDepositDestinationType;
+    fiat: BankAccountUS;
+    target?: DepositDestinationTarget;
+    status: DepositDestinationStatus;
+    metadata?: Metadata;
+    /** The timestamp when the deposit destination was created. */
+    createdAt: string;
+    /** The timestamp when the deposit destination was last updated. */
+    updatedAt: string;
+}
+export declare const FiatDepositDestination: S.Schema<FiatDepositDestination>;
+/** A deposit destination for receiving funds to an account. */
+export type DepositDestination = CryptoDepositDestination | FiatDepositDestination;
+export declare const DepositDestination: S.Schema<DepositDestination>;
+export type CreateDepositDestinationResponse = DepositDestination;
 export declare const CreateDepositDestinationResponse: S.Schema<CreateDepositDestinationResponse>;
+/** A Coinbase-user target for the disbursement. */
+export interface DisbursementCoinbaseTarget {
+    /** The unique identifier of the recipient within Coinbase. */
+    coinbaseUserId: string;
+}
+export declare const DisbursementCoinbaseTarget: S.Schema<DisbursementCoinbaseTarget>;
+/** The blockchain network for the payment. Supported networks depend on the account type. */
+export type Network = "base" | "ethereum" | "solana" | "aptos" | "arbitrum" | "arbitrum-sepolia" | "optimism" | "polygon" | "world" | "world-sepolia";
+export declare const Network: any;
+/** An onchain address target for the disbursement. */
+export interface DisbursementWalletTarget {
+    /** The onchain crypto address of the recipient. */
+    address: string;
+    /** The blockchain network on which the target receives funds. */
+    network: Network | (string & {});
+}
+export declare const DisbursementWalletTarget: S.Schema<DisbursementWalletTarget>;
+/** The target of the disbursement. Can be either a Coinbase user account or an onchain blockchain address. */
+export type DisbursementTarget = DisbursementCoinbaseTarget | DisbursementWalletTarget;
+export declare const DisbursementTarget: S.Schema<DisbursementTarget>;
+/** A physical address with standard address components including street, city, state/province, postal code, and country. */
+export type PhysicalAddress = IndividualInputAddress;
+export declare const PhysicalAddress: S.Schema<IndividualInputAddress>;
+/** A natural person, identified by name and physical address. */
+export interface Person {
+    /** Full legal name of the person. */
+    name?: string;
+    /** Physical address of the person. */
+    address?: IndividualInputAddress;
+}
+export declare const Person: S.Schema<Person>;
+/** Compliance context for a disbursement request. Extends the base Compliance schema with recipient information required for travel rule obligations. This object is request-only — it is never echoed back in responses. */
+export interface DisbursementCompliance {
+    /** IPv4 or IPv6 address of the individual (i.e., end-customer) that initiated this request. NOT the IP of the partner server making the API call. */
+    requesterIpAddress?: string;
+    /** Information about the person receiving this disbursement. Required by some entity configurations to meet regulatory requirements for fund transfers. When required, omitting this field or leaving required sub-fields empty returns a 400 listing the specific fields needed. */
+    recipient?: Person;
+}
+export declare const DisbursementCompliance: S.Schema<DisbursementCompliance>;
+export interface CreateDisbursementRequest {
+    /** The source from which to fund the disbursement. */
+    source: TransfersAccount;
+    /** The target receiving the disbursement. */
+    target: DisbursementTarget;
+    /** A decimal representation of the amount to disburse, denominated in `asset`. */
+    amount: string;
+    /** The symbol of the asset for the disbursement amount. */
+    asset: string;
+    /** Human-readable reason for the disbursement. */
+    reason?: string;
+    /** A merchant-provided internal identifier for this disbursement, from the merchant's own system—not visible to the payer. It must not contain personally identifiable information (PII) or payment credentials. */
+    externalReferenceId?: string;
+    /** Optional customer-facing display data for this disbursement, shown to the payer. If `referenceCode` is omitted, one is auto-generated — disbursements have no payment session to fall back to, unlike every other action type. */
+    customerDisplay?: OperationCustomerDisplay;
+    metadata?: Metadata;
+    /** Compliance context for this disbursement. Carries recipient information required by some entity configurations to meet regulatory requirements. */
+    compliance?: DisbursementCompliance;
+}
+export declare const CreateDisbursementRequest: S.Schema<CreateDisbursementRequest>;
+/** The onchain transactions associated with this disbursement. */
+export type DisbursementOnchainTransactionsList = Array<OnchainTransaction>;
+export declare const DisbursementOnchainTransactionsList: S.Schema<DisbursementOnchainTransactionsList>;
+/** A Disbursement represents a merchant-initiated payment of funds from a CDP account they own to a Coinbase account or onchain address. Used for standalone refunds, goodwill disbursements, rebates, and other merchant-driven payouts that are not tied to a specific payment session. Disbursements are asynchronous: the resource is returned in `pending` status and transitions to `succeeded` (with associated `onchainTransactions`) or `failed` (with `error`). */
+export interface Disbursement {
+    /** The unique identifier of the disbursement. */
+    disbursementId: string;
+    /** The source from which the disbursement is funded. */
+    source: TransfersAccount;
+    /** The target receiving the disbursement. */
+    target: DisbursementTarget;
+    /** A decimal representation of the disbursed amount, denominated in `asset`. */
+    amount: string;
+    /** The symbol of the asset for the disbursement amount. */
+    asset: string;
+    /** The current status of the disbursement. */
+    status: PaymentActionStatus;
+    /** Human-readable reason for the disbursement. */
+    reason?: string;
+    /** A merchant-provided internal identifier for this disbursement, from the merchant's own system—not visible to the payer. It must not contain personally identifiable information (PII) or payment credentials. */
+    externalReferenceId?: string;
+    /** Customer-facing display data for this disbursement, shown to the payer. Always present: if the create request omits `referenceCode`, one is auto-generated, since disbursements have no payment session to fall back to. */
+    customerDisplay?: OperationCustomerDisplay;
+    metadata?: Metadata;
+    /** Error details, present only when the disbursement failed. */
+    error?: PaymentError;
+    /** The onchain transactions associated with this disbursement. */
+    onchainTransactions?: DisbursementOnchainTransactionsList;
+    /** The UTC ISO 8601 timestamp at which the disbursement was created. */
+    createdAt: string;
+    /** The UTC ISO 8601 timestamp at which the disbursement was last updated. */
+    updatedAt: string;
+}
+export declare const Disbursement: S.Schema<Disbursement>;
 /** The type of authentication information. */
 export type EmailAuthenticationType = "email";
 export declare const EmailAuthenticationType: any;
@@ -449,13 +1293,12 @@ export interface EIP712Message {
     message: unknown;
 }
 export declare const EIP712Message: S.Schema<EIP712Message>;
-/** The approval object which contains the necessary fields to submit an approval for this transaction. Null if the `fromToken` is the native token or the transaction is a native token wrap / unwrap. */
-export interface CreateSwapQuoteResponsePermit2 {
+export interface SwapPermit2Approval {
     /** The hash for the approval according to [EIP-712](https://eips.ethereum.org/EIPS/eip-712). Computing the hash of the `eip712` field should match the value of this field. */
     hash: string;
     eip712: EIP712Message;
 }
-export declare const CreateSwapQuoteResponsePermit2: S.Schema<CreateSwapQuoteResponsePermit2>;
+export declare const SwapPermit2Approval: S.Schema<SwapPermit2Approval>;
 /** The details of the transaction to be signed and submitted to execute the swap. */
 export interface CreateSwapQuoteResponseTransaction {
     /** The 0x-prefixed address of the contract to call. */
@@ -485,16 +1328,14 @@ export interface CreateSwapQuoteResponseFees {
     protocolFee: TokenFee | null;
 }
 export declare const CreateSwapQuoteResponseFees: S.Schema<CreateSwapQuoteResponseFees>;
-/** Details of the allowances that the taker must set in order to execute the swap successfully. Null if no allowance is required. */
-export interface CreateSwapQuoteResponseIssuesAllowance {
+export interface CommonSwapResponseIssuesAllowance {
     /** The current allowance of the `fromToken` by the `taker`. */
     currentAllowance: string;
     /** The 0x-prefixed address of to set the allowance on. */
     spender: string;
 }
-export declare const CreateSwapQuoteResponseIssuesAllowance: S.Schema<CreateSwapQuoteResponseIssuesAllowance>;
-/** Details of the balance of the `fromToken` that the `taker` must hold. Null if the `taker` has a sufficient balance. */
-export interface CreateSwapQuoteResponseIssuesBalance {
+export declare const CommonSwapResponseIssuesAllowance: S.Schema<CommonSwapResponseIssuesAllowance>;
+export interface CommonSwapResponseIssuesBalance {
     /** The 0x-prefixed contract address of the token. */
     token: string;
     /** The current balance of the `fromToken` by the `taker`. */
@@ -502,20 +1343,20 @@ export interface CreateSwapQuoteResponseIssuesBalance {
     /** The amount of the token that the `taker` must hold. */
     requiredBalance: string;
 }
-export declare const CreateSwapQuoteResponseIssuesBalance: S.Schema<CreateSwapQuoteResponseIssuesBalance>;
+export declare const CommonSwapResponseIssuesBalance: S.Schema<CommonSwapResponseIssuesBalance>;
 /** An object containing potential issues discovered during validation that could prevent the swap from being executed successfully. */
 export interface CreateSwapQuoteResponseIssues {
     /** Details of the allowances that the taker must set in order to execute the swap successfully. Null if no allowance is required. */
-    allowance: CreateSwapQuoteResponseIssuesAllowance | null;
+    allowance: CommonSwapResponseIssuesAllowance | null;
     /** Details of the balance of the `fromToken` that the `taker` must hold. Null if the `taker` has a sufficient balance. */
-    balance: CreateSwapQuoteResponseIssuesBalance | null;
+    balance: CommonSwapResponseIssuesBalance | null;
     /** This is set to true when the transaction cannot be validated. This can happen when the taker has an insufficient balance of the `fromToken`. Note that this does not necessarily mean that the trade will revert. */
     simulationIncomplete: boolean;
 }
 export declare const CreateSwapQuoteResponseIssues: S.Schema<CreateSwapQuoteResponseIssues>;
 export interface CreateSwapQuoteResponse {
     /** The approval object which contains the necessary fields to submit an approval for this transaction. Null if the `fromToken` is the native token or the transaction is a native token wrap / unwrap. */
-    permit2: CreateSwapQuoteResponsePermit2 | null;
+    permit2: SwapPermit2Approval | null;
     /** The details of the transaction to be signed and submitted to execute the swap. */
     transaction: CreateSwapQuoteResponseTransaction;
     /** The block number at which the liquidity conditions were examined. */
@@ -549,10 +1390,13 @@ export declare const CreateSwapQuoteResponseWrapper: S.Schema<CreateSwapQuoteRes
 export type CreateEvmSwapQuoteResponse = CreateSwapQuoteResponseWrapper;
 export declare const CreateEvmSwapQuoteResponse: S.Schema<CreateEvmSwapQuoteResponse>;
 export interface CreateFoundationAccountRequest {
+    /** The Owner of the Account to create. * If omitted, the account will be owned by the Entity making the request. * If the account is for a customer, the value will be a Customer ID, e.g. `customer_af2937b0-9846-4fe7-bfe9-ccc22d935114`. * Further, the corresponding Customer must have all of the following capabilities enabled: - `custodyCrypto` - `custodyFiat` - `custodyStablecoin`. */
+    owner?: string;
     name?: string;
+    compliance?: Compliance;
 }
 export declare const CreateFoundationAccountRequest: S.Schema<CreateFoundationAccountRequest>;
-/** The type of the Account. */
+/** The type of the Account. - `prime`: a linked Coinbase Prime account. - `business`: a linked Coinbase Business account. - `cdp`: a CDP-native account created via this API. Used for accounts created on behalf of an Entity and for Customer-owned accounts. */
 export type AccountType = "prime" | "business" | "cdp";
 export declare const AccountType: any;
 export interface Account {
@@ -571,13 +1415,13 @@ export type OnrampOrderPaymentMethodTypeId = "GUEST_CHECKOUT_APPLE_PAY" | "GUEST
 export declare const OnrampOrderPaymentMethodTypeId: any;
 export interface CreateOnrampOrderRequest {
     /** The timestamp of when the user acknowledged that by using Coinbase Onramp they are accepting the Coinbase Terms (https://www.coinbase.com/legal/guest-checkout/us), User Agreement (https://www.coinbase.com/legal/user_agreement), and Privacy Policy (https://www.coinbase.com/legal/privacy). */
-    agreementAcceptedAt: string;
+    agreementAcceptedAt?: string;
     /** The address the purchased crypto will be sent to. */
     destinationAddress: string;
     /** The name of the crypto network the purchased currency will be sent on. Use the [Onramp Buy Options API](https://docs.cdp.coinbase.com/api-reference/rest-api/onramp-offramp/get-buy-options) to discover the supported networks for your user's location. */
     destinationNetwork: string;
     /** The verified email address of the user requesting the onramp transaction. This email must be verified by your app (via OTP) before being used with the Onramp API. */
-    email: string;
+    email?: string;
     /** If true, this API will return a quote without creating any transaction. */
     isQuote?: boolean;
     /** Optional partner order reference ID. */
@@ -589,10 +1433,10 @@ export interface CreateOnrampOrderRequest {
     /** The fiat currency to be converted to crypto. */
     paymentCurrency: string;
     paymentMethod: OnrampOrderPaymentMethodTypeId | (string & {});
-    /** The phone number of the user requesting the onramp transaction in E.164 format. This phone number must be verified by your app (via OTP) before being used with the Onramp API. Please refer to the [Onramp docs](https://docs.cdp.coinbase.com/onramp-&-offramp/onramp-apis/apple-pay-onramp-api) for more details on phone number verification requirements and best practices. */
-    phoneNumber: string;
+    /** The phone number of the user requesting the onramp transaction in E.164 format. This phone number must be verified by your app (via OTP) before being used with the Onramp API. Please refer to the [Onramp docs](https://docs.cdp.coinbase.com/onramp/headless-onramp/overview) for more details on phone number verification requirements and best practices. */
+    phoneNumber?: string;
     /** Timestamp of when the user's phone number was verified via OTP. User phone number must be verified every 60 days. If this timestamp is older than 60 days, an error will be returned. */
-    phoneNumberVerifiedAt: string;
+    phoneNumberVerifiedAt?: string;
     /** The SMS verification ID returned by the Submit Onramp Verification endpoint after verifying the user's phone number. When provided, Onramp validates the server-side verification record instead of trusting `phoneNumberVerifiedAt`. */
     smsVerificationId?: string;
     /** The email verification ID returned by the Submit Onramp Verification endpoint after verifying the user's email address. */
@@ -603,8 +1447,12 @@ export interface CreateOnrampOrderRequest {
     purchaseCurrency: string;
     /** The IP address of the end user requesting the onramp transaction. */
     clientIp?: string;
-    /** The domain that the Apple Pay button will be rendered on. Required when using the `GUEST_CHECKOUT_APPLE_PAY` payment method and embedding the payment link in an iframe. */
+    /** The domain that the Apple Pay or Google Pay button will be rendered on. Required when using the `GUEST_CHECKOUT_APPLE_PAY` or `GUEST_CHECKOUT_GOOGLE_PAY` payment method and embedding the payment link in an iframe. Omit this field entirely for mobile iOS Apple Pay via WebView integration. */
     domain?: string;
+    /** Optional [BCP-47](https://www.rfc-editor.org/info/bcp47) locale tag (e.g. `es-ES`, `pt-BR`, `en`) used to localize the hosted payment page. When provided, it is appended to the returned `paymentLink` URL and mapped to the closest locale supported by the Apple Pay and Google Pay buttons; unsupported locales fall back to the user's browser language. Any well-formed BCP-47 tag is accepted. */
+    locale?: string;
+    /** Optional. A reusable token returned by a previous verified order. When provided, a returning user checking out to the same wallet is taken straight to the pay button, skipping OTP (best-effort — an invalid, expired, or different-wallet token still requires verification). */
+    userAuthToken?: string;
 }
 export declare const CreateOnrampOrderRequest: S.Schema<CreateOnrampOrderRequest>;
 /** The type of fee. */
@@ -624,7 +1472,7 @@ export declare const OnrampOrderFee: S.Schema<OnrampOrderFee>;
 export type OnrampOrderFeesList = Array<OnrampOrderFee>;
 export declare const OnrampOrderFeesList: S.Schema<OnrampOrderFeesList>;
 /** The status of an onramp order. */
-export type OnrampOrderStatus = "ONRAMP_ORDER_STATUS_PENDING_AUTH" | "ONRAMP_ORDER_STATUS_PENDING_PAYMENT" | "ONRAMP_ORDER_STATUS_PROCESSING" | "ONRAMP_ORDER_STATUS_COMPLETED" | "ONRAMP_ORDER_STATUS_FAILED";
+export type OnrampOrderStatus = "ONRAMP_ORDER_STATUS_PENDING_AUTH" | "ONRAMP_ORDER_STATUS_PENDING_VERIFICATION" | "ONRAMP_ORDER_STATUS_PENDING_PAYMENT" | "ONRAMP_ORDER_STATUS_PROCESSING" | "ONRAMP_ORDER_STATUS_COMPLETED" | "ONRAMP_ORDER_STATUS_FAILED";
 export declare const OnrampOrderStatus: any;
 /** An Onramp order. */
 export interface OnrampOrder {
@@ -661,7 +1509,7 @@ export interface OnrampOrder {
 }
 export declare const OnrampOrder: S.Schema<OnrampOrder>;
 /** The type of payment link. */
-export type OnrampPaymentLinkType = "PAYMENT_LINK_TYPE_APPLE_PAY_BUTTON";
+export type OnrampPaymentLinkType = "PAYMENT_LINK_TYPE_APPLE_PAY_BUTTON" | "PAYMENT_LINK_TYPE_GOOGLE_PAY_BUTTON" | "PAYMENT_LINK_TYPE_EMBEDDED_ORDER";
 export declare const OnrampPaymentLinkType: any;
 /** A payment link to pay for an order. Please refer to the [Onramp docs](https://docs.cdp.coinbase.com/onramp-&-offramp/onramp-apis/onramp-overview) for details on how to integrate with the different payment link types. */
 export interface OnrampPaymentLink {
@@ -673,6 +1521,8 @@ export declare const OnrampPaymentLink: S.Schema<OnrampPaymentLink>;
 export interface CreateOnrampOrderResponse {
     order: OnrampOrder;
     paymentLink?: OnrampPaymentLink;
+    /** Present for embedded orders once the user has verified. Store this and pass it on future orders for the same user to skip OTP verification. Valid for 60 days. */
+    userAuthToken?: string;
 }
 export declare const CreateOnrampOrderResponse: S.Schema<CreateOnrampOrderResponse>;
 /** The type of payment method used to generate the onramp quote. */
@@ -738,6 +1588,33 @@ export interface CreateOnrampSessionResponse {
     quote?: OnrampQuote;
 }
 export declare const CreateOnrampSessionResponse: S.Schema<CreateOnrampSessionResponse>;
+/** Compliance context for a payment session request. Extends the base Compliance schema with buyer information required for travel rule obligations. This object is request-only — it is never echoed back in responses. */
+export interface PaymentSessionCompliance {
+    /** IPv4 or IPv6 address of the individual (i.e., end-customer) that initiated this request. NOT the IP of the partner server making the API call. */
+    requesterIpAddress?: string;
+    /** Information about the person paying. Required by some entity configurations to meet regulatory requirements for fund transfers. When required, omitting this field or leaving required sub-fields empty returns a 400 listing the specific fields needed. */
+    buyer?: Person;
+}
+export declare const PaymentSessionCompliance: S.Schema<PaymentSessionCompliance>;
+export interface CreatePaymentSessionRequest {
+    /** A decimal representation of the payment amount, denominated in `asset`. */
+    amount: string;
+    /** The symbol of the asset for the payment amount. */
+    asset: string;
+    /** The target of the payment session. */
+    target: PaymentSessionTarget;
+    expiries?: PaymentExpiries;
+    redirect?: PaymentRedirect;
+    /** When true, a capture is automatically created after a successful authorization. When false or omitted, the merchant must create captures manually via the captures endpoint. */
+    autoCapture?: boolean;
+    /** A merchant-provided internal identifier for this payment session, from the merchant's own system—not visible to the payer. It must not contain personally identifiable information (PII) or payment credentials. */
+    externalReferenceId?: string;
+    customerDisplay?: CustomerDisplay;
+    metadata?: Metadata;
+    /** Compliance context for this payment session. Carries buyer information required by some entity configurations to meet regulatory requirements. */
+    compliance?: PaymentSessionCompliance;
+}
+export declare const CreatePaymentSessionRequest: S.Schema<CreatePaymentSessionRequest>;
 /** The scope of the policy. */
 export type CreatePolicyRequestScope = "project" | "account";
 export declare const CreatePolicyRequestScope: any;
@@ -1846,6 +2723,7 @@ export declare const UserOperationReceipt: S.Schema<UserOperationReceipt>;
 /** The list of receipts associated with the user operation. */
 export type EvmUserOperationReceiptsList = Array<UserOperationReceipt>;
 export declare const EvmUserOperationReceiptsList: S.Schema<EvmUserOperationReceiptsList>;
+/** A smart account operation response. */
 export interface EvmUserOperation {
     network: EvmUserOperationNetwork;
     /** The hash of the user operation. This is not the transaction hash, as a transaction consists of multiple user operations. The user operation hash is the hash of this particular user operation which gets signed by the owner of the Smart Account. */
@@ -1862,34 +2740,14 @@ export interface EvmUserOperation {
     expiresAt?: string;
 }
 export declare const EvmUserOperation: S.Schema<EvmUserOperation>;
-/** The Account specific details for the transfer. */
-export interface TransfersAccount {
-    /** The ID of the Account. */
-    accountId: string;
-    asset: string;
-}
-export declare const TransfersAccount: S.Schema<TransfersAccount>;
 /** The Payment Method specific details for the transfer. */
 export interface PaymentMethod {
     /** The ID of the Payment Method. */
     paymentMethodId: string;
+    /** The asset symbol. Supported values are `usd` and `eur`. */
     asset: string;
 }
 export declare const PaymentMethod: S.Schema<PaymentMethod>;
-/** The source of the transfer. */
-export type CreateTransferSource = TransfersAccount | PaymentMethod;
-export declare const CreateTransferSource: S.Schema<CreateTransferSource>;
-/** The target of the payment is an onchain address. */
-export interface OnchainAddress {
-    /** The onchain crypto address of the recipient. Examples: - EVM address: 0xabc1234567890abcdef1234567890abcdef123456 - Solana address: HpabPRRCFbBKSuJr5PdkVvQc85FyxyTWkFM2obBRSvHT - XRP address: rhccc5p23aKiCGFcEqqnjEfLRZ6xEvfy3s */
-    address: string;
-    network: Network | (string & {});
-    /** The destination tag of the onchain address. Destination tags are used by certain networks (primarily XRP/Ripple) to identify specific recipients when multiple users share a single address. The tag ensures funds are credited to the correct account within the shared address. Examples by network: - XRP/Ripple: Numeric values like "1234567890" or "123456" - Stellar (XLM): Memos which can be text, ID, or hash format Note: Most networks (Ethereum, Bitcoin, Solana) do not use destination tags. */
-    destinationTag?: string;
-    /** Asset symbol of the payment received by the recipient. */
-    asset: string;
-}
-export declare const OnchainAddress: S.Schema<OnchainAddress>;
 /** The target of the payment is an email address. */
 export interface EmailInstrument {
     /** The email address of the recipient. The recipient will need to have an account with Coinbase or onboard to Coinbase to receive the payment. */
@@ -1904,30 +2762,14 @@ export declare const TransferTarget: S.Schema<TransferTarget>;
 /** Specifies whether the given amount is to be received by the target or taken from the source. - `target`: The transfer `target` receives the exact value specified in `amount`. Fees are added to the amount taken from the transfer `source`. - `source`: The transfer `target` receives the value specified in `amount`, minus any fees. */
 export type CreateTransferRequestAmountType = "target" | "source";
 export declare const CreateTransferRequestAmountType: any;
-/** A physical address with standard address components including street, city, state/province, postal code, and country. */
-export interface PhysicalAddress {
-    /** Primary street address. */
-    line1?: string;
-    /** Secondary address information. */
-    line2?: string;
-    /** City or locality. */
-    city?: string;
-    /** State, province, or region. */
-    state?: string;
-    /** Postal or ZIP code. */
-    postCode?: string;
-    /** ISO 3166-1 alpha-2 country code (2 characters). See https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes. */
-    countryCode?: string;
-}
-export declare const PhysicalAddress: S.Schema<PhysicalAddress>;
 /** Information about the originating Virtual Asset Service Provider (VASP) that handles cryptocurrency or other virtual assets on behalf of customers. */
 export interface TravelRuleOriginatorVirtualAssetServiceProvider {
+    /** The Legal Entity Identifier of the originating Virtual Asset Service Provider (VASP). */
+    identifier?: string;
     /** The name of the originating Virtual Asset Service Provider (VASP). */
     name?: string;
     /** The address of the originating Virtual Asset Service Provider (VASP). */
-    address?: PhysicalAddress;
-    /** The Legal Entity Identifier of the originating Virtual Asset Service Provider (VASP). */
-    identifier?: string;
+    address?: IndividualInputAddress;
 }
 export declare const TravelRuleOriginatorVirtualAssetServiceProvider: S.Schema<TravelRuleOriginatorVirtualAssetServiceProvider>;
 /** Date of birth. */
@@ -1942,11 +2784,11 @@ export interface DateOfBirth {
 export declare const DateOfBirth: S.Schema<DateOfBirth>;
 /** Originator (sender) party. */
 export interface TravelRuleOriginator {
-    /** Name of the financial institution. */
-    financialInstitution?: string;
     /** Full name of the party. */
     name?: string;
-    address?: PhysicalAddress;
+    address?: IndividualInputAddress;
+    /** Name of the financial institution. */
+    financialInstitution?: string;
     /** Information about the originating Virtual Asset Service Provider (VASP) that handles cryptocurrency or other virtual assets on behalf of customers. */
     virtualAssetServiceProvider?: TravelRuleOriginatorVirtualAssetServiceProvider;
     /** Personal identifier for travel rule compliance. For individuals: passport number, national ID, or driver's license. For institutions: LEI (Legal Entity Identifier). */
@@ -1960,11 +2802,11 @@ export type TravelRuleBeneficiaryWalletType = "custodial" | "self_custody";
 export declare const TravelRuleBeneficiaryWalletType: any;
 /** Beneficiary (receiver) party. */
 export interface TravelRuleBeneficiary {
-    /** Name of the financial institution. */
-    financialInstitution?: string;
     /** Full name of the party. */
     name?: string;
-    address?: PhysicalAddress;
+    address?: IndividualInputAddress;
+    /** Name of the financial institution. */
+    financialInstitution?: string;
     /** The type of the beneficiary's wallet. */
     walletType?: TravelRuleBeneficiaryWalletType | (string & {});
 }
@@ -1973,14 +2815,15 @@ export declare const TravelRuleBeneficiary: S.Schema<TravelRuleBeneficiary>;
 export interface TravelRule {
     /** Indicates whether the user attests that the receiving wallet belongs to them. */
     isSelf?: boolean;
-    /** Indicates whether Coinbase is being used as an intermediary Virtual Asset Service Provider (VASP) to send crypto on behalf of your customer. **Background:** The Travel Rule (FATF Recommendation 16) requires VASPs to share originator and beneficiary information for virtual asset transfers. When Coinbase acts as an intermediary, additional Travel Rule data must be provided to satisfy compliance requirements. **Set to `true` when:** - Your organization is a VASP using Coinbase to send crypto **on behalf of your end customer** - In this scenario, Coinbase acts as an intermediary in the transfer chain and handles Travel Rule data exchange with the beneficiary VASP **Set to `false` (or omit) when:** - You are transferring funds directly from your own Coinbase account, where **Coinbase is your primary VASP** rather than an intermediary for another institution **Impact on required fields:** When `isIntermediary` is `true`, you must provide the `originator` object with details about the **original sender**, including: - Originator name - Originator address - Your VASP information (`virtualAssetServiceProvider` object with `name`, `address`, and `identifier`) For jurisdictions that require them (such as Coinbase Luxembourg), `personalIdentification` and `dateOfBirth` must also reflect the **original sender's** identity — not the intermediary's. These fields will not be auto-populated from any internal KYC data when `isIntermediary` is `true`. */
     isIntermediary?: boolean;
+    /** When `true`, you attest that the beneficiary's wallet ownership has been verified out-of-band. Instructs Coinbase to skip the wallet verification check for this transfer. **Only valid when `isIntermediary` is `true`.** You can only attest to the beneficiary's wallet ownership when your organization is acting as the originating VASP on behalf of your end customer, and Coinbase is acting as the intermediary VASP. Returns a `400` error if set to `true` when `isIntermediary` is `false` or omitted. */
+    attestVerifiedWalletOwnership?: boolean;
     originator?: TravelRuleOriginator;
     beneficiary?: TravelRuleBeneficiary;
 }
 export declare const TravelRule: S.Schema<TravelRule>;
 export interface CreateTransferRequest {
-    source: CreateTransferSource;
+    source: TransfersAccount;
     target: TransferTarget;
     /** The amount of the transfer, as a decimal string in standard unit denomination of the asset specified by `asset` (e.g., "100.00" for 100 USD, "0.05" for 0.05 ETH). */
     amount: string;
@@ -2000,18 +2843,37 @@ export declare const CreateTransferRequest: S.Schema<CreateTransferRequest>;
 /** The current status of the transfer, indicating what action you need to take next. Required when validateOnly is false. */
 export type TransferStatus = "quoted" | "processing" | "completed" | "failed";
 export declare const TransferStatus: any;
-/** The originating US bank account details for the transfer source. Present when funds were deposited from an external bank account into a deposit destination. Only the last 4 digits of the account number are exposed. */
-export interface OriginatingBankAccountUS {
-    /** The name of the bank that originated the deposit. */
-    bankName: string;
-    /** The last 4 digits of the originating bank account number. */
-    accountLast4: string;
-    /** The fiat currency of the deposit (e.g., `usd`). */
+/** The originating ACH deposit details for the transfer source. Present when funds were deposited via ACH into a deposit destination. */
+export interface AchDepositSource {
+    /** The fiat currency of the ACH deposit (e.g., `usd`). */
     currency: string;
-}
-export declare const OriginatingBankAccountUS: S.Schema<OriginatingBankAccountUS>;
+    /** The company name from the ACH batch header record. Masked on webhook payloads. */
+    companyName: string;
+    /** The company entry description from the ACH batch header record. */
+    companyEntryDescription: string;
+    /** The individual identification number from the ACH entry detail record. For Person-to-Person WEB credit Entries, this field is required and contains the name of the consumer Originator. Masked on webhook payloads. */
+    individualIdentificationNumber?: string;
+}
+export declare const AchDepositSource: S.Schema<AchDepositSource>;
+/** The Originator to Beneficiary Information (OBI) lines from the Fedwire message. Up to 4 lines, each up to 35 characters. Free-form and may contain identifying information about the originator. Masked on webhook payloads. */
+export type FedwireDepositSourceOriginatorToBeneficiaryList = Array<string>;
+export declare const FedwireDepositSourceOriginatorToBeneficiaryList: S.Schema<FedwireDepositSourceOriginatorToBeneficiaryList>;
+/** The originating Fedwire deposit details for the transfer source. Present when funds were deposited via Fedwire into a deposit destination. */
+export interface FedwireDepositSource {
+    /** The fiat currency of the Fedwire deposit (e.g., `usd`). */
+    currency: string;
+    /** The Output Message Accountability Data (OMAD), a unique identifier assigned by the Fedwire network to the wire transfer message. */
+    omad: string;
+    /** The originator's bank account number. Masked on webhook payloads. */
+    accountNumber: string;
+    /** The name of the originator. Masked on webhook payloads. */
+    originatorName: string;
+    /** The Originator to Beneficiary Information (OBI) lines from the Fedwire message. Up to 4 lines, each up to 35 characters. Free-form and may contain identifying information about the originator. Masked on webhook payloads. */
+    originatorToBeneficiary?: FedwireDepositSourceOriginatorToBeneficiaryList;
+}
+export declare const FedwireDepositSource: S.Schema<FedwireDepositSource>;
 /** The source of the transfer. */
-export type TransferSource = TransfersAccount | PaymentMethod | OnchainAddress | OriginatingBankAccountUS;
+export type TransferSource = TransfersAccount | PaymentMethod | OnchainAddress | AchDepositSource | FedwireDepositSource;
 export declare const TransferSource: S.Schema<TransferSource>;
 /** Exchange rate information for currency conversion. The rate indicates how much of the target asset is equivalent to one unit of the source asset. */
 export interface TransferExchangeRate {
@@ -2062,7 +2924,7 @@ export declare const DepositDestinationReference: S.Schema<DepositDestinationRef
 export interface TransferDetailsOnchainTransactionsItem {
     /** The transaction hash. */
     transactionHash: string;
-    network: Network;
+    network: PaymentNetwork;
 }
 export declare const TransferDetailsOnchainTransactionsItem: S.Schema<TransferDetailsOnchainTransactionsItem>;
 /** The onchain transactions associated with the transfer. */
@@ -2124,7 +2986,7 @@ export interface Transfer {
 }
 export declare const Transfer: S.Schema<Transfer>;
 /** A webhook event type identifier following dot-separated format: `<domain>.<entity>.<verb>` (e.g., "onchain.activity.detected"). */
-export type EventType = "onchain.activity.detected" | "wallet.activity.detected" | "wallet.activity.multi" | "wallet.transaction.created" | "wallet.transaction.signed" | "wallet.transaction.broadcast" | "wallet.transaction.replaced" | "wallet.transaction.pending" | "wallet.transaction.confirmed" | "wallet.transaction.failed" | "wallet.delegation.created" | "wallet.delegation.revoked" | "wallet.typed_data.signed" | "wallet.message.signed" | "wallet.hash.signed" | "onramp.transaction.created" | "onramp.transaction.updated" | "onramp.transaction.success" | "onramp.transaction.failed" | "offramp.transaction.created" | "offramp.transaction.updated" | "offramp.transaction.success" | "offramp.transaction.failed";
+export type EventType = "onchain.activity.detected" | "wallet.activity.detected" | "wallet.activity.multi" | "wallet.transaction.created" | "wallet.transaction.signed" | "wallet.transaction.broadcast" | "wallet.transaction.replaced" | "wallet.transaction.pending" | "wallet.transaction.confirmed" | "wallet.transaction.failed" | "wallet.delegation.created" | "wallet.delegation.revoked" | "wallet.typed_data.signed" | "wallet.message.signed" | "wallet.hash.signed" | "payments.transfers.quoted" | "payments.transfers.processing" | "payments.transfers.completed" | "payments.transfers.failed" | "payments.transfers.expired" | "payments.transfers.travel_rule_incomplete" | "payments.transfers.travel_rule_completed" | "onramp.transaction.created" | "onramp.transaction.updated" | "onramp.transaction.success" | "onramp.transaction.failed" | "offramp.transaction.created" | "offramp.transaction.updated" | "offramp.transaction.success" | "offramp.transaction.failed" | "acceptance.payment_session.created" | "acceptance.payment_session.canceled" | "acceptance.payment_session.authorization_pending" | "acceptance.payment_session.authorization_succeeded" | "acceptance.payment_session.authorization_failed" | "acceptance.payment_session.capture_pending" | "acceptance.payment_session.capture_succeeded" | "acceptance.payment_session.capture_failed" | "acceptance.payment_session.refund_pending" | "acceptance.payment_session.refund_succeeded" | "acceptance.payment_session.refund_failed" | "acceptance.payment_session.void_pending" | "acceptance.payment_session.void_succeeded" | "acceptance.payment_session.void_failed" | "acceptance.disbursement.pending" | "acceptance.disbursement.succeeded" | "acceptance.disbursement.failed" | "health.status.updated" | "health.maintenance.scheduled" | "health.maintenance.started" | "health.maintenance.completed" | "health.maintenance.canceled" | "customers.capability.changed" | "customers.customer.deleted";
 export declare const EventType: any;
 /** Types of events to subscribe to. Event types follow a dot-separated format: service.resource.verb (e.g., "onchain.activity.detected", "wallet.activity.detected", "onramp.transaction.created", "acceptance.payment_session.authorization_succeeded"). The subscription will only receive events matching these types AND the label filter(s). */
 export type CreateWebhookSubscriptionRequestEventTypesList = Array<EventType | (string & {})>;
@@ -2148,7 +3010,6 @@ export type CreateWebhookSubscriptionRequestLabelsMap = {
 };
 export declare const CreateWebhookSubscriptionRequestLabelsMap: S.Schema<CreateWebhookSubscriptionRequestLabelsMap>;
 export interface CreateWebhookSubscriptionRequest {
-    /** Description of the webhook subscription. */
     description?: string;
     /** Types of events to subscribe to. Event types follow a dot-separated format: service.resource.verb (e.g., "onchain.activity.detected", "wallet.activity.detected", "onramp.transaction.created", "acceptance.payment_session.authorization_succeeded"). The subscription will only receive events matching these types AND the label filter(s). */
     eventTypes: CreateWebhookSubscriptionRequestEventTypesList;
@@ -2180,7 +3041,6 @@ export interface WebhookSubscriptionResponse {
     createdAt: string;
     /** When the subscription was last updated. */
     updatedAt?: string;
-    /** Description of the webhook subscription. */
     description?: string;
     /** Types of events to subscribe to. Event types follow a dot-separated format: service.resource.verb (e.g., "onchain.activity.detected", "wallet.activity.detected", "onramp.transaction.created", "acceptance.payment_session.authorization_succeeded"). */
     eventTypes: WebhookSubscriptionResponseEventTypesList;
@@ -2197,6 +3057,73 @@ export interface WebhookSubscriptionResponse {
     labels?: WebhookSubscriptionResponseLabelsMap;
 }
 export declare const WebhookSubscriptionResponse: S.Schema<WebhookSubscriptionResponse>;
+/** JSON-RPC version, must be "2.0". */
+export type CreateX402DiscoveryMcpRequestJsonrpc = "2.0";
+export declare const CreateX402DiscoveryMcpRequestJsonrpc: any;
+/** Request identifier. */
+export type CreateX402DiscoveryMcpRequestId = string | number;
+export declare const CreateX402DiscoveryMcpRequestId: S.Schema<CreateX402DiscoveryMcpRequestId>;
+/** Optional parameters for the method. */
+export type CreateX402DiscoveryMcpRequestParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const CreateX402DiscoveryMcpRequestParamsMap: S.Schema<CreateX402DiscoveryMcpRequestParamsMap>;
+export interface CreateX402DiscoveryMcpRequest {
+    /** JSON-RPC version, must be "2.0". */
+    jsonrpc: CreateX402DiscoveryMcpRequestJsonrpc | (string & {});
+    /** Request identifier. */
+    id?: CreateX402DiscoveryMcpRequestId;
+    /** The MCP method to invoke. */
+    method: string;
+    /** Optional parameters for the method. */
+    params?: CreateX402DiscoveryMcpRequestParamsMap;
+}
+export declare const CreateX402DiscoveryMcpRequest: S.Schema<CreateX402DiscoveryMcpRequest>;
+/** JSON-RPC version. */
+export type X402McpResponseJsonrpc = "2.0";
+export declare const X402McpResponseJsonrpc: any;
+/** Request identifier (matches the request ID, null for notifications). */
+export type X402McpResponseId = string | number;
+export declare const X402McpResponseId: S.Schema<X402McpResponseId>;
+/** The result of the method call (present on success). */
+export type X402McpResponseResultMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const X402McpResponseResultMap: S.Schema<X402McpResponseResultMap>;
+/** Additional error data. */
+export type X402McpErrorDataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const X402McpErrorDataMap: S.Schema<X402McpErrorDataMap>;
+/** JSON-RPC 2.0 error object. */
+export interface X402McpError {
+    /** Error code. */
+    code: number;
+    /** Error message. */
+    message: string;
+    /** Additional error data. */
+    data?: X402McpErrorDataMap;
+}
+export declare const X402McpError: S.Schema<X402McpError>;
+/** A JSON-RPC 2.0 response for the Model Context Protocol. */
+export interface X402McpResponse {
+    /** JSON-RPC version. */
+    jsonrpc: X402McpResponseJsonrpc;
+    /** Request identifier (matches the request ID, null for notifications). */
+    id?: X402McpResponseId | null;
+    /** The result of the method call (present on success). */
+    result?: X402McpResponseResultMap;
+    error?: X402McpError;
+}
+export declare const X402McpResponse: S.Schema<X402McpResponse>;
+export interface DeleteCustomerRequest {
+    /** The ID of the customer. */
+    customerId: string;
+}
+export declare const DeleteCustomerRequest: S.Schema<DeleteCustomerRequest>;
+export interface DeleteCustomerResponse {
+}
+export declare const DeleteCustomerResponse: S.Schema<DeleteCustomerResponse>;
 export interface DeletePolicyRequest {
     /** The ID of the policy to delete. */
     policyId: string;
@@ -2306,6 +3233,11 @@ export interface Balance {
     amount: BalanceAmountMap;
 }
 export declare const Balance: S.Schema<Balance>;
+export interface GetCustomerRequest {
+    /** The ID of the customer. */
+    customerId: string;
+}
+export declare const GetCustomerRequest: S.Schema<GetCustomerRequest>;
 export interface GetDelegationForEndUserRequest {
     /** The ID of the end user. */
     userId: string;
@@ -2332,13 +3264,18 @@ export interface GetDelegationForEndUserAccountResponse {
     expiresAt: string;
 }
 export declare const GetDelegationForEndUserAccountResponse: S.Schema<GetDelegationForEndUserAccountResponse>;
-export interface GetDepositDestinationByIdRequest {
+export interface GetDepositDestinationRequest {
     /** The ID of the deposit address to retrieve. */
     depositDestinationId: string;
 }
-export declare const GetDepositDestinationByIdRequest: S.Schema<GetDepositDestinationByIdRequest>;
-export type GetDepositDestinationByIdResponse = CryptoDepositDestination;
-export declare const GetDepositDestinationByIdResponse: S.Schema<GetDepositDestinationByIdResponse>;
+export declare const GetDepositDestinationRequest: S.Schema<GetDepositDestinationRequest>;
+export type GetDepositDestinationResponse = DepositDestination;
+export declare const GetDepositDestinationResponse: S.Schema<GetDepositDestinationResponse>;
+export interface GetDisbursementRequest {
+    /** The unique identifier of the disbursement. */
+    disbursementId: string;
+}
+export declare const GetDisbursementRequest: S.Schema<GetDisbursementRequest>;
 export interface GetEndUserRequest {
     /** The ID of the end user to get. */
     userId: string;
@@ -2354,11 +3291,11 @@ export interface GetEvmAccountByNameRequest {
     name: string;
 }
 export declare const GetEvmAccountByNameRequest: S.Schema<GetEvmAccountByNameRequest>;
-export interface GetEvmEip7702DelegationOperationByIdRequest {
+export interface GetEvmEip7702DelegationOperationRequest {
     /** The unique identifier for the delegation operation. */
     delegationOperationId: string;
 }
-export declare const GetEvmEip7702DelegationOperationByIdRequest: S.Schema<GetEvmEip7702DelegationOperationByIdRequest>;
+export declare const GetEvmEip7702DelegationOperationRequest: S.Schema<GetEvmEip7702DelegationOperationRequest>;
 /** The current status of the delegation operation. UNSPECIFIED means the status has not been set. PENDING means the operation has been created but not yet submitted. SUBMITTED means the operation has been submitted to the network. COMPLETED means the operation has completed successfully. FAILED means the operation has failed. */
 export type EvmEip7702DelegationOperationStatus = "UNSPECIFIED" | "PENDING" | "SUBMITTED" | "COMPLETED" | "FAILED";
 export declare const EvmEip7702DelegationOperationStatus: any;
@@ -2399,12 +3336,6 @@ export declare const GetEvmSwapPriceRequest: S.Schema<GetEvmSwapPriceRequest>;
 /** The estimated fees for the swap. */
 export type GetSwapPriceResponseFees = CreateSwapQuoteResponseFees;
 export declare const GetSwapPriceResponseFees: S.Schema<CreateSwapQuoteResponseFees>;
-/** Details of the allowances that the taker must set in order to execute the swap successfully. Null if no allowance is required. */
-export type GetSwapPriceResponseIssuesAllowance = CreateSwapQuoteResponseIssuesAllowance;
-export declare const GetSwapPriceResponseIssuesAllowance: S.Schema<CreateSwapQuoteResponseIssuesAllowance>;
-/** Details of the balance of the `fromToken` that the `taker` must hold. Null if the `taker` has a sufficient balance. */
-export type GetSwapPriceResponseIssuesBalance = CreateSwapQuoteResponseIssuesBalance;
-export declare const GetSwapPriceResponseIssuesBalance: S.Schema<CreateSwapQuoteResponseIssuesBalance>;
 /** An object containing potential issues discovered during validation that could prevent the swap from being executed successfully. */
 export type GetSwapPriceResponseIssues = CreateSwapQuoteResponseIssues;
 export declare const GetSwapPriceResponseIssues: S.Schema<CreateSwapQuoteResponseIssues>;
@@ -2443,15 +3374,15 @@ export interface GetFoundationAccountByIdRequest {
     accountId: string;
 }
 export declare const GetFoundationAccountByIdRequest: S.Schema<GetFoundationAccountByIdRequest>;
-export interface GetOnrampOrderByIdRequest {
+export interface GetOnrampOrderRequest {
     /** The ID of the onramp order to retrieve. */
     orderId: string;
 }
-export declare const GetOnrampOrderByIdRequest: S.Schema<GetOnrampOrderByIdRequest>;
-export interface GetOnrampOrderByIdResponse {
+export declare const GetOnrampOrderRequest: S.Schema<GetOnrampOrderRequest>;
+export interface GetOnrampOrderResponse {
     order: OnrampOrder;
 }
-export declare const GetOnrampOrderByIdResponse: S.Schema<GetOnrampOrderByIdResponse>;
+export declare const GetOnrampOrderResponse: S.Schema<GetOnrampOrderResponse>;
 /** The type of user identifier: - `phone_number`: A phone number in E.164 format associated with an onramp user. */
 export type OnrampUserIdType = "phone_number";
 export declare const OnrampUserIdType: any;
@@ -2479,9 +3410,42 @@ export declare const OnrampUserLimit: S.Schema<OnrampUserLimit>;
 /** The list of limits applicable to the user. */
 export type GetOnrampUserLimitsResponseLimitsList = Array<OnrampUserLimit>;
 export declare const GetOnrampUserLimitsResponseLimitsList: S.Schema<GetOnrampUserLimitsResponseLimitsList>;
+/** The status of verification: - `unrequested`: The limit upgrade has not been submitted. - `resubmit`: One or more identity fields must be resubmitted. - `pending`: The submitted identity fields are pending review. - `active`: The limit upgrade is active. - `inactive`: The limit upgrade was rejected and cannot be resubmitted. */
+export type OnrampLimitUpgradeStatus = "unrequested" | "resubmit" | "pending" | "active" | "inactive";
+export declare const OnrampLimitUpgradeStatus: any;
+/** The identity field key for limit upgrades. These keys correspond to the fields in the limits upgrade request: - `ssnLast4`: Last 4 digits of the Social Security Number - `dateOfBirth`: Date of birth */
+export type OnrampLimitUpgradeIdentityFieldKey = "ssnLast4" | "dateOfBirth";
+export declare const OnrampLimitUpgradeIdentityFieldKey: any;
+/** The identity fields associated with the current status. Contains fields to submit for `unrequested` and `resubmit`, fields pending review for `pending`, and is empty for `active` and `inactive`. */
+export type OnrampLimitUpgradeOptionFieldsList = Array<OnrampLimitUpgradeIdentityFieldKey>;
+export declare const OnrampLimitUpgradeOptionFieldsList: S.Schema<OnrampLimitUpgradeOptionFieldsList>;
+/** Describes a limit value associated with an upgrade. */
+export interface OnrampLimitUpgrade {
+    limitType: OnrampLimitType;
+    /** The maximum limit value possible after completing the upgrade. Risk factors may impact the actual limit value that takes effect. For `lifetime_transactions`, `2147483647` represents an unlimited number of transactions. */
+    maxUpgrade: string;
+}
+export declare const OnrampLimitUpgrade: S.Schema<OnrampLimitUpgrade>;
+/** The limit values associated with this upgrade. */
+export type OnrampLimitUpgradeOptionLimitUpgradesList = Array<OnrampLimitUpgrade>;
+export declare const OnrampLimitUpgradeOptionLimitUpgradesList: S.Schema<OnrampLimitUpgradeOptionLimitUpgradesList>;
+/** Describes the current status and potential limit changes for a limit upgrade. */
+export interface OnrampLimitUpgradeOption {
+    status: OnrampLimitUpgradeStatus;
+    /** The identity fields associated with the current status. Contains fields to submit for `unrequested` and `resubmit`, fields pending review for `pending`, and is empty for `active` and `inactive`. */
+    fields: OnrampLimitUpgradeOptionFieldsList;
+    /** The limit values associated with this upgrade. */
+    limitUpgrades: OnrampLimitUpgradeOptionLimitUpgradesList;
+}
+export declare const OnrampLimitUpgradeOption: S.Schema<OnrampLimitUpgradeOption>;
+/** The user's limit upgrade status and associated upgrade details. Omitted when limit upgrades are not available for the calling app or user. Use the [Request Limit Upgrade](https://docs.cdp.coinbase.com/api-reference/v2/rest-api/onramp/request-limits-upgrade) endpoint to request a limit upgrade. */
+export type GetOnrampUserLimitsResponseLimitUpgradeOptionsList = Array<OnrampLimitUpgradeOption>;
+export declare const GetOnrampUserLimitsResponseLimitUpgradeOptionsList: S.Schema<GetOnrampUserLimitsResponseLimitUpgradeOptionsList>;
 export interface GetOnrampUserLimitsResponse {
     /** The list of limits applicable to the user. */
     limits: GetOnrampUserLimitsResponseLimitsList;
+    /** The user's limit upgrade status and associated upgrade details. Omitted when limit upgrades are not available for the calling app or user. Use the [Request Limit Upgrade](https://docs.cdp.coinbase.com/api-reference/v2/rest-api/onramp/request-limits-upgrade) endpoint to request a limit upgrade. */
+    limitUpgradeOptions?: GetOnrampUserLimitsResponseLimitUpgradeOptionsList;
 }
 export declare const GetOnrampUserLimitsResponse: S.Schema<GetOnrampUserLimitsResponse>;
 export interface GetPaymentMethodRequest {
@@ -2586,6 +3550,39 @@ export type PaymentMethodsPaymentMethod = FedwirePaymentMethod | SwiftPaymentMet
 export declare const PaymentMethodsPaymentMethod: S.Schema<PaymentMethodsPaymentMethod>;
 export type GetPaymentMethodResponse = PaymentMethodsPaymentMethod;
 export declare const GetPaymentMethodResponse: S.Schema<GetPaymentMethodResponse>;
+export interface GetPaymentSessionRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+}
+export declare const GetPaymentSessionRequest: S.Schema<GetPaymentSessionRequest>;
+export interface GetPaymentSessionAuthorizationRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The unique identifier of the authorization. */
+    authorizationId: string;
+}
+export declare const GetPaymentSessionAuthorizationRequest: S.Schema<GetPaymentSessionAuthorizationRequest>;
+export interface GetPaymentSessionCaptureRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The unique identifier of the capture. */
+    captureId: string;
+}
+export declare const GetPaymentSessionCaptureRequest: S.Schema<GetPaymentSessionCaptureRequest>;
+export interface GetPaymentSessionRefundRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The unique identifier of the refund. */
+    refundId: string;
+}
+export declare const GetPaymentSessionRefundRequest: S.Schema<GetPaymentSessionRefundRequest>;
+export interface GetPaymentSessionVoidRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The unique identifier of the void. */
+    voidId: string;
+}
+export declare const GetPaymentSessionVoidRequest: S.Schema<GetPaymentSessionVoidRequest>;
 export interface GetPolicyByIdRequest {
     /** The ID of the policy to get. */
     policyId: string;
@@ -2651,11 +3648,11 @@ export interface OnchainDataSchemaResponse {
     tables?: OnchainDataSchemaResponseTablesList;
 }
 export declare const OnchainDataSchemaResponse: S.Schema<OnchainDataSchemaResponse>;
-export interface GetTransferByIdRequest {
+export interface GetTransferRequest {
     /** The unique identifier of the transfer. */
     transferId: string;
 }
-export declare const GetTransferByIdRequest: S.Schema<GetTransferByIdRequest>;
+export declare const GetTransferRequest: S.Schema<GetTransferRequest>;
 export interface GetUserOperationRequest {
     /** The address of the Smart Account the user operation belongs to. */
     address: string;
@@ -2663,11 +3660,313 @@ export interface GetUserOperationRequest {
     userOpHash: string;
 }
 export declare const GetUserOperationRequest: S.Schema<GetUserOperationRequest>;
-export interface GetWebhookSubscriptionRequest {
+export type GetWalletAuthorizationOptionsRequestAddressesList = Array<string>;
+export declare const GetWalletAuthorizationOptionsRequestAddressesList: S.Schema<GetWalletAuthorizationOptionsRequestAddressesList>;
+export interface GetWalletAuthorizationOptionsRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The payer wallet addresses to generate authorization options for. Provide between 1 and 5 unique addresses, comma-separated (e.g. `?addresses=0xA,0xB`). Each returned option's `source.address` identifies which requested address it applies to. If a requested address has no eligible authorization options, it appears in `ineligibleAddresses` with a `code` explaining why. */
+    addresses: GetWalletAuthorizationOptionsRequestAddressesList;
+    /** Optional filter to restrict options to a specific blockchain network. */
+    network?: PaymentSourceNetwork | (string & {});
+    /** Optional filter to restrict options to a specific asset. */
+    asset?: string;
+}
+export declare const GetWalletAuthorizationOptionsRequest: S.Schema<GetWalletAuthorizationOptionsRequest>;
+/** The payload type. */
+export type EIP3009PayloadType = "eip3009";
+export declare const EIP3009PayloadType: any;
+/** An EIP-3009 TransferWithAuthorization typed-data payload. The payer must pass `data` to `eth_signTypedData_v4` and return the resulting signature. */
+export interface EIP3009Payload {
+    /** The unique identifier of the payload. */
+    payloadId: string;
+    /** The payload type. */
+    type: EIP3009PayloadType;
+    /** EIP-712 typed data for a TransferWithAuthorization. Pass to `eth_signTypedData_v4`. */
+    data: EIP712Message;
+}
+export declare const EIP3009Payload: S.Schema<EIP3009Payload>;
+/** The payload type. */
+export type Permit2PayloadType = "permit2";
+export declare const Permit2PayloadType: any;
+/** A Permit2 PermitTransferFrom typed-data payload. The payer must pass `data` to `eth_signTypedData_v4` and return the resulting signature. */
+export interface Permit2Payload {
+    /** The unique identifier of the payload. */
+    payloadId: string;
+    /** The payload type. */
+    type: Permit2PayloadType;
+    /** EIP-712 typed data for a Permit2 PermitTransferFrom. Pass to `eth_signTypedData_v4`. */
+    data: EIP712Message;
+}
+export declare const Permit2Payload: S.Schema<Permit2Payload>;
+/** The payload type. */
+export type Erc20ApprovalPayloadType = "erc20_approval";
+export declare const Erc20ApprovalPayloadType: any;
+/** An EVM transaction object. Send via `eth_sendTransaction`. */
+export interface Erc20ApprovalPayloadData {
+    /** The EVM chain ID for the transaction. */
+    chainId: number;
+    /** The 0x-prefixed address of the ERC-20 token contract to approve. */
+    to: string;
+    /** The ABI-encoded `approve()` calldata. */
+    data: string;
+    /** The native token value to send (always `"0"` for approvals). */
+    value: string;
+    /** The estimated gas limit for the transaction. */
+    gas?: string;
+    /** The maximum fee per gas unit (EIP-1559). */
+    maxFeePerGas?: string;
+    /** The maximum priority fee per gas unit (EIP-1559). */
+    maxPriorityFeePerGas?: string;
+}
+export declare const Erc20ApprovalPayloadData: S.Schema<Erc20ApprovalPayloadData>;
+/** An ERC-20 approval transaction payload. The payer must send `data` as an EVM transaction via `eth_sendTransaction` and return the resulting transaction hash. */
+export interface Erc20ApprovalPayload {
+    /** The unique identifier of the payload. */
+    payloadId: string;
+    /** The payload type. */
+    type: Erc20ApprovalPayloadType;
+    /** An EVM transaction object. Send via `eth_sendTransaction`. */
+    data: Erc20ApprovalPayloadData;
+}
+export declare const Erc20ApprovalPayload: S.Schema<Erc20ApprovalPayload>;
+/** The payload type. */
+export type SpendPermissionPayloadType = "spend_permission";
+export declare const SpendPermissionPayloadType: any;
+/** A spend permission EIP-712 typed-data payload. The payer must pass `data` to `eth_signTypedData_v4` and return the resulting signature. This grants a spender the ability to transfer tokens from the payer's smart account under the specified constraints (allowance, period, expiry). */
+export interface SpendPermissionPayload {
+    /** The unique identifier of the payload. */
+    payloadId: string;
+    /** The payload type. */
+    type: SpendPermissionPayloadType;
+    /** EIP-712 typed data for a SpendPermission approval. Pass to `eth_signTypedData_v4`. */
+    data: EIP712Message;
+}
+export declare const SpendPermissionPayload: S.Schema<SpendPermissionPayload>;
+/** A single onchain payload the payer must process to complete an onchain payment option. Inspect `type` to determine how to handle the `data` field: - `eip3009` — pass `data` to `eth_signTypedData_v4`, return the signature. - `permit2` — pass `data` to `eth_signTypedData_v4`, return the signature. - `erc20_approval` — send `data` via `eth_sendTransaction`, return the transaction hash. - `spend_permission` — pass `data` to `eth_signTypedData_v4`, return the signature. */
+export type OnchainSignaturePayload = EIP3009Payload | Permit2Payload | Erc20ApprovalPayload | SpendPermissionPayload;
+export declare const OnchainSignaturePayload: S.Schema<OnchainSignaturePayload>;
+/** The payloads the payer must sign or submit to authorize the payment via this option. */
+export type WalletAuthorizationOptionPayloadsList = Array<OnchainSignaturePayload>;
+export declare const WalletAuthorizationOptionPayloadsList: S.Schema<WalletAuthorizationOptionPayloadsList>;
+/** An authorization option for completing payment via a wallet. Specifies the currency, amount, and network the payer would pay on, and the payloads the payer must sign or submit. */
+export interface WalletAuthorizationOption {
+    /** The unique identifier of the authorization option. */
+    optionId: string;
+    /** The source address this authorization option applies to. */
+    source: PaymentSourceWallet;
+    /** A decimal representation of the amount the payer would pay if they choose this option, denominated in `asset`. May differ from the session amount when paying in a different asset. */
+    amount: string;
+    /** The symbol of the asset the payer would pay in for this option. */
+    asset: string;
+    /** The blockchain network the transaction will occur on for this option. */
+    network: PaymentSourceNetwork;
+    /** The payloads the payer must sign or submit to authorize the payment via this option. */
+    payloads: WalletAuthorizationOptionPayloadsList;
+}
+export declare const WalletAuthorizationOption: S.Schema<WalletAuthorizationOption>;
+/** The available wallet authorization options. */
+export type WalletAuthorizationOptionsResponseOptionsList = Array<WalletAuthorizationOption>;
+export declare const WalletAuthorizationOptionsResponseOptionsList: S.Schema<WalletAuthorizationOptionsResponseOptionsList>;
+/** A machine-readable code indicating why this address has no eligible authorization option. The enum is closed — any value the server returns must be listed below. Adding a new code is a deliberate, coordinated API change; clients receiving an undocumented value should treat it as a server violating the spec. */
+export type IneligibleWalletAuthorizationAddressCode = "insufficient_funds" | "superseded_by_preferred_option";
+export declare const IneligibleWalletAuthorizationAddressCode: any;
+/** Describes, for one enabled (network, asset) combination, what the payer would need to fund a source address with so that it becomes eligible to authorize the payment. Appears in the `fundsRequired` list of an ineligible address whose `code` is `insufficient_funds`. All amounts are human-readable decimal strings, formatted the same way as `WalletAuthorizationOption.amount`. */
+export interface WalletAuthorizationFundsRequirement {
+    /** The symbol of the asset the payer would fund on this network. */
+    asset: string;
+    /** The blockchain network this funding requirement applies to. */
+    network: PaymentSourceNetwork;
+    /** A decimal representation of the address's current balance of `asset` on this `network`. */
+    currentBalance: string;
+    /** A decimal representation of the balance of `asset` the payer must hold on this `network` to become eligible to authorize the payment. */
+    requiredBalance: string;
+}
+export declare const WalletAuthorizationFundsRequirement: S.Schema<WalletAuthorizationFundsRequirement>;
+/** The funding options for this address, one entry per (network, asset) combination the payer could fund to become eligible. Only present when `code` is `insufficient_funds`, and honors the request's `network` and `asset` filters. May be an empty array. */
+export type IneligibleWalletAuthorizationAddressFundsRequiredList = Array<WalletAuthorizationFundsRequirement>;
+export declare const IneligibleWalletAuthorizationAddressFundsRequiredList: S.Schema<IneligibleWalletAuthorizationAddressFundsRequiredList>;
+/** A requested payer wallet address that has no eligible authorization option for this payment session, along with a machine- and human-readable reason. */
+export interface IneligibleWalletAuthorizationAddress {
+    /** The requested payer wallet address that has no eligible authorization option. */
+    address: string;
+    /** A machine-readable code indicating why this address has no eligible authorization option. The enum is closed — any value the server returns must be listed below. Adding a new code is a deliberate, coordinated API change; clients receiving an undocumented value should treat it as a server violating the spec. */
+    code: IneligibleWalletAuthorizationAddressCode;
+    /** A human-readable, English-language description of why this address has no eligible authorization option. Suitable for surfacing in product UIs — does not contain personally identifiable information or internal infrastructure details. Clients that need localized strings should dispatch on `code` and provide their own translations. */
+    message: string;
+    /** The funding options for this address, one entry per (network, asset) combination the payer could fund to become eligible. Only present when `code` is `insufficient_funds`, and honors the request's `network` and `asset` filters. May be an empty array. */
+    fundsRequired?: IneligibleWalletAuthorizationAddressFundsRequiredList;
+}
+export declare const IneligibleWalletAuthorizationAddress: S.Schema<IneligibleWalletAuthorizationAddress>;
+/** Requested payer addresses that have no eligible authorization option, each with a `code` explaining why. Empty when every requested address can authorize the payment. */
+export type WalletAuthorizationOptionsResponseIneligibleAddressesList = Array<IneligibleWalletAuthorizationAddress>;
+export declare const WalletAuthorizationOptionsResponseIneligibleAddressesList: S.Schema<WalletAuthorizationOptionsResponseIneligibleAddressesList>;
+/** The available wallet authorization options for a payment session. Each option describes one way the payer can authorize the payment from their wallet. Present the options to the payer and let them choose one. Requested addresses with no eligible option appear in `ineligibleAddresses` with a `code` explaining why. */
+export interface WalletAuthorizationOptionsResponse {
+    /** The available wallet authorization options. */
+    options: WalletAuthorizationOptionsResponseOptionsList;
+    /** Requested payer addresses that have no eligible authorization option, each with a `code` explaining why. Empty when every requested address can authorize the payment. */
+    ineligibleAddresses: WalletAuthorizationOptionsResponseIneligibleAddressesList;
+}
+export declare const WalletAuthorizationOptionsResponse: S.Schema<WalletAuthorizationOptionsResponse>;
+export interface GetWebhookSubscriptionRequest {
     /** Unique identifier for the webhook subscription. */
     subscriptionId: string;
 }
 export declare const GetWebhookSubscriptionRequest: S.Schema<GetWebhookSubscriptionRequest>;
+export interface GetX402BundleRequest {
+    /** The unique, URL-safe slug identifying the bundle (as returned by `GET /v2/x402/discovery/bundles`). */
+    bundleSlug: string;
+}
+export declare const GetX402BundleRequest: S.Schema<GetX402BundleRequest>;
+/** Communication protocol (e.g., "http", "mcp"). */
+export type X402DiscoveryResourceType = "http" | "mcp";
+export declare const X402DiscoveryResourceType: any;
+/** The version of the x402 protocol. */
+export type X402Version = 1 | 2;
+export declare const X402Version: any;
+/** The scheme of the payment protocol to use. Supported schemes are `exact`, `upto`, and `batch-settlement`. */
+export type X402V2PaymentRequirementsScheme = "exact" | "upto" | "batch-settlement";
+export declare const X402V2PaymentRequirementsScheme: any;
+/** The x402 v2 network identifier in CAIP-2 format. x402 v2 identifies networks by their CAIP-2 chain ID (e.g. `eip155:<chainId>` for EVM networks, `solana:<genesisHash>` for Solana). Supported networks: Base, Polygon, Arbitrum One, World Chain (EVM), and Solana. */
+export type X402V2Network = "eip155:8453" | "eip155:84532" | "eip155:137" | "eip155:42161" | "eip155:480" | "eip155:4801" | "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" | "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+export declare const X402V2Network: any;
+/** The optional additional scheme-specific payment info. */
+export type X402V2PaymentRequirementsExtraMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const X402V2PaymentRequirementsExtraMap: S.Schema<X402V2PaymentRequirementsExtraMap>;
+/** The x402 v2 payment requirements. Uses CAIP-2 network identifiers and supports `exact`, `upto`, and `batch-settlement` schemes. Carries only the payment fields (no resource metadata — that is in the enclosing `x402V2PaymentPayload.resource`). */
+export interface X402V2PaymentRequirements {
+    /** The scheme of the payment protocol to use. Supported schemes are `exact`, `upto`, and `batch-settlement`. */
+    scheme: X402V2PaymentRequirementsScheme | (string & {});
+    /** The network of the blockchain to send payment on in CAIP-2 format. */
+    network: X402V2Network | (string & {});
+    /** The asset to pay with. For EVM networks, the asset will be a 0x-prefixed, checksum EVM address. For Solana-based networks, the asset will be a base58-encoded Solana address. */
+    asset: string;
+    /** The amount to pay for the resource in atomic units of the payment asset. */
+    amount: string;
+    /** The destination to pay value to. For EVM networks, payTo will be a 0x-prefixed, checksum EVM address. For Solana-based networks, payTo will be a base58-encoded Solana address. */
+    payTo: string;
+    /** The maximum time in seconds for the resource server to respond. */
+    maxTimeoutSeconds: number;
+    /** The optional additional scheme-specific payment info. */
+    extra?: X402V2PaymentRequirementsExtraMap;
+}
+export declare const X402V2PaymentRequirements: S.Schema<X402V2PaymentRequirements>;
+/** The scheme of the payment protocol to use. Currently, the only supported scheme is `exact`. */
+export type X402V1PaymentRequirementsScheme = "exact";
+export declare const X402V1PaymentRequirementsScheme: any;
+/** The x402 v1 network identifier. x402 v1 uses human-readable network names. Supported networks: Base mainnet and testnet, Solana mainnet and devnet. */
+export type X402V1Network = "base" | "base-sepolia" | "solana" | "solana-devnet";
+export declare const X402V1Network: any;
+/** The optional JSON schema describing the resource output. */
+export type X402V1PaymentRequirementsOutputSchemaMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const X402V1PaymentRequirementsOutputSchemaMap: S.Schema<X402V1PaymentRequirementsOutputSchemaMap>;
+/** The optional additional scheme-specific payment info. */
+export type X402V1PaymentRequirementsExtraMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const X402V1PaymentRequirementsExtraMap: S.Schema<X402V1PaymentRequirementsExtraMap>;
+/** The x402 v1 payment requirements. Uses human-readable network names, and carries resource metadata (`resource`, `description`, `mimeType`) alongside the payment fields. The only supported scheme is `exact`. */
+export interface X402V1PaymentRequirements {
+    /** The scheme of the payment protocol to use. Currently, the only supported scheme is `exact`. */
+    scheme: X402V1PaymentRequirementsScheme;
+    /** The network of the blockchain to send payment on. */
+    network: X402V1Network | (string & {});
+    /** The maximum amount required to pay for the resource in atomic units of the payment asset. */
+    maxAmountRequired: string;
+    /** The URL of the resource to pay for. */
+    resource: string;
+    /** A human-readable description of the resource. */
+    description: string;
+    /** The MIME type of the resource response. */
+    mimeType: string;
+    /** The optional JSON schema describing the resource output. */
+    outputSchema?: X402V1PaymentRequirementsOutputSchemaMap;
+    /** The destination to pay value to. For EVM networks, payTo will be a 0x-prefixed, checksum EVM address. For Solana-based networks, payTo will be a base58-encoded Solana address. */
+    payTo: string;
+    /** The maximum time in seconds for the resource server to respond. */
+    maxTimeoutSeconds: number;
+    /** The asset to pay with. For EVM networks, the asset will be a 0x-prefixed, checksum EVM address. For Solana-based networks, the asset will be a base58-encoded Solana address. */
+    asset: string;
+    /** The optional additional scheme-specific payment info. */
+    extra?: X402V1PaymentRequirementsExtraMap;
+}
+export declare const X402V1PaymentRequirements: S.Schema<X402V1PaymentRequirements>;
+/** The x402 protocol payment requirements that the resource server expects the client's payment payload to meet. */
+export type X402PaymentRequirements = X402V2PaymentRequirements | X402V1PaymentRequirements;
+export declare const X402PaymentRequirements: S.Schema<X402PaymentRequirements>;
+/** Payment requirements accepted by the resource. */
+export type X402DiscoveryResourceAcceptsList = Array<X402PaymentRequirements>;
+export declare const X402DiscoveryResourceAcceptsList: S.Schema<X402DiscoveryResourceAcceptsList>;
+/** Map of x402 protocol extensions supported by the resource, keyed by extension name. */
+export type X402DiscoveryResourceExtensionsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const X402DiscoveryResourceExtensionsMap: S.Schema<X402DiscoveryResourceExtensionsMap>;
+/** Quality metrics for a discovered x402 resource. */
+export interface X402ResourceQuality {
+    /** Total number of paid calls to a resource in the last 30 days. */
+    l30DaysTotalCalls?: number;
+    /** Number of unique payers to a resource in the last 30 days. */
+    l30DaysUniquePayers?: number;
+    /** Timestamp of the most recent paid call to a resource. */
+    lastCalledAt?: string;
+}
+export declare const X402ResourceQuality: S.Schema<X402ResourceQuality>;
+/** Low-cardinality string labels associated with the resource for client-side filtering and display. Values are free-form (no controlled vocabulary) and case-sensitive. Order is not significant and duplicates are not expected. */
+export type X402DiscoveryResourceTagsList = Array<string>;
+export declare const X402DiscoveryResourceTagsList: S.Schema<X402DiscoveryResourceTagsList>;
+/** Slugs of the curated x402 bundles this resource belongs to. A bundle is an ordered, named grouping of curated resources covering a common agent workflow. Present only for Coinbase-curated resources (`curated: true`); omitted when the resource is not curated or is not a member of any bundle. */
+export type X402DiscoveryResourceBundleSlugsList = Array<string>;
+export declare const X402DiscoveryResourceBundleSlugsList: S.Schema<X402DiscoveryResourceBundleSlugsList>;
+/** A single discovered x402 resource. Its fields come from three sources: - **x402 protocol** — negotiated from the resource's payment-required response: `resource`, `type`, `x402Version`, `accepts`, `extensions`. - **Provider-supplied** — metadata published by the resource owner: `description`, `serviceName`, `tags`. - **Coinbase-derived** — added during ingestion and curation: `iconUrl`, `quality`, `lastUpdated`, and (for Coinbase-curated endpoints only) `curated`, `skillUrl` (a Coinbase-authored SKILL.md), and `bundleSlugs`. */
+export interface X402DiscoveryResource {
+    /** The URL of the resource. */
+    resource: string;
+    /** A human-readable description of the resource. */
+    description?: string;
+    /** Communication protocol (e.g., "http", "mcp"). */
+    type: X402DiscoveryResourceType;
+    x402Version: X402Version;
+    /** Timestamp of the last update. */
+    lastUpdated?: string;
+    /** Payment requirements accepted by the resource. */
+    accepts?: X402DiscoveryResourceAcceptsList;
+    /** Map of x402 protocol extensions supported by the resource, keyed by extension name. */
+    extensions?: X402DiscoveryResourceExtensionsMap;
+    quality?: X402ResourceQuality;
+    /** Display name of the service this resource belongs to. This is a free-form label for grouping and presentation only — it is not a stable identifier, and two resources sharing the same `serviceName` are not guaranteed to belong to the same logical service. */
+    serviceName?: string;
+    /** Low-cardinality string labels associated with the resource for client-side filtering and display. Values are free-form (no controlled vocabulary) and case-sensitive. Order is not significant and duplicates are not expected. */
+    tags?: X402DiscoveryResourceTagsList;
+    /** Slugs of the curated x402 bundles this resource belongs to. A bundle is an ordered, named grouping of curated resources covering a common agent workflow. Present only for Coinbase-curated resources (`curated: true`); omitted when the resource is not curated or is not a member of any bundle. */
+    bundleSlugs?: X402DiscoveryResourceBundleSlugsList;
+    /** URL of a square icon representing the service this resource belongs to. Distinct from a brand logo: this is intended for compact, list-view rendering (favicon-style) and is normalized to a square aspect ratio at ingestion. The image is moderated and re-hosted by Coinbase, so the URL is stable and safe to render directly in clients. Omitted when the provider did not supply an icon, when the supplied icon failed moderation, or when image processing was unavailable at ingestion time. */
+    iconUrl?: string;
+    /** Whether this resource is a Coinbase-curated endpoint. Curated endpoints have passed the partner-admission and verification bar and surface higher in search and listing results. Omitted (treated as `false`) when the resource is not curated. */
+    curated?: boolean;
+    /** URL of the SKILL.md document describing how to use this resource. Omitted when the resource has no associated skill document. */
+    skillUrl?: string;
+}
+export declare const X402DiscoveryResource: S.Schema<X402DiscoveryResource>;
+/** The bundle's member resources in bundle-defined order. Each entry is the full discovery metadata for a curated endpoint belonging to this bundle. Bundle membership is capped at 50 resources. */
+export type GetX402BundleResponseResourcesList = Array<X402DiscoveryResource>;
+export declare const GetX402BundleResponseResourcesList: S.Schema<GetX402BundleResponseResourcesList>;
+export interface GetX402BundleResponse {
+    /** The stable, unique, URL-safe identifier for the bundle. Used as the path segment in `GET /v2/x402/discovery/bundles/{bundleSlug}`. */
+    slug: string;
+    /** The human-readable display name of the bundle. */
+    name: string;
+    /** A human-readable description of the workflow the bundle covers. */
+    description?: string;
+    /** The bundle's member resources in bundle-defined order. Each entry is the full discovery metadata for a curated endpoint belonging to this bundle. Bundle membership is capped at 50 resources. */
+    resources: GetX402BundleResponseResourcesList;
+}
+export declare const GetX402BundleResponse: S.Schema<GetX402BundleResponse>;
 /** The type of key being imported. Determines what type of account will be associated for the end user. */
 export type ImportEndUserRequestKeyType = "evm" | "solana";
 export declare const ImportEndUserRequestKeyType: any;
@@ -2734,6 +4033,35 @@ export interface ListBalancesResponse {
     nextPageToken?: string;
 }
 export declare const ListBalancesResponse: S.Schema<ListBalancesResponse>;
+export interface ListCoinbaseAccountBalancesRequest {
+}
+export declare const ListCoinbaseAccountBalancesRequest: S.Schema<ListCoinbaseAccountBalancesRequest>;
+/** The list of balances. */
+export type BalancesBalancesList = Array<Balance>;
+export declare const BalancesBalancesList: S.Schema<BalancesBalancesList>;
+/** A list of balances for an account. */
+export interface Balances {
+    /** The list of balances. */
+    balances: BalancesBalancesList;
+}
+export declare const Balances: S.Schema<Balances>;
+export interface ListCustomersRequest {
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+}
+export declare const ListCustomersRequest: S.Schema<ListCustomersRequest>;
+/** The list of customers. */
+export type ListCustomersResponseCustomersList = Array<Customer>;
+export declare const ListCustomersResponseCustomersList: S.Schema<ListCustomersResponseCustomersList>;
+export interface ListCustomersResponse {
+    /** The list of customers. */
+    customers: ListCustomersResponseCustomersList;
+    /** The token for the next page of items, if any. */
+    nextPageToken?: string;
+}
+export declare const ListCustomersResponse: S.Schema<ListCustomersResponse>;
 /** The name of the supported EVM networks in human-readable format. */
 export type ListDataTokenBalancesRequestNetwork = "base" | "base-sepolia" | "ethereum";
 export declare const ListDataTokenBalancesRequestNetwork: any;
@@ -2791,7 +4119,7 @@ export interface ListDepositDestinationsRequest {
     /** Filter deposit destinations by the cryptocurrency address. */
     address?: string;
     /** Filter deposit destinations by type. */
-    type?: DepositDestinationType | (string & {});
+    type?: DepositDestinationType;
     /** Filter deposit destinations by network. */
     network?: string;
     /** The number of resources to return per page. */
@@ -2801,7 +4129,7 @@ export interface ListDepositDestinationsRequest {
 }
 export declare const ListDepositDestinationsRequest: S.Schema<ListDepositDestinationsRequest>;
 /** The list of deposit destinations. */
-export type ListDepositDestinationsResponseDepositDestinationsList = Array<CryptoDepositDestination>;
+export type ListDepositDestinationsResponseDepositDestinationsList = Array<DepositDestination>;
 export declare const ListDepositDestinationsResponseDepositDestinationsList: S.Schema<ListDepositDestinationsResponseDepositDestinationsList>;
 export interface ListDepositDestinationsResponse {
     /** The list of deposit destinations. */
@@ -2810,6 +4138,29 @@ export interface ListDepositDestinationsResponse {
     nextPageToken?: string;
 }
 export declare const ListDepositDestinationsResponse: S.Schema<ListDepositDestinationsResponse>;
+export interface ListDisbursementsRequest {
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+    /** Filter disbursements by status. */
+    status?: PaymentActionStatus | (string & {});
+    /** Filter disbursements by the source CDP account ID. */
+    sourceAccountId?: string;
+    /** Filter disbursements by the client-supplied external reference ID. */
+    externalReferenceId?: string;
+}
+export declare const ListDisbursementsRequest: S.Schema<ListDisbursementsRequest>;
+/** The list of disbursements. */
+export type ListDisbursementsResponseDisbursementsList = Array<Disbursement>;
+export declare const ListDisbursementsResponseDisbursementsList: S.Schema<ListDisbursementsResponseDisbursementsList>;
+export interface ListDisbursementsResponse {
+    /** The list of disbursements. */
+    disbursements: ListDisbursementsResponseDisbursementsList;
+    /** The token for the next page of items, if any. */
+    nextPageToken?: string;
+}
+export declare const ListDisbursementsResponse: S.Schema<ListDisbursementsResponse>;
 export type ListEndUsersRequestSortItem = "createdAt=asc" | "createdAt=desc";
 export declare const ListEndUsersRequestSortItem: any;
 export type ListEndUsersRequestSortList = Array<ListEndUsersRequestSortItem | (string & {})>;
@@ -2891,11 +4242,15 @@ export interface ListEvmTokenBalancesResponse {
     nextPageToken?: string;
 }
 export declare const ListEvmTokenBalancesResponse: S.Schema<ListEvmTokenBalancesResponse>;
+export type ListFoundationAccountsRequestOwnerList = Array<string>;
+export declare const ListFoundationAccountsRequestOwnerList: S.Schema<ListFoundationAccountsRequestOwnerList>;
 export interface ListFoundationAccountsRequest {
     /** The number of resources to return per page. */
     pageSize?: number;
     /** The token for the next page of resources, if any. */
     pageToken?: string;
+    /** Filter accounts by owner. Values can be specific Owner IDs or owner type wildcards. Multiple values can be combined as a comma-separated list. **Specific Owner IDs:** * `entity_<uuid>` - Accounts owned by a specific entity * `customer_<uuid>` - Accounts owned by a specific customer **Owner type wildcards:** * `entity` - All entity-owned accounts * `customer` - All customer-owned accounts **Examples:** * `owner=customer_af29...` - A specific customer's accounts * `owner=customer` - All customer accounts * `owner=entity,customer_af29...` - Entity accounts and a specific customer's accounts * When omitted, accounts with any owner are returned. */
+    owner?: ListFoundationAccountsRequestOwnerList;
     /** Filter accounts by account type. When omitted, accounts of any type are returned. Combined with `owner` using AND. */
     type?: AccountType | (string & {});
 }
@@ -2927,6 +4282,99 @@ export interface ListPaymentMethodsResponse {
     nextPageToken?: string;
 }
 export declare const ListPaymentMethodsResponse: S.Schema<ListPaymentMethodsResponse>;
+export interface ListPaymentSessionAuthorizationsRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+}
+export declare const ListPaymentSessionAuthorizationsRequest: S.Schema<ListPaymentSessionAuthorizationsRequest>;
+/** The list of authorizations. */
+export type ListPaymentSessionAuthorizationsResponseAuthorizationsList = Array<Authorization>;
+export declare const ListPaymentSessionAuthorizationsResponseAuthorizationsList: S.Schema<ListPaymentSessionAuthorizationsResponseAuthorizationsList>;
+export interface ListPaymentSessionAuthorizationsResponse {
+    /** The list of authorizations. */
+    authorizations: ListPaymentSessionAuthorizationsResponseAuthorizationsList;
+    /** The token for the next page of items, if any. */
+    nextPageToken?: string;
+}
+export declare const ListPaymentSessionAuthorizationsResponse: S.Schema<ListPaymentSessionAuthorizationsResponse>;
+export interface ListPaymentSessionCapturesRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+}
+export declare const ListPaymentSessionCapturesRequest: S.Schema<ListPaymentSessionCapturesRequest>;
+/** The list of captures. */
+export type ListPaymentSessionCapturesResponseCapturesList = Array<Capture>;
+export declare const ListPaymentSessionCapturesResponseCapturesList: S.Schema<ListPaymentSessionCapturesResponseCapturesList>;
+export interface ListPaymentSessionCapturesResponse {
+    /** The list of captures. */
+    captures: ListPaymentSessionCapturesResponseCapturesList;
+    /** The token for the next page of items, if any. */
+    nextPageToken?: string;
+}
+export declare const ListPaymentSessionCapturesResponse: S.Schema<ListPaymentSessionCapturesResponse>;
+export interface ListPaymentSessionRefundsRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+}
+export declare const ListPaymentSessionRefundsRequest: S.Schema<ListPaymentSessionRefundsRequest>;
+/** The list of refunds. */
+export type ListPaymentSessionRefundsResponseRefundsList = Array<Refund>;
+export declare const ListPaymentSessionRefundsResponseRefundsList: S.Schema<ListPaymentSessionRefundsResponseRefundsList>;
+export interface ListPaymentSessionRefundsResponse {
+    /** The list of refunds. */
+    refunds: ListPaymentSessionRefundsResponseRefundsList;
+    /** The token for the next page of items, if any. */
+    nextPageToken?: string;
+}
+export declare const ListPaymentSessionRefundsResponse: S.Schema<ListPaymentSessionRefundsResponse>;
+export interface ListPaymentSessionsRequest {
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+}
+export declare const ListPaymentSessionsRequest: S.Schema<ListPaymentSessionsRequest>;
+/** The list of payment sessions. */
+export type ListPaymentSessionsResponsePaymentSessionsList = Array<PaymentSession>;
+export declare const ListPaymentSessionsResponsePaymentSessionsList: S.Schema<ListPaymentSessionsResponsePaymentSessionsList>;
+export interface ListPaymentSessionsResponse {
+    /** The list of payment sessions. */
+    paymentSessions: ListPaymentSessionsResponsePaymentSessionsList;
+    /** The token for the next page of items, if any. */
+    nextPageToken?: string;
+}
+export declare const ListPaymentSessionsResponse: S.Schema<ListPaymentSessionsResponse>;
+export interface ListPaymentSessionVoidsRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+}
+export declare const ListPaymentSessionVoidsRequest: S.Schema<ListPaymentSessionVoidsRequest>;
+/** The list of voids. */
+export type ListPaymentSessionVoidsResponseVoidsList = Array<Void>;
+export declare const ListPaymentSessionVoidsResponseVoidsList: S.Schema<ListPaymentSessionVoidsResponseVoidsList>;
+export interface ListPaymentSessionVoidsResponse {
+    /** The list of voids. */
+    voids: ListPaymentSessionVoidsResponseVoidsList;
+    /** The token for the next page of items, if any. */
+    nextPageToken?: string;
+}
+export declare const ListPaymentSessionVoidsResponse: S.Schema<ListPaymentSessionVoidsResponse>;
 export type ListPoliciesRequestScope = "project" | "account";
 export declare const ListPoliciesRequestScope: any;
 export interface ListPoliciesRequest {
@@ -3105,9 +4553,9 @@ export interface ListTransfersRequest {
     updatedAfter?: string;
     /** Filter transfers to those updated at or before this datetime (inclusive). ISO 8601 format. */
     updatedBefore?: string;
-    /** Filter transfers by source asset symbol (e.g., `usd`, `usdc`). */
+    /** Filter transfers by source asset symbol (e.g., `usd`, `usdc`, `eurc`, `eur`). */
     sourceAsset?: string;
-    /** Filter transfers by target asset symbol (e.g., `usdc`, `eth`). */
+    /** Filter transfers by target asset symbol (e.g., `usdc`, `eurc`, `usd`, `eur`). */
     targetAsset?: string;
     /** Filter transfers by the on-chain address of the source. */
     sourceAddress?: string;
@@ -3204,6 +4652,28 @@ export interface ListWebhookSubscriptionsResponse {
     nextPageToken?: string;
 }
 export declare const ListWebhookSubscriptionsResponse: S.Schema<ListWebhookSubscriptionsResponse>;
+export interface ListX402BundlesRequest {
+}
+export declare const ListX402BundlesRequest: S.Schema<ListX402BundlesRequest>;
+/** A curated workflow bundle: an ordered, named grouping of curated x402 resources that together cover a common agent workflow. This metadata shape is returned by the bundle list endpoint; the per-bundle detail endpoint additionally returns the joined member resources. */
+export interface X402Bundle {
+    /** The stable, unique, URL-safe identifier for the bundle. Used as the path segment in `GET /v2/x402/discovery/bundles/{bundleSlug}`. */
+    slug: string;
+    /** The human-readable display name of the bundle. */
+    name: string;
+    /** A human-readable description of the workflow the bundle covers. */
+    description?: string;
+}
+export declare const X402Bundle: S.Schema<X402Bundle>;
+/** The list of available curated bundles. This list is empty when no bundles are defined. */
+export type X402BundlesResponseBundlesList = Array<X402Bundle>;
+export declare const X402BundlesResponseBundlesList: S.Schema<X402BundlesResponseBundlesList>;
+/** Response containing the available curated x402 bundles. Unlike x402 protocol discovery and search responses, bundle responses omit `x402Version` because bundles are CDP-curated metadata, not protocol negotiation payloads. */
+export interface X402BundlesResponse {
+    /** The list of available curated bundles. This list is empty when no bundles are defined. */
+    bundles: X402BundlesResponseBundlesList;
+}
+export declare const X402BundlesResponse: S.Schema<X402BundlesResponse>;
 export interface ListX402DiscoveryMerchantRequest {
     /** The merchant's payment address to look up. This is the onchain address that payment requirements route funds to. */
     payTo: string;
@@ -3213,131 +4683,6 @@ export interface ListX402DiscoveryMerchantRequest {
     offset?: number;
 }
 export declare const ListX402DiscoveryMerchantRequest: S.Schema<ListX402DiscoveryMerchantRequest>;
-/** The version of the x402 protocol. */
-export type X402Version = 1 | 2;
-export declare const X402Version: any;
-/** Communication protocol (e.g., "http", "mcp"). */
-export type X402DiscoveryResourceType = "http" | "mcp";
-export declare const X402DiscoveryResourceType: any;
-/** The scheme of the payment protocol to use. Supported schemes are `exact`, `upto`, and `batch-settlement`. */
-export type X402V2PaymentRequirementsScheme = "exact" | "upto" | "batch-settlement";
-export declare const X402V2PaymentRequirementsScheme: any;
-/** The x402 v2 network identifier in CAIP-2 format. x402 v2 identifies networks by their CAIP-2 chain ID (e.g. `eip155:<chainId>` for EVM networks, `solana:<genesisHash>` for Solana). Supported networks: Base, Polygon, Arbitrum One, World Chain (EVM), and Solana. */
-export type X402V2Network = "eip155:8453" | "eip155:84532" | "eip155:137" | "eip155:42161" | "eip155:480" | "eip155:4801" | "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" | "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
-export declare const X402V2Network: any;
-/** The optional additional scheme-specific payment info. */
-export type X402V2PaymentRequirementsExtraMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const X402V2PaymentRequirementsExtraMap: S.Schema<X402V2PaymentRequirementsExtraMap>;
-/** The x402 v2 payment requirements. Uses CAIP-2 network identifiers and supports `exact`, `upto`, and `batch-settlement` schemes. Carries only the payment fields (no resource metadata — that is in the enclosing `x402V2PaymentPayload.resource`). */
-export interface X402V2PaymentRequirements {
-    /** The scheme of the payment protocol to use. Supported schemes are `exact`, `upto`, and `batch-settlement`. */
-    scheme: X402V2PaymentRequirementsScheme | (string & {});
-    /** The network of the blockchain to send payment on in CAIP-2 format. */
-    network: X402V2Network | (string & {});
-    /** The asset to pay with. For EVM networks, the asset will be a 0x-prefixed, checksum EVM address. For Solana-based networks, the asset will be a base58-encoded Solana address. */
-    asset: string;
-    /** The amount to pay for the resource in atomic units of the payment asset. */
-    amount: string;
-    /** The destination to pay value to. For EVM networks, payTo will be a 0x-prefixed, checksum EVM address. For Solana-based networks, payTo will be a base58-encoded Solana address. */
-    payTo: string;
-    /** The maximum time in seconds for the resource server to respond. */
-    maxTimeoutSeconds: number;
-    /** The optional additional scheme-specific payment info. */
-    extra?: X402V2PaymentRequirementsExtraMap;
-}
-export declare const X402V2PaymentRequirements: S.Schema<X402V2PaymentRequirements>;
-/** The scheme of the payment protocol to use. Currently, the only supported scheme is `exact`. */
-export type X402V1PaymentRequirementsScheme = "exact";
-export declare const X402V1PaymentRequirementsScheme: any;
-/** The x402 v1 network identifier. x402 v1 uses human-readable network names. Supported networks: Base mainnet and testnet, Solana mainnet and devnet. */
-export type X402V1Network = "base" | "base-sepolia" | "solana" | "solana-devnet";
-export declare const X402V1Network: any;
-/** The optional JSON schema describing the resource output. */
-export type X402V1PaymentRequirementsOutputSchemaMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const X402V1PaymentRequirementsOutputSchemaMap: S.Schema<X402V1PaymentRequirementsOutputSchemaMap>;
-/** The optional additional scheme-specific payment info. */
-export type X402V1PaymentRequirementsExtraMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const X402V1PaymentRequirementsExtraMap: S.Schema<X402V1PaymentRequirementsExtraMap>;
-/** The x402 v1 payment requirements. Uses human-readable network names, and carries resource metadata (`resource`, `description`, `mimeType`) alongside the payment fields. The only supported scheme is `exact`. */
-export interface X402V1PaymentRequirements {
-    /** The scheme of the payment protocol to use. Currently, the only supported scheme is `exact`. */
-    scheme: X402V1PaymentRequirementsScheme;
-    /** The network of the blockchain to send payment on. */
-    network: X402V1Network | (string & {});
-    /** The maximum amount required to pay for the resource in atomic units of the payment asset. */
-    maxAmountRequired: string;
-    /** The URL of the resource to pay for. */
-    resource: string;
-    /** A human-readable description of the resource. */
-    description: string;
-    /** The MIME type of the resource response. */
-    mimeType: string;
-    /** The optional JSON schema describing the resource output. */
-    outputSchema?: X402V1PaymentRequirementsOutputSchemaMap;
-    /** The destination to pay value to. For EVM networks, payTo will be a 0x-prefixed, checksum EVM address. For Solana-based networks, payTo will be a base58-encoded Solana address. */
-    payTo: string;
-    /** The maximum time in seconds for the resource server to respond. */
-    maxTimeoutSeconds: number;
-    /** The asset to pay with. For EVM networks, the asset will be a 0x-prefixed, checksum EVM address. For Solana-based networks, the asset will be a base58-encoded Solana address. */
-    asset: string;
-    /** The optional additional scheme-specific payment info. */
-    extra?: X402V1PaymentRequirementsExtraMap;
-}
-export declare const X402V1PaymentRequirements: S.Schema<X402V1PaymentRequirements>;
-/** The x402 protocol payment requirements that the resource server expects the client's payment payload to meet. */
-export type X402PaymentRequirements = X402V2PaymentRequirements | X402V1PaymentRequirements;
-export declare const X402PaymentRequirements: S.Schema<X402PaymentRequirements>;
-/** Payment requirements accepted by the resource. */
-export type X402DiscoveryResourceAcceptsList = Array<X402PaymentRequirements>;
-export declare const X402DiscoveryResourceAcceptsList: S.Schema<X402DiscoveryResourceAcceptsList>;
-/** Map of x402 protocol extensions supported by the resource, keyed by extension name. */
-export type X402DiscoveryResourceExtensionsMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const X402DiscoveryResourceExtensionsMap: S.Schema<X402DiscoveryResourceExtensionsMap>;
-/** Quality metrics for a discovered x402 resource. */
-export interface X402ResourceQuality {
-    /** Total number of paid calls to a resource in the last 30 days. */
-    l30DaysTotalCalls?: number;
-    /** Number of unique payers to a resource in the last 30 days. */
-    l30DaysUniquePayers?: number;
-    /** Timestamp of the most recent paid call to a resource. */
-    lastCalledAt?: string;
-}
-export declare const X402ResourceQuality: S.Schema<X402ResourceQuality>;
-/** Provider-supplied, low-cardinality string labels associated with the resource for client-side filtering and display. Values are free-form (no controlled vocabulary) and case-sensitive. Order is not significant and duplicates are not expected. */
-export type X402DiscoveryResourceTagsList = Array<string>;
-export declare const X402DiscoveryResourceTagsList: S.Schema<X402DiscoveryResourceTagsList>;
-/** A single discovered x402 resource. */
-export interface X402DiscoveryResource {
-    /** The URL of the resource. */
-    resource: string;
-    /** A human-readable description of the resource. */
-    description?: string;
-    /** Communication protocol (e.g., "http", "mcp"). */
-    type: X402DiscoveryResourceType;
-    x402Version: X402Version;
-    /** Timestamp of the last update. */
-    lastUpdated?: string;
-    /** Payment requirements accepted by the resource. */
-    accepts?: X402DiscoveryResourceAcceptsList;
-    /** Map of x402 protocol extensions supported by the resource, keyed by extension name. */
-    extensions?: X402DiscoveryResourceExtensionsMap;
-    quality?: X402ResourceQuality;
-    /** Provider-supplied display name of the service this resource belongs to. This is a free-form label for grouping and presentation only — it is not a stable identifier, and two resources sharing the same `serviceName` are not guaranteed to belong to the same logical service. */
-    serviceName?: string;
-    /** Provider-supplied, low-cardinality string labels associated with the resource for client-side filtering and display. Values are free-form (no controlled vocabulary) and case-sensitive. Order is not significant and duplicates are not expected. */
-    tags?: X402DiscoveryResourceTagsList;
-    /** URL of a square icon representing the service this resource belongs to. Distinct from a brand logo: this is intended for compact, list-view rendering (favicon-style) and is normalized to a square aspect ratio at ingestion. The image is moderated and re-hosted by Coinbase, so the URL is stable and safe to render directly in clients. Omitted when the provider did not supply an icon, when the supplied icon failed moderation, or when image processing was unavailable at ingestion time. */
-    iconUrl?: string;
-}
-export declare const X402DiscoveryResource: S.Schema<X402DiscoveryResource>;
 /** List of discovered x402 resources associated with the merchant's payTo address. This list is empty when no active resources are found. */
 export type X402DiscoveryMerchantResponseResourcesList = Array<X402DiscoveryResource>;
 export declare const X402DiscoveryMerchantResponseResourcesList: S.Schema<X402DiscoveryMerchantResponseResourcesList>;
@@ -3413,65 +4758,6 @@ export interface LookupEndUserResponse {
     endUsers: LookupEndUserResponseEndUsersList;
 }
 export declare const LookupEndUserResponse: S.Schema<LookupEndUserResponse>;
-/** JSON-RPC version, must be "2.0". */
-export type PostX402DiscoveryMcpRequestJsonrpc = "2.0";
-export declare const PostX402DiscoveryMcpRequestJsonrpc: any;
-/** Request identifier. */
-export type PostX402DiscoveryMcpRequestId = string | number;
-export declare const PostX402DiscoveryMcpRequestId: S.Schema<PostX402DiscoveryMcpRequestId>;
-/** Optional parameters for the method. */
-export type PostX402DiscoveryMcpRequestParamsMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const PostX402DiscoveryMcpRequestParamsMap: S.Schema<PostX402DiscoveryMcpRequestParamsMap>;
-export interface PostX402DiscoveryMcpRequest {
-    /** JSON-RPC version, must be "2.0". */
-    jsonrpc: PostX402DiscoveryMcpRequestJsonrpc | (string & {});
-    /** Request identifier. */
-    id?: PostX402DiscoveryMcpRequestId;
-    /** The MCP method to invoke. */
-    method: string;
-    /** Optional parameters for the method. */
-    params?: PostX402DiscoveryMcpRequestParamsMap;
-}
-export declare const PostX402DiscoveryMcpRequest: S.Schema<PostX402DiscoveryMcpRequest>;
-/** JSON-RPC version. */
-export type X402McpResponseJsonrpc = "2.0";
-export declare const X402McpResponseJsonrpc: any;
-/** Request identifier (matches the request ID, null for notifications). */
-export type X402McpResponseId = string | number;
-export declare const X402McpResponseId: S.Schema<X402McpResponseId>;
-/** The result of the method call (present on success). */
-export type X402McpResponseResultMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const X402McpResponseResultMap: S.Schema<X402McpResponseResultMap>;
-/** Additional error data. */
-export type X402McpErrorDataMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const X402McpErrorDataMap: S.Schema<X402McpErrorDataMap>;
-/** JSON-RPC 2.0 error object. */
-export interface X402McpError {
-    /** Error code. */
-    code: number;
-    /** Error message. */
-    message: string;
-    /** Additional error data. */
-    data?: X402McpErrorDataMap;
-}
-export declare const X402McpError: S.Schema<X402McpError>;
-/** A JSON-RPC 2.0 response for the Model Context Protocol. */
-export interface X402McpResponse {
-    /** JSON-RPC version. */
-    jsonrpc: X402McpResponseJsonrpc;
-    /** Request identifier (matches the request ID, null for notifications). */
-    id?: X402McpResponseId | null;
-    /** The result of the method call (present on success). */
-    result?: X402McpResponseResultMap;
-    error?: X402McpError;
-}
-export declare const X402McpResponse: S.Schema<X402McpResponse>;
 /** The list of calls to make from the Smart Account. */
 export type PrepareAndSendUserOperationRequestCallsList = Array<EvmCall>;
 export declare const PrepareAndSendUserOperationRequestCallsList: S.Schema<PrepareAndSendUserOperationRequestCallsList>;
@@ -3507,6 +4793,22 @@ export interface PrepareUserOperationRequest {
     dataSuffix?: string;
 }
 export declare const PrepareUserOperationRequest: S.Schema<PrepareUserOperationRequest>;
+export interface RefundPaymentSessionRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    /** The source from which to fund the refund. Can be a CDP account or an onchain address. */
+    source: RefundSource;
+    /** A decimal representation of the amount to refund, denominated in the session's `asset`. If omitted, the full remaining refundable amount is refunded. */
+    amount?: string;
+    /** The reason for the refund. */
+    reason?: string;
+    metadata?: Metadata;
+    /** An optional merchant-provided internal identifier for this refund, from the merchant's own system—not visible to the payer. */
+    externalReferenceId?: string;
+    /** Optional customer-facing display data for this refund, shown to the payer. Falls back to the session's `orderCode` when `referenceCode` is omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+}
+export declare const RefundPaymentSessionRequest: S.Schema<RefundPaymentSessionRequest>;
 /** The network to request funds from. */
 export type RequestEvmFaucetRequestNetwork = "base-sepolia" | "ethereum-sepolia" | "ethereum-hoodi";
 export declare const RequestEvmFaucetRequestNetwork: any;
@@ -3527,6 +4829,9 @@ export interface RequestEvmFaucetResponse {
     transactionHash: string;
 }
 export declare const RequestEvmFaucetResponse: S.Schema<RequestEvmFaucetResponse>;
+/** The interaction mode for the limit upgrade request: - `api`: Submit identity fields directly in the API request. - `embedded`: Return a Coinbase-hosted URL where the user enters identity fields. */
+export type OnrampLimitUpgradeInteractionMode = "api" | "embedded";
+export declare const OnrampLimitUpgradeInteractionMode: any;
 /** Populate the properties that correspond to the `fields` array from the user's `OnrampLimitUpgradeOption`. */
 export interface OnrampLimitUpgradeIdentityFields {
     /** Last 4 digits of the Social Security Number (no dashes or spaces). */
@@ -3539,13 +4844,20 @@ export interface RequestLimitsUpgradeRequest {
     /** The user identifier value. For `phone_number` type, this must be in E.164 format. */
     userId: string;
     userIdType: OnrampUserIdType | (string & {});
-    /** Populate the properties that correspond to the `fields` array from the user's `OnrampLimitUpgradeOption`. These fields are required; a request without them is rejected. */
+    /** The interaction mode for the limit upgrade request. Defaults to `api`. */
+    interactionMode?: OnrampLimitUpgradeInteractionMode | (string & {});
+    /** Populate the properties that correspond to the `fields` array from the user's `OnrampLimitUpgradeOption`. Required in `api` mode. Omit in `embedded` mode — the user enters their identity information on the Coinbase-hosted upgrade page (see `interactionMode`), so any value sent here is rejected. */
     fields?: OnrampLimitUpgradeIdentityFields;
 }
 export declare const RequestLimitsUpgradeRequest: S.Schema<RequestLimitsUpgradeRequest>;
-export interface RequestLimitsUpgradeResponse {
+/** A Coinbase-hosted URL for collecting limit upgrade identity fields. */
+export interface OnrampLimitUpgradeEmbeddedResponse {
+    /** The Coinbase-hosted URL where the user enters identity information for the limit upgrade. Treat the session token in this URL as opaque. */
+    upgradeUrl: string;
+    /** The time at which the hosted limit upgrade URL expires. Request a new upgrade URL after this time. */
+    expiresAt: string;
 }
-export declare const RequestLimitsUpgradeResponse: S.Schema<RequestLimitsUpgradeResponse>;
+export declare const OnrampLimitUpgradeEmbeddedResponse: S.Schema<OnrampLimitUpgradeEmbeddedResponse>;
 /** The token to request funds for. */
 export type RequestSolanaFaucetRequestToken = "sol" | "usdc" | "cbtusd";
 export declare const RequestSolanaFaucetRequestToken: any;
@@ -3661,6 +4973,10 @@ export interface OnchainDataResult {
 export declare const OnchainDataResult: S.Schema<OnchainDataResult>;
 export type SearchX402ResourcesRequestExtensionsList = Array<string>;
 export declare const SearchX402ResourcesRequestExtensionsList: S.Schema<SearchX402ResourcesRequestExtensionsList>;
+export type SearchX402ResourcesRequestTagsList = Array<string>;
+export declare const SearchX402ResourcesRequestTagsList: S.Schema<SearchX402ResourcesRequestTagsList>;
+export type SearchX402ResourcesRequestBundleSlugsList = Array<string>;
+export declare const SearchX402ResourcesRequestBundleSlugsList: S.Schema<SearchX402ResourcesRequestBundleSlugsList>;
 export interface SearchX402ResourcesRequest {
     /** Full-text or semantic search query to find matching resources. */
     query?: string;
@@ -3678,6 +4994,12 @@ export interface SearchX402ResourcesRequest {
     maxUsdPrice?: string;
     /** Filter results to resources that support the specified protocol extensions. Can be specified multiple times to filter by multiple extensions. */
     extensions?: SearchX402ResourcesRequestExtensionsList;
+    /** Filter results to resources published with any of the specified provider tags (case-sensitive exact match). Can be specified multiple times to filter by multiple tags; a resource matches if it carries at least one of the supplied tags (OR). */
+    tags?: SearchX402ResourcesRequestTagsList;
+    /** Filter results to resources that belong to any of the specified curated bundles (by bundle slug). Can be specified multiple times to filter by multiple bundles; a resource matches if it belongs to at least one of the supplied bundles (OR). */
+    bundleSlugs?: SearchX402ResourcesRequestBundleSlugsList;
+    /** When `true`, restrict results to Coinbase-curated resources (those with `curated: true`). When `false` or omitted, both curated and non-curated resources are returned. */
+    curatedOnly?: boolean;
     /** Maximum number of resources to return. Must be a positive integer no greater than 20. Defaults to 20. */
     limit?: number;
 }
@@ -4192,7 +5514,7 @@ export interface X402V1PaymentPayload {
     payload: X402V1PaymentPayloadPayload;
 }
 export declare const X402V1PaymentPayload: S.Schema<X402V1PaymentPayload>;
-/** The x402 protocol payment payload that the client attaches to x402-paid API requests to the resource server in the X-PAYMENT header. For EVM networks, smart account signatures can be longer than 65 bytes. */
+/** The x402 protocol payment payload that the client attaches to x402-paid API requests to the resource server in the PAYMENT-SIGNATURE header. For EVM networks, smart account signatures can be longer than 65 bytes. */
 export type X402PaymentPayload = X402V2PaymentPayload | X402V1PaymentPayload;
 export declare const X402PaymentPayload: S.Schema<X402PaymentPayload>;
 export interface SettleX402PaymentRequest {
@@ -4202,7 +5524,7 @@ export interface SettleX402PaymentRequest {
 }
 export declare const SettleX402PaymentRequest: S.Schema<SettleX402PaymentRequest>;
 /** The reason the payment settlement errored on the x402 protocol. */
-export type X402SettleErrorReason = "insufficient_funds" | "invalid_scheme" | "invalid_network" | "invalid_x402_version" | "invalid_payment_requirements" | "invalid_payload" | "invalid_exact_evm_payload_authorization_value" | "invalid_exact_evm_payload_authorization_value_too_low" | "invalid_exact_evm_payload_authorization_valid_after" | "invalid_exact_evm_payload_authorization_valid_before" | "invalid_exact_evm_payload_authorization_typed_data_message" | "invalid_exact_evm_payload_authorization_from_address_kyt" | "invalid_exact_evm_payload_authorization_to_address_kyt" | "invalid_exact_evm_payload_signature" | "invalid_exact_evm_payload_signature_address" | "invalid_exact_evm_permit2_payload_allowance_required" | "invalid_exact_evm_permit2_payload_signature" | "invalid_exact_evm_permit2_payload_deadline" | "invalid_exact_evm_permit2_payload_valid_after" | "invalid_exact_evm_permit2_payload_spender" | "invalid_exact_evm_permit2_payload_recipient" | "invalid_exact_evm_permit2_payload_amount" | "invalid_exact_svm_payload_transaction" | "invalid_exact_svm_payload_transaction_amount_mismatch" | "invalid_exact_svm_payload_transaction_create_ata_instruction" | "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee" | "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset" | "invalid_exact_svm_payload_transaction_instructions" | "invalid_exact_svm_payload_transaction_instructions_length" | "invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction" | "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction" | "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high" | "invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked" | "invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked" | "invalid_exact_svm_payload_transaction_not_a_transfer_instruction" | "invalid_exact_svm_payload_transaction_cannot_derive_receiver_ata" | "invalid_exact_svm_payload_transaction_receiver_ata_not_found" | "invalid_exact_svm_payload_transaction_sender_ata_not_found" | "invalid_exact_svm_payload_transaction_simulation_failed" | "invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata" | "invalid_exact_svm_payload_transaction_fee_payer_included_in_instruction_accounts" | "invalid_exact_svm_payload_transaction_fee_payer_transferring_funds" | "settle_exact_evm_transaction_confirmation_timed_out" | "settle_exact_node_failure" | "settle_exact_failed_onchain" | "settle_exact_svm_block_height_exceeded" | "settle_exact_svm_transaction_confirmation_timed_out" | "invalid_batch_settlement_evm_unknown_settle_action" | "invalid_batch_settlement_evm_claim_payload" | "invalid_batch_settlement_evm_settle_payload" | "invalid_batch_settlement_evm_authorizer_address_mismatch" | "invalid_batch_settlement_evm_claim_simulation_failed" | "invalid_batch_settlement_evm_claim_transaction_failed" | "invalid_batch_settlement_evm_deposit_transaction_failed" | "invalid_batch_settlement_evm_refund_simulation_failed" | "invalid_batch_settlement_evm_refund_transaction_failed" | "invalid_batch_settlement_evm_settle_simulation_failed" | "invalid_batch_settlement_evm_settle_transaction_failed" | "invalid_batch_settlement_evm_transaction_reverted" | "invalid_batch_settlement_evm_wait_for_receipt_failed" | "invalid_batch_settlement_evm_erc20_approval_broadcast_failed" | "invalid_batch_settlement_evm_channel_id_mismatch" | "invalid_batch_settlement_evm_channel_state_read_failed" | "invalid_batch_settlement_evm_cumulative_below_claimed" | "invalid_batch_settlement_evm_cumulative_exceeds_balance" | "invalid_batch_settlement_evm_eip2612_amount_mismatch" | "invalid_batch_settlement_evm_eip2612_asset_mismatch" | "invalid_batch_settlement_evm_eip2612_deadline_expired" | "invalid_batch_settlement_evm_eip2612_invalid_format" | "invalid_batch_settlement_evm_eip2612_invalid_signature" | "invalid_batch_settlement_evm_eip2612_owner_mismatch" | "invalid_batch_settlement_evm_eip2612_spender_mismatch" | "invalid_batch_settlement_evm_erc20_approval_asset_mismatch" | "invalid_batch_settlement_evm_erc20_approval_from_mismatch" | "invalid_batch_settlement_evm_erc20_approval_invalid_format" | "invalid_batch_settlement_evm_erc20_approval_unavailable" | "invalid_batch_settlement_evm_erc20_approval_wrong_spender" | "invalid_batch_settlement_evm_erc3009_authorization_required" | "invalid_batch_settlement_evm_insufficient_balance" | "invalid_batch_settlement_evm_deposit_payload" | "invalid_batch_settlement_evm_receive_authorization_signature" | "invalid_batch_settlement_evm_refund_payload" | "invalid_batch_settlement_evm_voucher_payload" | "invalid_batch_settlement_evm_voucher_signature" | "invalid_batch_settlement_evm_missing_eip712_domain" | "invalid_batch_settlement_evm_payload_authorization_valid_after" | "invalid_batch_settlement_evm_payload_authorization_valid_before" | "invalid_batch_settlement_evm_permit2_allowance_required" | "invalid_batch_settlement_evm_permit2_amount_mismatch" | "invalid_batch_settlement_evm_permit2_authorization_required" | "invalid_batch_settlement_evm_permit2_deadline_expired" | "invalid_batch_settlement_evm_permit2_invalid_signature" | "invalid_batch_settlement_evm_permit2_invalid_spender" | "invalid_batch_settlement_evm_receiver_authorizer_mismatch" | "invalid_batch_settlement_evm_receiver_mismatch" | "invalid_batch_settlement_evm_rpc_read_failed" | "invalid_batch_settlement_evm_token_mismatch" | "invalid_batch_settlement_evm_withdraw_delay_mismatch" | "invalid_batch_settlement_evm_withdraw_delay_out_of_range" | "invalid_batch_settlement_evm_scheme" | "invalid_batch_settlement_evm_network_mismatch" | "invalid_batch_settlement_evm_payload_type" | "invalid_batch_settlement_evm_channel_not_found" | "invalid_batch_settlement_evm_deposit_simulation_failed" | "invalid_exact_evm_scheme" | "invalid_exact_evm_network_mismatch" | "invalid_exact_evm_payload" | "invalid_exact_evm_payload_missing_signature" | "invalid_exact_evm_failed_to_get_network_config" | "invalid_exact_evm_missing_eip712_domain" | "invalid_exact_evm_recipient_mismatch" | "invalid_exact_evm_authorization_value" | "invalid_exact_evm_required_amount" | "invalid_exact_evm_payload_authorization_value_mismatch" | "invalid_exact_evm_failed_to_check_nonce" | "invalid_exact_evm_nonce_already_used" | "invalid_exact_evm_failed_to_get_balance" | "invalid_exact_evm_insufficient_balance" | "invalid_exact_evm_signature_format" | "invalid_exact_evm_failed_to_verify_signature" | "invalid_exact_evm_signature" | "invalid_exact_evm_token_name_mismatch" | "invalid_exact_evm_token_version_mismatch" | "invalid_exact_evm_eip3009_not_supported" | "invalid_exact_evm_transaction_simulation_failed" | "invalid_exact_evm_verification_failed" | "invalid_exact_evm_failed_to_parse_signature" | "invalid_exact_evm_failed_to_check_deployment" | "invalid_exact_evm_failed_to_execute_transfer" | "invalid_exact_evm_failed_to_get_receipt" | "invalid_exact_evm_transaction_failed" | "invalid_exact_evm_payload_undeployed_smart_wallet" | "smart_wallet_deployment_failed" | "unsupported_payload_type" | "invalid_erc20_approval_extension_format" | "erc20_approval_tx_failed" | "erc20_approval_from_mismatch" | "erc20_approval_asset_mismatch" | "erc20_approval_spender_not_permit2" | "erc20_approval_tx_parse_failed" | "erc20_approval_tx_wrong_target" | "erc20_approval_tx_wrong_selector" | "erc20_approval_tx_wrong_spender" | "erc20_approval_tx_signer_mismatch" | "erc20_approval_tx_invalid_signature" | "invalid_exact_evm_unsupported_scheme" | "invalid_exact_evm_extra_field" | "invalid_exact_evm_payload_recipient_mismatch" | "invalid_exact_evm_insufficient_funds" | "invalid_exact_evm_transaction_state" | "invalid_permit2_spender" | "invalid_permit2_recipient_mismatch" | "permit2_deadline_expired" | "permit2_not_yet_valid" | "permit2_amount_mismatch" | "permit2_token_mismatch" | "invalid_permit2_signature" | "permit2_allowance_required" | "permit2_invalid_amount" | "permit2_invalid_destination" | "permit2_invalid_owner" | "permit2_payment_too_early" | "permit2_invalid_nonce" | "permit2_2612_amount_mismatch" | "permit2_simulation_failed" | "permit2_insufficient_balance" | "permit2_proxy_not_deployed" | "erc20_approval_insufficient_eth_for_gas" | "erc20_approval_broadcast_failed" | "invalid_exact_solana_unsupported_scheme" | "invalid_exact_solana_network_mismatch" | "invalid_exact_solana_payload_missing_fee_payer" | "invalid_exact_solana_fee_payer_not_managed_by_facilitator" | "invalid_exact_solana_payload_transaction" | "invalid_exact_solana_payload_transaction_could_not_be_decoded" | "invalid_exact_solana_payload_transaction_instructions_length" | "invalid_exact_solana_payload_unknown_fourth_instruction" | "invalid_exact_solana_payload_unknown_fifth_instruction" | "invalid_exact_solana_payload_unknown_sixth_instruction" | "invalid_exact_solana_payload_transaction_instructions_compute_limit_instruction" | "invalid_exact_solana_payload_transaction_instructions_compute_price_instruction" | "invalid_exact_solana_payload_transaction_instructions_compute_price_instruction_too_high" | "invalid_exact_solana_payload_no_transfer_instruction" | "invalid_exact_solana_payload_transaction_fee_payer_transferring_funds" | "invalid_exact_solana_payload_mint_mismatch" | "invalid_exact_solana_payload_recipient_mismatch" | "invalid_exact_solana_payload_amount_insufficient" | "invalid_exact_solana_invalid_fee_payer" | "invalid_exact_solana_transaction_signing_failed" | "invalid_exact_solana_transaction_simulation_failed" | "invalid_exact_solana_payload_memo_mismatch" | "invalid_exact_solana_payload_memo_count" | "invalid_exact_solana_verification_failed" | "invalid_exact_solana_fee_payer_mismatch" | "invalid_exact_solana_transaction_failed" | "invalid_exact_solana_transaction_confirmation_failed" | "duplicate_settlement" | "invalid_exact_solana_extra_field" | "batch_settlement_cumulative_amount_mismatch" | "batch_settlement_channel_busy" | "missing_batch_settlement_channel" | "batch_settlement_charge_exceeds_signed_cumulative" | "batch_settlement_refund_no_balance" | "batch_settlement_refund_amount_invalid" | "batch_settlement_refund_amount_exceeds_balance" | "amount_too_low" | "invalid_amount" | "kyt_risk_detected" | "permit2_disabled" | "preflight_validation_failed" | "request_blocked_by_location" | "self_send_not_allowed" | "invalid_bazaar_extension" | "unknown_error";
+export type X402SettleErrorReason = "insufficient_funds" | "invalid_scheme" | "invalid_network" | "invalid_x402_version" | "invalid_payment_requirements" | "invalid_payload" | "invalid_exact_evm_payload_authorization_value" | "invalid_exact_evm_payload_authorization_value_too_low" | "invalid_exact_evm_payload_authorization_valid_after" | "invalid_exact_evm_payload_authorization_valid_before" | "invalid_exact_evm_payload_authorization_typed_data_message" | "invalid_exact_evm_payload_authorization_from_address_kyt" | "invalid_exact_evm_payload_authorization_to_address_kyt" | "invalid_exact_evm_payload_signature" | "invalid_exact_evm_payload_signature_address" | "invalid_exact_evm_permit2_payload_allowance_required" | "invalid_exact_evm_permit2_payload_signature" | "invalid_exact_evm_permit2_payload_deadline" | "invalid_exact_evm_permit2_payload_valid_after" | "invalid_exact_evm_permit2_payload_spender" | "invalid_exact_evm_permit2_payload_recipient" | "invalid_exact_evm_permit2_payload_amount" | "invalid_exact_svm_payload_transaction" | "invalid_exact_svm_payload_transaction_amount_mismatch" | "invalid_exact_svm_payload_transaction_create_ata_instruction" | "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee" | "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset" | "invalid_exact_svm_payload_transaction_instructions" | "invalid_exact_svm_payload_transaction_instructions_length" | "invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction" | "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction" | "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high" | "invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked" | "invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked" | "invalid_exact_svm_payload_transaction_not_a_transfer_instruction" | "invalid_exact_svm_payload_transaction_cannot_derive_receiver_ata" | "invalid_exact_svm_payload_transaction_receiver_ata_not_found" | "invalid_exact_svm_payload_transaction_sender_ata_not_found" | "invalid_exact_svm_payload_transaction_simulation_failed" | "invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata" | "invalid_exact_svm_payload_transaction_fee_payer_included_in_instruction_accounts" | "invalid_exact_svm_payload_transaction_fee_payer_transferring_funds" | "settle_exact_evm_transaction_confirmation_timed_out" | "settle_exact_node_failure" | "settle_exact_failed_onchain" | "settle_exact_svm_block_height_exceeded" | "settle_exact_svm_transaction_confirmation_timed_out" | "settlement_pending" | "invalid_batch_settlement_evm_unknown_settle_action" | "invalid_batch_settlement_evm_claim_payload" | "invalid_batch_settlement_evm_settle_payload" | "invalid_batch_settlement_evm_authorizer_address_mismatch" | "invalid_batch_settlement_evm_claim_simulation_failed" | "invalid_batch_settlement_evm_claim_transaction_failed" | "invalid_batch_settlement_evm_deposit_transaction_failed" | "invalid_batch_settlement_evm_refund_simulation_failed" | "invalid_batch_settlement_evm_refund_transaction_failed" | "invalid_batch_settlement_evm_settle_simulation_failed" | "invalid_batch_settlement_evm_settle_transaction_failed" | "invalid_batch_settlement_evm_transaction_reverted" | "invalid_batch_settlement_evm_wait_for_receipt_failed" | "invalid_batch_settlement_evm_erc20_approval_broadcast_failed" | "invalid_batch_settlement_evm_channel_id_mismatch" | "invalid_batch_settlement_evm_channel_state_read_failed" | "invalid_batch_settlement_evm_cumulative_below_claimed" | "invalid_batch_settlement_evm_cumulative_exceeds_balance" | "invalid_batch_settlement_evm_eip2612_amount_mismatch" | "invalid_batch_settlement_evm_eip2612_asset_mismatch" | "invalid_batch_settlement_evm_eip2612_deadline_expired" | "invalid_batch_settlement_evm_eip2612_invalid_format" | "invalid_batch_settlement_evm_eip2612_invalid_signature" | "invalid_batch_settlement_evm_eip2612_owner_mismatch" | "invalid_batch_settlement_evm_eip2612_spender_mismatch" | "invalid_batch_settlement_evm_erc20_approval_asset_mismatch" | "invalid_batch_settlement_evm_erc20_approval_from_mismatch" | "invalid_batch_settlement_evm_erc20_approval_invalid_format" | "invalid_batch_settlement_evm_erc20_approval_unavailable" | "invalid_batch_settlement_evm_erc20_approval_wrong_spender" | "invalid_batch_settlement_evm_erc3009_authorization_required" | "invalid_batch_settlement_evm_insufficient_balance" | "invalid_batch_settlement_evm_deposit_payload" | "invalid_batch_settlement_evm_receive_authorization_signature" | "invalid_batch_settlement_evm_refund_payload" | "invalid_batch_settlement_evm_voucher_payload" | "invalid_batch_settlement_evm_voucher_signature" | "invalid_batch_settlement_evm_missing_eip712_domain" | "invalid_batch_settlement_evm_payload_authorization_valid_after" | "invalid_batch_settlement_evm_payload_authorization_valid_before" | "invalid_batch_settlement_evm_permit2_allowance_required" | "invalid_batch_settlement_evm_permit2_amount_mismatch" | "invalid_batch_settlement_evm_permit2_authorization_required" | "invalid_batch_settlement_evm_permit2_deadline_expired" | "invalid_batch_settlement_evm_permit2_invalid_signature" | "invalid_batch_settlement_evm_permit2_invalid_spender" | "invalid_batch_settlement_evm_receiver_authorizer_mismatch" | "invalid_batch_settlement_evm_receiver_mismatch" | "invalid_batch_settlement_evm_rpc_read_failed" | "invalid_batch_settlement_evm_token_mismatch" | "invalid_batch_settlement_evm_withdraw_delay_mismatch" | "invalid_batch_settlement_evm_withdraw_delay_out_of_range" | "invalid_batch_settlement_evm_scheme" | "invalid_batch_settlement_evm_network_mismatch" | "invalid_batch_settlement_evm_payload_type" | "invalid_batch_settlement_evm_channel_not_found" | "invalid_batch_settlement_evm_deposit_simulation_failed" | "invalid_exact_evm_scheme" | "invalid_exact_evm_network_mismatch" | "invalid_exact_evm_payload" | "invalid_exact_evm_payload_missing_signature" | "invalid_exact_evm_failed_to_get_network_config" | "invalid_exact_evm_missing_eip712_domain" | "invalid_exact_evm_recipient_mismatch" | "invalid_exact_evm_authorization_value" | "invalid_exact_evm_required_amount" | "invalid_exact_evm_payload_authorization_value_mismatch" | "invalid_exact_evm_failed_to_check_nonce" | "invalid_exact_evm_nonce_already_used" | "invalid_exact_evm_failed_to_get_balance" | "invalid_exact_evm_insufficient_balance" | "invalid_exact_evm_signature_format" | "invalid_exact_evm_failed_to_verify_signature" | "invalid_exact_evm_signature" | "invalid_exact_evm_token_name_mismatch" | "invalid_exact_evm_token_version_mismatch" | "invalid_exact_evm_eip3009_not_supported" | "invalid_exact_evm_transaction_simulation_failed" | "invalid_exact_evm_verification_failed" | "invalid_exact_evm_failed_to_parse_signature" | "invalid_exact_evm_failed_to_check_deployment" | "invalid_exact_evm_failed_to_execute_transfer" | "invalid_exact_evm_failed_to_get_receipt" | "invalid_exact_evm_transaction_failed" | "invalid_exact_evm_payload_undeployed_smart_wallet" | "smart_wallet_deployment_failed" | "unsupported_payload_type" | "invalid_erc20_approval_extension_format" | "erc20_approval_tx_failed" | "erc20_approval_from_mismatch" | "erc20_approval_asset_mismatch" | "erc20_approval_spender_not_permit2" | "erc20_approval_tx_parse_failed" | "erc20_approval_tx_wrong_target" | "erc20_approval_tx_wrong_selector" | "erc20_approval_tx_wrong_spender" | "erc20_approval_tx_signer_mismatch" | "erc20_approval_tx_invalid_signature" | "invalid_exact_evm_unsupported_scheme" | "invalid_exact_evm_extra_field" | "invalid_exact_evm_payload_recipient_mismatch" | "invalid_exact_evm_insufficient_funds" | "invalid_exact_evm_transaction_state" | "invalid_permit2_spender" | "invalid_permit2_recipient_mismatch" | "permit2_deadline_expired" | "permit2_not_yet_valid" | "permit2_amount_mismatch" | "permit2_token_mismatch" | "invalid_permit2_signature" | "permit2_allowance_required" | "permit2_invalid_amount" | "permit2_invalid_destination" | "permit2_invalid_owner" | "permit2_payment_too_early" | "permit2_invalid_nonce" | "permit2_2612_amount_mismatch" | "permit2_simulation_failed" | "permit2_insufficient_balance" | "permit2_proxy_not_deployed" | "erc20_approval_insufficient_eth_for_gas" | "erc20_approval_broadcast_failed" | "invalid_exact_solana_unsupported_scheme" | "invalid_exact_solana_network_mismatch" | "invalid_exact_solana_payload_missing_fee_payer" | "invalid_exact_solana_fee_payer_not_managed_by_facilitator" | "invalid_exact_solana_payload_transaction" | "invalid_exact_solana_payload_transaction_could_not_be_decoded" | "invalid_exact_solana_payload_transaction_instructions_length" | "invalid_exact_solana_payload_unknown_fourth_instruction" | "invalid_exact_solana_payload_unknown_fifth_instruction" | "invalid_exact_solana_payload_unknown_sixth_instruction" | "invalid_exact_solana_payload_transaction_instructions_compute_limit_instruction" | "invalid_exact_solana_payload_transaction_instructions_compute_price_instruction" | "invalid_exact_solana_payload_transaction_instructions_compute_price_instruction_too_high" | "invalid_exact_solana_payload_no_transfer_instruction" | "invalid_exact_solana_payload_transaction_fee_payer_transferring_funds" | "invalid_exact_solana_payload_mint_mismatch" | "invalid_exact_solana_payload_recipient_mismatch" | "invalid_exact_solana_payload_amount_insufficient" | "invalid_exact_solana_invalid_fee_payer" | "invalid_exact_solana_transaction_signing_failed" | "invalid_exact_solana_transaction_simulation_failed" | "invalid_exact_solana_payload_memo_mismatch" | "invalid_exact_solana_payload_memo_count" | "invalid_exact_solana_verification_failed" | "invalid_exact_solana_fee_payer_mismatch" | "invalid_exact_solana_transaction_failed" | "invalid_exact_solana_transaction_confirmation_failed" | "duplicate_settlement" | "invalid_exact_solana_extra_field" | "batch_settlement_cumulative_amount_mismatch" | "batch_settlement_channel_busy" | "missing_batch_settlement_channel" | "batch_settlement_charge_exceeds_signed_cumulative" | "batch_settlement_refund_no_balance" | "batch_settlement_refund_amount_invalid" | "batch_settlement_refund_amount_exceeds_balance" | "amount_too_low" | "invalid_amount" | "kyt_risk_detected" | "permit2_disabled" | "preflight_validation_failed" | "request_blocked_by_location" | "self_send_not_allowed" | "invalid_bazaar_extension" | "unknown_error";
 export declare const X402SettleErrorReason: any;
 /** Optional scheme-specific success metadata returned by the facilitator. */
 export type SettleX402PaymentResponseExtraMap = {
@@ -4392,9 +5714,48 @@ export interface SignSolanaTransactionWithEndUserAccountResponse {
     signedTransaction: string;
 }
 export declare const SignSolanaTransactionWithEndUserAccountResponse: S.Schema<SignSolanaTransactionWithEndUserAccountResponse>;
-/** The type of the originator's wallet. */
-export type DepositTravelRuleOriginatorWalletType = "custodial" | "self_custody";
-export declare const DepositTravelRuleOriginatorWalletType: any;
+/** The list of payment options the resource server accepts. At least one option must be present. */
+export type X402PaymentRequiredAcceptsList = Array<X402PaymentRequirements>;
+export declare const X402PaymentRequiredAcceptsList: S.Schema<X402PaymentRequiredAcceptsList>;
+/** Optional protocol extensions. Unknown keys are forwarded as-is into the signed payment payload. */
+export type X402PaymentRequiredExtensionsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const X402PaymentRequiredExtensionsMap: S.Schema<X402PaymentRequiredExtensionsMap>;
+/** The x402 protocol payment required response body, returned by a resource server when a request lacks valid payment. Contains the accepted payment options, optional resource metadata, and an optional error message from the resource server. */
+export interface X402PaymentRequired {
+    /** The x402 protocol version. */
+    x402Version: X402Version | (number & {});
+    /** The list of payment options the resource server accepts. At least one option must be present. */
+    accepts: X402PaymentRequiredAcceptsList;
+    /** Optional metadata about the resource being paid for. */
+    resource?: X402ResourceInfo;
+    /** An optional error message from the resource server describing why payment is required. */
+    error?: string;
+    /** Optional protocol extensions. Unknown keys are forwarded as-is into the signed payment payload. */
+    extensions?: X402PaymentRequiredExtensionsMap;
+}
+export declare const X402PaymentRequired: S.Schema<X402PaymentRequired>;
+export interface SignSolanaX402PaymentWithEndUserAccountRequest {
+    /** The ID of the end user. */
+    userId: string;
+    /** The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider). */
+    projectID?: string;
+    /** The complete x402 payment required response body from the resource server. Top-level fields (x402Version, resource, error, extensions) are preserved in the signed payment payload; acceptsIndex selects which entry from accepts is signed as paymentPayload.accepted. */
+    paymentRequired: X402PaymentRequired;
+    /** Zero-based index into paymentRequired.accepts selecting which payment option to sign. Must be less than the length of accepts. The entry at this index must be a Solana network payment option for this endpoint. */
+    acceptsIndex: number;
+    /** The base58 encoded address of the end user's Solana account to sign with. */
+    address: string;
+    /** Required when not using delegated signing. The ID of the Temporary Wallet Secret that was used to sign the X-Wallet-Auth Header. */
+    walletSecretId?: string;
+}
+export declare const SignSolanaX402PaymentWithEndUserAccountRequest: S.Schema<SignSolanaX402PaymentWithEndUserAccountRequest>;
+export interface SignSolanaX402PaymentWithEndUserAccountResponse {
+    /** The signed x402 payment payload. Base64-encode this and send it in the PAYMENT-SIGNATURE header of the resource request. */
+    paymentPayload: X402PaymentPayload;
+}
+export declare const SignSolanaX402PaymentWithEndUserAccountResponse: S.Schema<SignSolanaX402PaymentWithEndUserAccountResponse>;
 /** Information about the Virtual Asset Service Provider (VASP) for a deposit travel rule submission. */
 export interface DepositTravelRuleVasp {
     /** The Legal Entity Identifier (LEI) of the Virtual Asset Service Provider (VASP). */
@@ -4403,18 +5764,23 @@ export interface DepositTravelRuleVasp {
     name?: string;
 }
 export declare const DepositTravelRuleVasp: S.Schema<DepositTravelRuleVasp>;
+/** The type of the originator's wallet. */
+export type DepositTravelRuleOriginatorWalletType = "custodial" | "self_custody";
+export declare const DepositTravelRuleOriginatorWalletType: any;
 /** Originator information for a deposit travel rule submission. */
 export interface DepositTravelRuleOriginator {
     /** Full name of the originator. */
     name?: string;
-    address?: PhysicalAddress;
-    /** The type of the originator's wallet. */
-    walletType?: DepositTravelRuleOriginatorWalletType | (string & {});
+    address?: IndividualInputAddress;
+    /** Name of the financial institution. */
+    financialInstitution?: string;
     virtualAssetServiceProvider?: DepositTravelRuleVasp;
     /** Personal identifier for travel rule compliance. For individuals: passport number, national ID, or driver's license. For institutions: LEI (Legal Entity Identifier). */
     personalId?: string;
     /** Date of birth of the originator. */
     dateOfBirth?: DateOfBirth;
+    /** The type of the originator's wallet. */
+    walletType?: DepositTravelRuleOriginatorWalletType | (string & {});
 }
 export declare const DepositTravelRuleOriginator: S.Schema<DepositTravelRuleOriginator>;
 /** Beneficiary information for a deposit travel rule submission. */
@@ -4426,12 +5792,15 @@ export declare const DepositTravelRuleBeneficiary: S.Schema<DepositTravelRuleBen
 export interface SubmitDepositTravelRuleRequest {
     /** The unique identifier of the transfer. */
     transferId: string;
+    /** Indicates whether the user attests that the originating wallet belongs to them. */
+    isSelf?: boolean;
+    isIntermediary?: boolean;
+    /** When `true`, you attest that the originating wallet's ownership has been verified out-of-band. Instructs Coinbase to skip the wallet verification check for this travel-rule submission. **Only valid when `isIntermediary` is `true`.** You can only attest to the originating wallet's ownership when your organization is acting as the originating VASP on behalf of your end customer, and Coinbase is acting as the intermediary VASP. Returns a `400` error if set to `true` when `isIntermediary` is `false` or omitted. */
+    attestVerifiedWalletOwnership?: boolean;
     /** Originator information for the travel rule submission. */
     originator?: DepositTravelRuleOriginator;
     /** Beneficiary information for the travel rule submission. */
     beneficiary?: DepositTravelRuleBeneficiary;
-    /** Indicates whether the user attests that the originating wallet belongs to them. */
-    isSelf?: boolean;
 }
 export declare const SubmitDepositTravelRuleRequest: S.Schema<SubmitDepositTravelRuleRequest>;
 /** List of field paths that are still required to complete travel rule compliance. Each entry is a dot-separated path (e.g., "originator.name", "originator.address.countryCode"). Empty when status is "completed". */
@@ -4508,6 +5877,33 @@ export interface SupportedX402PaymentKindsResponse {
     signers: SupportedX402PaymentKindsResponseSignersMap;
 }
 export declare const SupportedX402PaymentKindsResponse: S.Schema<SupportedX402PaymentKindsResponse>;
+/** The project IDs that this customer is associated with. */
+export type UpdateCustomerByIdRequestProjectIdsList = Array<string>;
+export declare const UpdateCustomerByIdRequestProjectIdsList: S.Schema<UpdateCustomerByIdRequestProjectIdsList>;
+/** Terms of Service acceptances to record on the customer. Submit one entry per required version surfaced inline on `requirements.tos.tosVersions[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `tos` requirement is unsatisfied). The server rejects each acceptance whose `language` is not listed under `languages` on the matching required version with `errorType: "unsupported_tos_language"`. When new required Terms of Service versions are published, only the new `versionId`s appear in `requirements.tos.tosVersions[]`; submit acceptances for only those new version(s). Omit `tosAcceptances` on a partial update to leave previously recorded acceptances unchanged. Sending `tosAcceptances: []` is invalid (`errorType: "invalid_request"`) because it would clear all acceptances without replacing them; omit the field entirely when you are not updating Terms of Service acceptances. */
+export type UpdateCustomerByIdRequestTosAcceptancesList = Array<TosAcceptance>;
+export declare const UpdateCustomerByIdRequestTosAcceptancesList: S.Schema<UpdateCustomerByIdRequestTosAcceptancesList>;
+/** Tax attestations to record on the customer. Submit one entry per required form surfaced inline on `requirements.taxAttestation.taxForms[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `taxAttestation` requirement is unsatisfied). The required fields per entry depend on `form`; see `TaxAttestation`. This field is ingestion-only and is never returned on read. Omit `taxAttestations` on a partial update to leave previously recorded attestations unchanged. Sending `taxAttestations: []` is invalid (`errorType: "invalid_request"`) because it would clear all attestations without replacing them; omit the field entirely when you are not updating tax attestations. */
+export type UpdateCustomerByIdRequestTaxAttestationsList = Array<UsW9Attestation>;
+export declare const UpdateCustomerByIdRequestTaxAttestationsList: S.Schema<UpdateCustomerByIdRequestTaxAttestationsList>;
+export interface UpdateCustomerByIdRequest {
+    /** The ID of the customer. */
+    customerId: string;
+    /** The type of the customer. Required on create; accepted but ignored on update. */
+    type?: CustomerType | (string & {});
+    /** Capabilities to request for the customer. */
+    capabilities?: CapabilitiesMapInput;
+    /** Information about an Individual customer. Not all fields are required for all customers; the requirements depend on which capabilities are requested. Submit only fields that are required by the capabilities that have been requested. */
+    individual?: IndividualInput;
+    /** The project IDs that this customer is associated with. */
+    projectIds?: UpdateCustomerByIdRequestProjectIdsList;
+    /** Terms of Service acceptances to record on the customer. Submit one entry per required version surfaced inline on `requirements.tos.tosVersions[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `tos` requirement is unsatisfied). The server rejects each acceptance whose `language` is not listed under `languages` on the matching required version with `errorType: "unsupported_tos_language"`. When new required Terms of Service versions are published, only the new `versionId`s appear in `requirements.tos.tosVersions[]`; submit acceptances for only those new version(s). Omit `tosAcceptances` on a partial update to leave previously recorded acceptances unchanged. Sending `tosAcceptances: []` is invalid (`errorType: "invalid_request"`) because it would clear all acceptances without replacing them; omit the field entirely when you are not updating Terms of Service acceptances. */
+    tosAcceptances?: UpdateCustomerByIdRequestTosAcceptancesList;
+    /** Tax attestations to record on the customer. Submit one entry per required form surfaced inline on `requirements.taxAttestation.taxForms[]` (returned by `Get Customer`, `Create Customer`, and `Update Customer` whenever a `taxAttestation` requirement is unsatisfied). The required fields per entry depend on `form`; see `TaxAttestation`. This field is ingestion-only and is never returned on read. Omit `taxAttestations` on a partial update to leave previously recorded attestations unchanged. Sending `taxAttestations: []` is invalid (`errorType: "invalid_request"`) because it would clear all attestations without replacing them; omit the field entirely when you are not updating tax attestations. */
+    taxAttestations?: UpdateCustomerByIdRequestTaxAttestationsList;
+    compliance?: Compliance;
+}
+export declare const UpdateCustomerByIdRequest: S.Schema<UpdateCustomerByIdRequest>;
 export interface UpdateEvmAccountRequest {
     /** The 0x-prefixed address of the EVM account. The address does not need to be checksummed. */
     address: string;
@@ -4556,7 +5952,6 @@ export declare const UpdateWebhookSubscriptionRequestLabelsMap: S.Schema<UpdateW
 export interface UpdateWebhookSubscriptionRequest {
     /** Unique identifier for the webhook subscription. */
     subscriptionId: string;
-    /** Description of the webhook subscription. */
     description?: string;
     /** Types of events to subscribe to. Event types follow a three-part dot-separated format: service.resource.verb (e.g., "onchain.activity.detected", "wallet.activity.detected", "onramp.transaction.created"). */
     eventTypes: UpdateWebhookSubscriptionRequestEventTypesList;
@@ -4679,6 +6074,16 @@ export interface VerifyX402PaymentResponse {
     extra?: VerifyX402PaymentResponseExtraMap;
 }
 export declare const VerifyX402PaymentResponse: S.Schema<VerifyX402PaymentResponse>;
+export interface VoidPaymentSessionRequest {
+    /** The unique identifier of the payment session. */
+    paymentSessionId: string;
+    metadata?: Metadata;
+    /** An optional merchant-provided internal identifier for this void, from the merchant's own system—not visible to the payer. */
+    externalReferenceId?: string;
+    /** Optional customer-facing display data for this void, shown to the payer. Falls back to the session's `orderCode` when `referenceCode` is omitted. */
+    customerDisplay?: OperationCustomerDisplay;
+}
+export declare const VoidPaymentSessionRequest: S.Schema<VoidPaymentSessionRequest>;
 export type AddEndUserEvmAccountError = CoinbaseOpError;
 /** Add EVM account to end user Adds a new EVM EOA account to an existing end user. End users can have up to 10 EVM accounts. This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key. */
 export declare const addEndUserEvmAccount: API.OperationMethod<AddEndUserEvmAccountRequest, AddEndUserEvmAccountResponse, AddEndUserEvmAccountError, CoinbaseOpContext>;
@@ -4688,12 +6093,33 @@ export declare const addEndUserEvmSmartAccount: API.OperationMethod<AddEndUserEv
 export type AddEndUserSolanaAccountError = CoinbaseOpError;
 /** Add Solana account to end user Adds a new Solana account to an existing end user. End users can have up to 10 Solana accounts. This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key. */
 export declare const addEndUserSolanaAccount: API.OperationMethod<AddEndUserSolanaAccountRequest, AddEndUserSolanaAccountResponse, AddEndUserSolanaAccountError, CoinbaseOpContext>;
+export type AuthorizeCoinbasePaymentSessionError = CoinbaseOpError;
+/** Authorize a payment session with a Coinbase account **Merchant-initiated.** The merchant charges the payer's Coinbase account using an OAuth grant the payer authorized earlier, so the payer does not need to be present at payment time. The session must be in `created` status. **Authentication:** Requires a Coinbase OAuth Bearer token with the `coinbase:stablecoins:payment-create` scope. On authorization, a hold is placed on the payer's funds. The authorization is returned in `pending` status and transitions asynchronously to `succeeded` or `failed`. If `autoCapture` is enabled on the session, a capture is automatically created after a successful authorization. */
+export declare const authorizeCoinbasePaymentSession: API.OperationMethod<AuthorizeCoinbasePaymentSessionRequest, Authorization, AuthorizeCoinbasePaymentSessionError, CoinbaseOpContext>;
+export type AuthorizeWalletPaymentSessionError = CoinbaseOpError;
+/** Authorize a payment session with a wallet **Customer-initiated.** Authorizes a payment session using the payer's wallet. The payer signs the payloads themselves, so this call is unauthenticated. The session must be in `created` status. The `optionId` must match one of the options returned by the **Get Wallet Authorization Options** endpoint. Include the signed payloads for the selected option. On authorization, a hold is placed on the payer's funds. The authorization is returned in `pending` status and transitions asynchronously to `succeeded` or `failed`. If `autoCapture` is enabled on the session, a capture is automatically created after a successful authorization. */
+export declare const authorizeWalletPaymentSession: API.OperationMethod<AuthorizeWalletPaymentSessionRequest, Authorization, AuthorizeWalletPaymentSessionError, CoinbaseOpContext>;
+export type AuthorizeX402PaymentSessionError = CoinbaseOpError;
+/** Authorize a payment session with x402 **Customer-initiated.** Authorizes a payment session using x402. The payer supplies the payment payload, so this call is unauthenticated. The session must be in `created` status. The client sends no request body. You may supply the base64-encoded x402-compliant payment payload in the optional **`PAYMENT-SIGNATURE`** header. On authorization, a hold is placed on the payer's funds. The authorization is returned in `pending` status and transitions asynchronously to `succeeded` or `failed`. **402 Payment Required** may be returned when payment must be supplied before authorization can proceed. The **402** response uses the standard CDP **`Error`** JSON body and may include a **`PAYMENT-REQUIRED`** header (see the **402** response) describing accepted networks, assets, and amounts. If `autoCapture` is enabled on the session, a capture is automatically created after a successful authorization. */
+export declare const authorizeX402PaymentSession: API.OperationMethod<AuthorizeX402PaymentSessionRequest, Authorization, AuthorizeX402PaymentSessionError, CoinbaseOpContext>;
+export type CancelPaymentSessionError = CoinbaseOpError;
+/** Cancel a payment session Cancels a payment session before any funds have been authorized or captured. The session must be in `created` status. Cancel is blocked while any authorization action is pending. Once canceled, no further actions can be performed on the session. This is the only way to terminate a pre-authorization session — expiry deadlines block actions but do not automatically transition the session to a terminal state. */
+export declare const cancelPaymentSession: API.OperationMethod<CancelPaymentSessionRequest, PaymentSession, CancelPaymentSessionError, CoinbaseOpContext>;
+export type CapturePaymentSessionError = CoinbaseOpError;
+/** Capture a payment session Captures authorized funds. The session must have a positive `capturable` balance and the `captureExpiresAt` deadline must not have passed. This is an asynchronous operation. The capture is returned in `pending` status and transitions to `succeeded` or `failed`. Multiple partial captures are allowed. If `amount` is omitted, the full remaining capturable amount is captured. */
+export declare const capturePaymentSession: API.OperationMethod<CapturePaymentSessionRequest, Capture, CapturePaymentSessionError, CoinbaseOpContext>;
+export type CreateCustomerError = CoinbaseOpError;
+/** Create a customer Create a new customer record. You can optionally request capabilities and submit verification requirements in the same request. This endpoint supports creating a customer with: - Minimal data (customer type only) - Capability requests - KYC data submission - Combined request for capability and required info for verification */
+export declare const createCustomer: API.OperationMethod<CreateCustomerRequest, Customer, CreateCustomerError, CoinbaseOpContext>;
 export type CreateDelegationForEndUserAccountError = CoinbaseOpError;
 /** Create account-scoped delegation for end user Creates an account-scoped delegation that allows a developer to sign on behalf of an end user for a single blockchain account (identified by its address) for the specified duration. The end user must be authenticated to authorize this delegation. Multiple account-scoped delegations may exist concurrently for a single end user (one per canonical account address). Account-scoped and user-scoped delegations cannot coexist for the same user. When the address corresponds to an EVM Smart Account, the delegation is scoped to the Smart Account's owner EOA rather than the Smart Account address itself. This means `/address/{smartAccountAddress}/delegation` and `/address/{ownerEoaAddress}/delegation` resolve to the same delegation, and the 409 `account_scoped_delegation_active` error may be returned when creating via either address if one already exists for the canonical owner. */
 export declare const createDelegationForEndUserAccount: API.OperationMethod<CreateDelegationForEndUserAccountRequest, CreateDelegationForEndUserAccountResponse, CreateDelegationForEndUserAccountError, CoinbaseOpContext>;
 export type CreateDepositDestinationError = CoinbaseOpError;
-/** Create deposit destination Create a new deposit destination for an account. A deposit destination is a cryptocurrency address that can be used to receive funds. The address will be generated for the specified network. */
-export declare const createDepositDestination: API.OperationMethod<CreateDepositDestinationRequest, CreateDepositDestinationResponse, CreateDepositDestinationError, CoinbaseOpContext>;
+/** Create deposit destination Create a new deposit destination for an account. Two types are supported: - `crypto` (public): provisions a cryptocurrency address on the requested network. The returned `crypto.address` is the deposit address; funds sent to it are credited to the `target` account in the specified asset. For Customer-owned accounts, the Customer must have the `custodyCrypto` and `custodyStablecoin` capabilities enabled. - `fiat` (private-beta): provisions a bank account at a CDP banking partner. The server picks the account type (e.g. `us_bank`) and supported payment rails based on the account's eligibility; pass `fiat.paymentRail` to influence partner selection. The returned `fiat` object contains the bank account details the depositor needs to send funds. For Customer-owned accounts, the Customer must have the `custodyFiat` capability enabled. Requires account enablement — contact your Coinbase representative for access. Fields and behavior may change before general availability. For Customer-owned accounts not authorized for the required capabilities, the request is rejected with `customer_not_authorized` (HTTP 403). The created destination's `status` starts as `pending` for fiat (it becomes `active` once the partner provisioning callback completes) and `active` for crypto. */
+export declare const createDepositDestination: API.OperationMethod<CreateDepositDestinationRequest2, CreateDepositDestinationResponse, CreateDepositDestinationError, CoinbaseOpContext>;
+export type CreateDisbursementError = CoinbaseOpError;
+/** Create a disbursement Creates a merchant-initiated payment of funds from a CDP account owned by the merchant to a Coinbase user account or onchain address. Used for standalone refunds, goodwill disbursements, rebates, and other merchant-driven payouts that are not tied to a specific payment session. This is an asynchronous operation. The disbursement is returned in `pending` status and transitions to `succeeded` (with associated `onchainTransactions`) or `failed` (with `error`). */
+export declare const createDisbursement: API.OperationMethod<CreateDisbursementRequest, Disbursement, CreateDisbursementError, CoinbaseOpContext>;
 export type CreateEndUserError = CoinbaseOpError;
 /** Create end user Creates an end user. An end user is an entity that can own CDP EVM accounts, EVM smart accounts, and/or Solana accounts. 1 or more authentication methods must be associated with an end user. By default, no accounts are created unless the optional `evmAccount` and/or `solanaAccount` fields are provided. This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key. */
 export declare const createEndUser: API.OperationMethod<CreateEndUserRequest, EndUser, CreateEndUserError, CoinbaseOpContext>;
@@ -4713,14 +6139,17 @@ export type CreateEvmSwapQuoteError = CoinbaseOpError;
 /** Create swap quote Create a swap quote, which includes the payload to sign as well as the transaction data needed to execute the swap. The developer is responsible for signing the payload and submitting the transaction to the network in order to execute the swap. */
 export declare const createEvmSwapQuote: API.OperationMethod<CreateEvmSwapQuoteRequest, CreateEvmSwapQuoteResponse, CreateEvmSwapQuoteError, CoinbaseOpContext>;
 export type CreateFoundationAccountError = CoinbaseOpError;
-/** Create account Create an account for your Entity. Support for creating Customer-owned accounts is in development. */
+/** Create account Create an account. Two ownership modes are supported: - **Entity-owned**: when `owner` is omitted, the account is owned by the Entity making the request. Returns an account with `owner: entity_<uuid>`. - **Customer-owned**: pass a Customer ID as `owner` (e.g. `customer_af2937b0-9846-4fe7-bfe9-ccc22d935114`). The Customer must have the `custodyCrypto`, `custodyFiat`, and `custodyStablecoin` capabilities enabled, otherwise the request is rejected with `customer_not_authorized` (HTTP 403). */
 export declare const createFoundationAccount: API.OperationMethod<CreateFoundationAccountRequest, Account, CreateFoundationAccountError, CoinbaseOpContext>;
 export type CreateOnrampOrderError = CoinbaseOpError;
-/** Create an onramp order Create a new Onramp order or get a quote for an Onramp order. Either `paymentAmount` or `purchaseAmount` must be provided. This API currently only supports the payment method `GUEST_CHECKOUT_APPLE_PAY`. For detailed integration instructions and to get access to this API, refer to the [Apple Pay Onramp API docs](https://docs.cdp.coinbase.com/onramp-&-offramp/onramp-apis/apple-pay-onramp-api). */
+/** Create an onramp order Create a new Onramp order or get a quote for an Onramp order. Either `paymentAmount` or `purchaseAmount` must be provided. This API supports two modes: **Headless mode (standard)**: returns a seamless Apple Pay or Google Pay button that you integrate directly into your app. Your app collects and verifies the user's contact details before calling this endpoint — `phoneNumber`, `email`, `phoneNumberVerifiedAt`, and `agreementAcceptedAt` are required and enforced server-side. **Embedded mode**: returns a webview that collects and verifies the user's contact and identity information, then shows the payment screen. Omit both `phoneNumber` and `email` from the request to select this mode. Embedded mode requires account enablement; contact the Onramp team for access. Read more about the difference between the two modes in the [Headless Onramp overview](https://docs.cdp.coinbase.com/onramp/headless-onramp/overview). This API supports the `GUEST_CHECKOUT_APPLE_PAY` and `GUEST_CHECKOUT_GOOGLE_PAY` payment methods. For detailed integration instructions and to get access to this API, refer to the [Guest Checkout Onramp API docs](https://docs.cdp.coinbase.com/onramp/headless-onramp/overview). */
 export declare const createOnrampOrder: API.OperationMethod<CreateOnrampOrderRequest, CreateOnrampOrderResponse, CreateOnrampOrderError, CoinbaseOpContext>;
 export type CreateOnrampSessionError = CoinbaseOpError;
 /** Create an onramp session Returns a single-use URL for an Onramp session. This API provides flexible functionality based on the parameters provided, supporting three cases: **Important**: The returned URL is single-use only. Once a user visits the URL, no one else can access it. ## Use Cases ### 1. Basic Session (Minimum Parameters) **Required**: `destinationAddress`, `purchaseCurrency`, `destinationNetwork` **Returns**: Basic single-use onramp URL. The `quote` object will not be included in the response. ### 2. One-Click Onramp URL **Required**: Basic parameters + (`paymentAmount` OR `purchaseAmount`), `paymentCurrency` **Returns**: One-click onramp URL for streamlined checkout. The `quote` object will not be included in the response. ### 3. One-Click Onramp URL with Quote **Required**: One-Click Onramp parameters + `paymentMethod`, `country`, `subdivision` **Returns**: Complete pricing quote and one-click onramp URL. Both `session` and `quote` objects will be included in the response. **Note**: Only one of `paymentAmount` or `purchaseAmount` should be provided, not both. Providing both will result in an error. When `paymentAmount` is provided, the quote shows how much crypto the user will receive for the specified fiat amount (fee-inclusive). When `purchaseAmount` is provided, the quote shows how much fiat the user needs to pay for the specified crypto amount (fee-exclusive). */
 export declare const createOnrampSession: API.OperationMethod<CreateOnrampSessionRequest, CreateOnrampSessionResponse, CreateOnrampSessionError, CoinbaseOpContext>;
+export type CreatePaymentSessionError = CoinbaseOpError;
+/** Create a payment session Creates a payment session that defines what is being paid — amount, asset, and target. Optionally configure execution behavior, expiry deadlines, redirect URLs, and metadata. If expiry deadlines are omitted, sensible defaults are applied (1 day for authorization, 7 days for capture, 30 days for refund). Expiries must be in ascending order — see the `expiries` object for details and constraints. Returns the session in `created` status. Next step: call one of the authorization endpoints (wallet or Coinbase) to authorize the payment. */
+export declare const createPaymentSession: API.OperationMethod<CreatePaymentSessionRequest, PaymentSession, CreatePaymentSessionError, CoinbaseOpContext>;
 export type CreatePolicyError = CoinbaseOpError;
 /** Create policy Create a policy that can be used to govern the behavior of accounts. */
 export declare const createPolicy: API.OperationMethod<CreatePolicyRequest, Policy, CreatePolicyError, CoinbaseOpContext>;
@@ -4736,6 +6165,12 @@ export declare const createTransfer: API.OperationMethod<CreateTransferRequest,
 export type CreateWebhookSubscriptionError = CoinbaseOpError;
 /** Create webhook subscription Subscribe to real-time events across CDP products. ### Filtering Onchain events can utilize multi-label filtering to only receive events that match all the specified labels. Allows labels are: - `network` (required) — Blockchain network - `contract_address` — Smart contract address - `event_name` — Event name (e.g., "Transfer", "Burn") - `event_signature` — Event signature (e.g., "Transfer(address,address,uint256)") - `transaction_from` — Transaction sender address - `transaction_to` — Transaction recipient address - `params.*` — Any event parameter from the log event (e.g., `params.from`, `params.to`, `params.sender`, `params.tokenId`) For webhook types that aren't `onchain.*`, labels are ignored. ### Webhook Signature Verification All webhooks include an HMAC-SHA256 signed header for security. The signature is signed with the secret that is returned in the `secret` field when creating a subscription. Do not lose the secret, as you will not be able to recreate it. If you lose the secret, you will need to create a new subscription. See the [verification guide](https://docs.cdp.coinbase.com/onramp-&-offramp/webhooks#webhook-signature-verification) for implementation details. */
 export declare const createWebhookSubscription: API.OperationMethod<CreateWebhookSubscriptionRequest, WebhookSubscriptionResponse, CreateWebhookSubscriptionError, CoinbaseOpContext>;
+export type CreateX402DiscoveryMcpError = CoinbaseOpError;
+/** Handle MCP JSON-RPC request Handles JSON-RPC requests for the Model Context Protocol (MCP). Supports MCP methods for discovering x402 payment resources and tools. */
+export declare const createX402DiscoveryMcp: API.OperationMethod<CreateX402DiscoveryMcpRequest, X402McpResponse, CreateX402DiscoveryMcpError, CoinbaseOpContext>;
+export type DeleteCustomerError = CoinbaseOpError;
+/** Delete a customer Initiates deletion of the customer and all associated data. This operation is idempotent — repeated calls for an already-deleted customer return 204. A 404 is returned only when no customer with the given ID exists for the caller's entity. */
+export declare const deleteCustomer: API.OperationMethod<DeleteCustomerRequest, DeleteCustomerResponse, DeleteCustomerError, CoinbaseOpContext>;
 export type DeletePolicyError = CoinbaseOpError;
 /** Delete policy Delete a policy by its ID. This will have the effect of removing the policy from all accounts that are currently using it. */
 export declare const deletePolicy: API.OperationMethod<DeletePolicyRequest, DeletePolicyResponse, DeletePolicyError, CoinbaseOpContext>;
@@ -4760,15 +6195,21 @@ export declare const exportSolanaAccountByName: API.OperationMethod<ExportSolana
 export type GetBalanceByAssetError = CoinbaseOpError;
 /** Get balance for account Get the balance for an account by asset. */
 export declare const getBalanceByAsset: API.OperationMethod<GetBalanceByAssetRequest, Balance, GetBalanceByAssetError, CoinbaseOpContext>;
+export type GetCustomerError = CoinbaseOpError;
+/** Get a customer Get a customer by their ID. Returns the full customer object. */
+export declare const getCustomer: API.OperationMethod<GetCustomerRequest, Customer, GetCustomerError, CoinbaseOpContext>;
 export type GetDelegationForEndUserError = CoinbaseOpError;
 /** Get delegation for end user Returns the active delegation for the specified end user, if one exists. This operation can be performed by the end user themselves or by a developer using their API key. */
 export declare const getDelegationForEndUser: API.OperationMethod<GetDelegationForEndUserRequest, GetDelegationForEndUserResponse, GetDelegationForEndUserError, CoinbaseOpContext>;
 export type GetDelegationForEndUserAccountError = CoinbaseOpError;
 /** Get account-scoped delegation for end user Returns the active account-scoped delegation for the specified end user account, if one exists. Useful for showing delegation status in a UI. When the address corresponds to an EVM Smart Account, this returns the delegation for the Smart Account's owner EOA. */
 export declare const getDelegationForEndUserAccount: API.OperationMethod<GetDelegationForEndUserAccountRequest, GetDelegationForEndUserAccountResponse, GetDelegationForEndUserAccountError, CoinbaseOpContext>;
-export type GetDepositDestinationByIdError = CoinbaseOpError;
+export type GetDepositDestinationError = CoinbaseOpError;
 /** Get deposit destination Get a specific deposit destination by its ID. */
-export declare const getDepositDestinationById: API.OperationMethod<GetDepositDestinationByIdRequest, GetDepositDestinationByIdResponse, GetDepositDestinationByIdError, CoinbaseOpContext>;
+export declare const getDepositDestination: API.OperationMethod<GetDepositDestinationRequest, GetDepositDestinationResponse, GetDepositDestinationError, CoinbaseOpContext>;
+export type GetDisbursementError = CoinbaseOpError;
+/** Get a disbursement Retrieves a single disbursement by its ID, including source, target, status, amount, associated onchain transactions, error details (if failed), and timestamps. Only returns the disbursement if the API key has permission to access it. */
+export declare const getDisbursement: API.OperationMethod<GetDisbursementRequest, Disbursement, GetDisbursementError, CoinbaseOpContext>;
 export type GetEndUserError = CoinbaseOpError;
 /** Get end user Gets an end user by ID. This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key. */
 export declare const getEndUser: API.OperationMethod<GetEndUserRequest, EndUser, GetEndUserError, CoinbaseOpContext>;
@@ -4778,9 +6219,9 @@ export declare const getEvmAccount: API.OperationMethod<GetEvmAccountRequest, Ev
 export type GetEvmAccountByNameError = CoinbaseOpError;
 /** Get EVM account by name Gets an EVM account by its name. */
 export declare const getEvmAccountByName: API.OperationMethod<GetEvmAccountByNameRequest, EvmAccount, GetEvmAccountByNameError, CoinbaseOpContext>;
-export type GetEvmEip7702DelegationOperationByIdError = CoinbaseOpError;
+export type GetEvmEip7702DelegationOperationError = CoinbaseOpError;
 /** Get EIP-7702 delegation operation by ID Returns the EIP-7702 delegation operation. Use the delegationOperationId returned by the Create EIP-7702 delegation endpoint to poll for operation completion. */
-export declare const getEvmEip7702DelegationOperationById: API.OperationMethod<GetEvmEip7702DelegationOperationByIdRequest, EvmEip7702DelegationOperation, GetEvmEip7702DelegationOperationByIdError, CoinbaseOpContext>;
+export declare const getEvmEip7702DelegationOperation: API.OperationMethod<GetEvmEip7702DelegationOperationRequest, EvmEip7702DelegationOperation, GetEvmEip7702DelegationOperationError, CoinbaseOpContext>;
 export type GetEvmSmartAccountError = CoinbaseOpError;
 /** Get Smart Account by address Gets a Smart Account by its address. */
 export declare const getEvmSmartAccount: API.OperationMethod<GetEvmSmartAccountRequest, EvmSmartAccount, GetEvmSmartAccountError, CoinbaseOpContext>;
@@ -4793,15 +6234,30 @@ export declare const getEvmSwapPrice: API.OperationMethod<GetEvmSwapPriceRequest
 export type GetFoundationAccountByIdError = CoinbaseOpError;
 /** Get account Get an account by its ID. */
 export declare const getFoundationAccountById: API.OperationMethod<GetFoundationAccountByIdRequest, Account, GetFoundationAccountByIdError, CoinbaseOpContext>;
-export type GetOnrampOrderByIdError = CoinbaseOpError;
+export type GetOnrampOrderError = CoinbaseOpError;
 /** Get an onramp order by ID Get an onramp order by ID. */
-export declare const getOnrampOrderById: API.OperationMethod<GetOnrampOrderByIdRequest, GetOnrampOrderByIdResponse, GetOnrampOrderByIdError, CoinbaseOpContext>;
+export declare const getOnrampOrder: API.OperationMethod<GetOnrampOrderRequest, GetOnrampOrderResponse, GetOnrampOrderError, CoinbaseOpContext>;
 export type GetOnrampUserLimitsError = CoinbaseOpError;
 /** Get onramp user limits Returns the transaction limits for an onramp user based on their payment method and user identifier. Use this API to show users their remaining purchase capacity before initiating an onramp transaction. Currently supports `GUEST_CHECKOUT_APPLE_PAY` payment method with phone number identification. The phone number must have been previously verified via OTP. */
 export declare const getOnrampUserLimits: API.OperationMethod<GetOnrampUserLimitsRequest, GetOnrampUserLimitsResponse, GetOnrampUserLimitsError, CoinbaseOpContext>;
 export type GetPaymentMethodError = CoinbaseOpError;
 /** Get payment method Get details of a specific payment method by its ID. Returns 404 if the payment method is not found or not owned by the requesting entity. */
 export declare const getPaymentMethod: API.OperationMethod<GetPaymentMethodRequest, GetPaymentMethodResponse, GetPaymentMethodError, CoinbaseOpContext>;
+export type GetPaymentSessionError = CoinbaseOpError;
+/** Get a payment session Retrieves a single payment session by its ID, including its current status, balances, and associated metadata. The API key must have permission to access the requested session. */
+export declare const getPaymentSession: API.OperationMethod<GetPaymentSessionRequest, PaymentSession, GetPaymentSessionError, CoinbaseOpContext>;
+export type GetPaymentSessionAuthorizationError = CoinbaseOpError;
+/** Get a payment session authorization Retrieves a single authorization by its ID, including its current status, amount, and any associated onchain transactions. */
+export declare const getPaymentSessionAuthorization: API.OperationMethod<GetPaymentSessionAuthorizationRequest, Authorization, GetPaymentSessionAuthorizationError, CoinbaseOpContext>;
+export type GetPaymentSessionCaptureError = CoinbaseOpError;
+/** Get a payment session capture Retrieves a single capture by its ID, including status, captured amount, associated onchain transactions, and timestamps. Only returns the capture if the API key has permission to access it. */
+export declare const getPaymentSessionCapture: API.OperationMethod<GetPaymentSessionCaptureRequest, Capture, GetPaymentSessionCaptureError, CoinbaseOpContext>;
+export type GetPaymentSessionRefundError = CoinbaseOpError;
+/** Get a payment session refund Retrieves a single refund by its ID, including status, refunded amount, reason, associated onchain transactions, and timestamps. Only returns the refund if the API key has permission to access it. */
+export declare const getPaymentSessionRefund: API.OperationMethod<GetPaymentSessionRefundRequest, Refund, GetPaymentSessionRefundError, CoinbaseOpContext>;
+export type GetPaymentSessionVoidError = CoinbaseOpError;
+/** Get a payment session void Retrieves a single void by its ID, including status, voided amount, associated onchain transactions, and timestamps. Only returns the void if the API key has permission to access it. */
+export declare const getPaymentSessionVoid: API.OperationMethod<GetPaymentSessionVoidRequest, Void, GetPaymentSessionVoidError, CoinbaseOpContext>;
 export type GetPolicyByIdError = CoinbaseOpError;
 /** Get policy by ID Get a policy by its ID. */
 export declare const getPolicyById: API.OperationMethod<GetPolicyByIdRequest, Policy, GetPolicyByIdError, CoinbaseOpContext>;
@@ -4817,15 +6273,21 @@ export declare const getSQLGrammar: API.OperationMethod<GetSQLGrammarRequest, Ge
 export type GetSQLSchemaError = CoinbaseOpError;
 /** Get schema details Retrieve the schema information for the available tables in the SQL API's indexed data. This includes table names, column definitions, data types, and indexed fields. */
 export declare const getSQLSchema: API.OperationMethod<GetSQLSchemaRequest, OnchainDataSchemaResponse, GetSQLSchemaError, CoinbaseOpContext>;
-export type GetTransferByIdError = CoinbaseOpError;
+export type GetTransferError = CoinbaseOpError;
 /** Get transfer Get a transfer by its ID. */
-export declare const getTransferById: API.OperationMethod<GetTransferByIdRequest, Transfer, GetTransferByIdError, CoinbaseOpContext>;
+export declare const getTransfer: API.OperationMethod<GetTransferRequest, Transfer, GetTransferError, CoinbaseOpContext>;
 export type GetUserOperationError = CoinbaseOpError;
 /** Get user operation Gets a user operation by its hash. */
 export declare const getUserOperation: API.OperationMethod<GetUserOperationRequest, EvmUserOperation, GetUserOperationError, CoinbaseOpContext>;
+export type GetWalletAuthorizationOptionsError = CoinbaseOpError;
+/** Get wallet authorization options Returns the available wallet authorization options for a payment session. The session must be in `created` status. Provide one or more payer wallet addresses as query parameters. Each option specifies the currency, amount, network, and payloads the payer must sign to authorize the payment. Present the options to the payer and let them choose one, then call **Authorize Wallet** with the selected option. This is a stateless read operation — the session is not modified. If a requested address has no eligible authorization options (e.g. insufficient funds), it appears in `ineligibleAddresses` with a `code` and `message` instead of being absent from `options`. When an address is ineligible because of `insufficient_funds`, its `fundsRequired` array lists, per enabled (network, asset) combination, the current balance and required balance the payer needs to become eligible. */
+export declare const getWalletAuthorizationOptions: API.OperationMethod<GetWalletAuthorizationOptionsRequest, WalletAuthorizationOptionsResponse, GetWalletAuthorizationOptionsError, CoinbaseOpContext>;
 export type GetWebhookSubscriptionError = CoinbaseOpError;
 /** Get webhook subscription Retrieve detailed information about a specific webhook subscription including configuration, status, creation timestamp, and webhook signature secret. ### Response Includes - Subscription configuration and filters - Target URL and custom headers - Webhook signature secret for verification - Creation timestamp and status */
 export declare const getWebhookSubscription: API.OperationMethod<GetWebhookSubscriptionRequest, WebhookSubscriptionResponse, GetWebhookSubscriptionError, CoinbaseOpContext>;
+export type GetX402BundleError = CoinbaseOpError;
+/** Get an x402 bundle Gets a single curated x402 workflow bundle by its bundle slug, including the bundle metadata and its ordered member resources joined to their full discovery metadata. */
+export declare const getX402Bundle: API.OperationMethod<GetX402BundleRequest, GetX402BundleResponse, GetX402BundleError, CoinbaseOpContext>;
 export type ImportEndUserError = CoinbaseOpError;
 /** Import end user private key Imports an existing private key for an end user into the developer's CDP Project. The private key must be encrypted using the CDP SDK's encryption scheme before being sent to this endpoint. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted. This endpoint allows developers to import existing keys for their end users, supporting both EVM and Solana key types. The end user must have at least one authentication method configured. */
 export declare const importEndUser: API.OperationMethod<ImportEndUserRequest, EndUser, ImportEndUserError, CoinbaseOpContext>;
@@ -4841,12 +6303,21 @@ export declare const initiateOnrampVerification: API.OperationMethod<InitiateOnr
 export type ListBalancesError = CoinbaseOpError;
 /** List balances for account List the balances for an account. Results are sorted by native-fiat equivalent balance in descending order. */
 export declare const listBalances: API.OperationMethod<ListBalancesRequest, ListBalancesResponse, ListBalancesError, CoinbaseOpContext>;
+export type ListCoinbaseAccountBalancesError = CoinbaseOpError;
+/** List Coinbase account balances Returns the balances held in the Coinbase account. The `available` amount is the immediately spendable balance. The `total` amount also includes funds currently on hold. Both amounts are returned as decimal strings with 2 decimal places (e.g. `"50.00"`). **Authentication:** Requires a Coinbase OAuth Bearer token with the `coinbase:stablecoins:balance-read` scope. **Returned assets:** Currently always returns a single USDC entry. If the payer holds no USDC, the entry is still returned with an `available` and `total` of `"0"` so callers do not need to special-case a missing asset. Additional assets may be returned in the future without a contract change. */
+export declare const listCoinbaseAccountBalances: API.OperationMethod<ListCoinbaseAccountBalancesRequest, Balances, ListCoinbaseAccountBalancesError, CoinbaseOpContext>;
+export type ListCustomersError = CoinbaseOpError;
+/** List customers List all customers. The API will return all customers that the API Key has permissions to access. Results are not returned in any guaranteed order. */
+export declare const listCustomers: API.OperationMethod<ListCustomersRequest, ListCustomersResponse, ListCustomersError, CoinbaseOpContext>;
 export type ListDataTokenBalancesError = CoinbaseOpError;
-/** List EVM token balances Lists the token balances of an EVM address on a given network. The balances include ERC-20 tokens and the native gas token (usually ETH). The response is paginated, and by default, returns 20 balances per page. **Note:** This endpoint provides <1 second freshness from chain tip, <500ms response latency for wallets with reasonable token history, and 99.9% uptime for production use. */
+/** List EVM token balances Lists the token balances of an EVM address on a given network. The balances include ERC-20 tokens and the native gas token (usually ETH). The response is paginated, and by default, returns 20 balances per page. Calls to the `base` and `base-sepolia` networks offer: * 99.5% < 2 second freshness from chain tip for new tokens on an address. * 99.5% < 2 second freshness from chain tip for balance data. Calls to the `ethereum` network offer: * 99% < 30 second freshness from chain tip for new tokens on an address. * 99% < 2 second freshness from chain tip for balance data. */
 export declare const listDataTokenBalances: API.OperationMethod<ListDataTokenBalancesRequest, ListDataTokenBalancesResponse, ListDataTokenBalancesError, CoinbaseOpContext>;
 export type ListDepositDestinationsError = CoinbaseOpError;
 /** List deposit destinations List deposit destinations. You can optionally filter the results by type, account ID, network, or cryptocurrency address. Results are sorted by creation date in descending order (newest first). */
 export declare const listDepositDestinations: API.OperationMethod<ListDepositDestinationsRequest, ListDepositDestinationsResponse, ListDepositDestinationsError, CoinbaseOpContext>;
+export type ListDisbursementsError = CoinbaseOpError;
+/** List disbursements Returns a paginated list of disbursements created by the merchant. Each disbursement includes its source, target, status, amount, and timestamps. Only disbursements accessible by the current API key are returned. */
+export declare const listDisbursements: API.OperationMethod<ListDisbursementsRequest, ListDisbursementsResponse, ListDisbursementsError, CoinbaseOpContext>;
 export type ListEndUsersError = CoinbaseOpError;
 /** List end users Lists the end users belonging to the developer's CDP Project. By default, the response is sorted by creation date in ascending order and paginated to 20 users per page. */
 export declare const listEndUsers: API.OperationMethod<ListEndUsersRequest, ListEndUsersResponse, ListEndUsersError, CoinbaseOpContext>;
@@ -4857,7 +6328,7 @@ export type ListEvmSmartAccountsError = CoinbaseOpError;
 /** List Smart Accounts Lists the Smart Accounts belonging to the developer's CDP Project. The response is paginated, and by default, returns 20 accounts per page. */
 export declare const listEvmSmartAccounts: API.OperationMethod<ListEvmSmartAccountsRequest, ListEvmSmartAccountsResponse, ListEvmSmartAccountsError, CoinbaseOpContext>;
 export type ListEvmTokenBalancesError = CoinbaseOpError;
-/** List EVM token balances Lists the token balances of an EVM address on a given network. The balances include ERC-20 tokens and the native gas token (usually ETH). The response is paginated, and by default, returns 20 balances per page. **Note:** This endpoint is still under development and does not yet provide strong freshness guarantees. Specifically, balances of new tokens can, on occasion, take up to ~30 seconds to appear, while balances of tokens already belonging to an address will generally be close to chain tip. Freshness of new token balances will improve over the coming weeks. */
+/** List EVM token balances Lists the token balances of an EVM address on a given network. The balances include ERC-20 tokens and the native gas token (usually ETH). The response is paginated, and by default, returns 20 balances per page. Calls to the `base` and `base-sepolia` networks offer: * 99.5% < 2 second freshness from chain tip for new tokens on an address. * 99.5% < 2 second freshness from chain tip for balance data. Calls to the `ethereum` network offer: * 99% < 30 second freshness from chain tip for new tokens on an address. * 99% < 2 second freshness from chain tip for balance data. */
 export declare const listEvmTokenBalances: API.OperationMethod<ListEvmTokenBalancesRequest, ListEvmTokenBalancesResponse, ListEvmTokenBalancesError, CoinbaseOpContext>;
 export type ListFoundationAccountsError = CoinbaseOpError;
 /** List accounts List all accounts. The API will return all accounts that the API Key has Permissions to access. You can filter the results by using query parameters, which will be treated as a single conjunction (i.e. AND). Results are sorted by creation date in descending order (newest first). */
@@ -4865,6 +6336,21 @@ export declare const listFoundationAccounts: API.OperationMethod<ListFoundationA
 export type ListPaymentMethodsError = CoinbaseOpError;
 /** List payment methods List payment methods linked to your entity. Payment methods represent external financial instruments that can be used as a target for transfers. The list will not include disabled or deleted payment methods. **Currently Supported Types:** - `fedwire`: Domestic USD wire transfers - `swift`: International wire transfers - `sepa`: SEPA EUR transfers **Note:** Payment methods are created and verified through your linked CDP entity. Currently, fetching payment methods is only supported for Prime investment vehicles linked to CDP. */
 export declare const listPaymentMethods: API.OperationMethod<ListPaymentMethodsRequest, ListPaymentMethodsResponse, ListPaymentMethodsError, CoinbaseOpContext>;
+export type ListPaymentSessionAuthorizationsError = CoinbaseOpError;
+/** List payment session authorizations Returns a paginated list of authorizations for a payment session. Each authorization represents a hold on funds and includes its current status and amount. */
+export declare const listPaymentSessionAuthorizations: API.OperationMethod<ListPaymentSessionAuthorizationsRequest, ListPaymentSessionAuthorizationsResponse, ListPaymentSessionAuthorizationsError, CoinbaseOpContext>;
+export type ListPaymentSessionCapturesError = CoinbaseOpError;
+/** List payment session captures Returns a paginated list of captures for a payment session. Each capture includes its status, amount, associated onchain transactions, and timestamps. Only captures accessible by the current API key are returned. */
+export declare const listPaymentSessionCaptures: API.OperationMethod<ListPaymentSessionCapturesRequest, ListPaymentSessionCapturesResponse, ListPaymentSessionCapturesError, CoinbaseOpContext>;
+export type ListPaymentSessionRefundsError = CoinbaseOpError;
+/** List payment session refunds Returns a paginated list of refunds for a payment session. Each refund includes its status, amount, reason, associated onchain transactions, and timestamps. Only refunds accessible by the current API key are returned. */
+export declare const listPaymentSessionRefunds: API.OperationMethod<ListPaymentSessionRefundsRequest, ListPaymentSessionRefundsResponse, ListPaymentSessionRefundsError, CoinbaseOpContext>;
+export type ListPaymentSessionsError = CoinbaseOpError;
+/** List payment sessions Returns a paginated list of payment sessions that the API key has permission to access. */
+export declare const listPaymentSessions: API.OperationMethod<ListPaymentSessionsRequest, ListPaymentSessionsResponse, ListPaymentSessionsError, CoinbaseOpContext>;
+export type ListPaymentSessionVoidsError = CoinbaseOpError;
+/** List payment session voids Returns a paginated list of voids for a payment session. Each void includes its status, amount, associated onchain transactions, and timestamps. Only voids accessible by the current API key are returned. */
+export declare const listPaymentSessionVoids: API.OperationMethod<ListPaymentSessionVoidsRequest, ListPaymentSessionVoidsResponse, ListPaymentSessionVoidsError, CoinbaseOpContext>;
 export type ListPoliciesError = CoinbaseOpError;
 /** List policies Lists the policies belonging to the developer's CDP Project. Use the `scope` parameter to filter the policies by scope. The response is paginated, and by default, returns 20 policies per page. */
 export declare const listPolicies: API.OperationMethod<ListPoliciesRequest, ListPoliciesResponse, ListPoliciesError, CoinbaseOpContext>;
@@ -4881,7 +6367,7 @@ export type ListTokensForAccountError = CoinbaseOpError;
 /** List token addresses for account Retrieve all ERC-20 token contract addresses that an account has ever received tokens from. Analyzes transaction history to discover token interactions. */
 export declare const listTokensForAccount: API.OperationMethod<ListTokensForAccountRequest, AccountTokenAddressesResponse, ListTokensForAccountError, CoinbaseOpContext>;
 export type ListTransfersError = CoinbaseOpError;
-/** List transfers List transfers for your organization. Use this to view and monitor your transfer activity. **Status Filtering**: Filter by specific status to efficiently manage transfers: * `?status=processing` - Monitor active transfers. * `?status=quoted` - Find transfers awaiting execution. * `?status=failed` - Review failed transfers for troubleshooting. * `?status=completed` - Find completed transfers. **Account Filtering**: Filter by account ID to find transfers involving a specific account: * `?accountId=<ID>` - All transfers where the account is either source or target (OR semantics). * `?sourceAccountId=<ID>` - Only transfers where the account is the source (outbound). * `?targetAccountId=<ID>` - Only transfers where the account is the target (inbound). Providing `accountId` together with `sourceAccountId` or `targetAccountId` is a validation error and returns HTTP 400. **Date Range Filtering**: Filter by creation or last-updated time for reconciliation: * `?createdAfter=2026-01-01T00:00:00Z&createdBefore=2026-01-31T23:59:59Z` - Transfers created within a date range. * `?updatedAfter=2026-01-01T00:00:00Z` - Transfers updated since a given time. Useful for incremental sync. **Asset Filtering**: Filter by source or target asset symbol: * `?sourceAsset=usd` - Transfers funded from a USD account. * `?targetAsset=usdc` - Transfers delivering USDC to the target. **Other Filters**: * `?sourceAddress=0x...` - Transfers from a specific on-chain source address. * `?targetAddress=0x...` - Transfers to a specific on-chain destination address. * `?targetEmail=user@example.com` - Transfers to a specific email recipient. * `?transferId=transfer_...` - Look up a single transfer by ID; bypasses pagination. */
+/** List transfers List transfers for your organization. Use this to view and monitor your transfer activity. **Status Filtering**: Filter by specific status to efficiently manage transfers: * `?status=processing` - Monitor active transfers. * `?status=quoted` - Find transfers awaiting execution. * `?status=failed` - Review failed transfers for troubleshooting. * `?status=completed` - Find completed transfers. **Account Filtering**: Filter by account ID to find transfers involving a specific account: * `?accountId=<ID>` - All transfers where the account is either source or target (OR semantics). * `?sourceAccountId=<ID>` - Only transfers where the account is the source (outbound). * `?targetAccountId=<ID>` - Only transfers where the account is the target (inbound). Providing `accountId` together with `sourceAccountId` or `targetAccountId` is a validation error and returns HTTP 400. **Date Range Filtering**: Filter by creation or last-updated time for reconciliation: * `?createdAfter=2026-01-01T00:00:00Z&createdBefore=2026-01-31T23:59:59Z` - Transfers created within a date range. * `?updatedAfter=2026-01-01T00:00:00Z` - Transfers updated since a given time. Useful for incremental sync. **Asset Filtering**: Filter by source or target asset symbol: * `?sourceAsset=usd` - Transfers funded from a USD account. * `?targetAsset=usdc` - Transfers delivering USDC to the target. Supported asset symbols include `usdc`, `eurc`, `usd`, and `eur`. **Other Filters**: * `?sourceAddress=0x...` - Transfers from a specific on-chain source address. * `?targetAddress=0x...` - Transfers to a specific on-chain destination address. * `?targetEmail=user@example.com` - Transfers to a specific email recipient. * `?transferId=transfer_...` - Look up a single transfer by ID; bypasses pagination. */
 export declare const listTransfers: API.OperationMethod<ListTransfersRequest, ListTransfersResponse, ListTransfersError, CoinbaseOpContext>;
 export type ListWebhookSubscriptionEventsError = CoinbaseOpError;
 /** List webhook subscription events Retrieve webhook event delivery attempts for a specific subscription. Returns event deliveries in descending order by creation time (newest first), including delivery status, retry count, and response details. ### Use Cases - Debug webhook delivery failures and inspect response codes - Monitor delivery status and retry counts - Audit event delivery history for a subscription - Verify that expected events were sent to webhook URLs ### Filtering Use optional query parameters to narrow results: - `eventId` — find a specific event by ID - `minCreatedAt` / `maxCreatedAt` — filter by time range - `eventTypeNames` — filter by event type (comma-separated) **Note:** Results are limited to the 50 most recent events (newest first). No pagination is supported. */
@@ -4889,6 +6375,9 @@ export declare const listWebhookSubscriptionEvents: API.OperationMethod<ListWebh
 export type ListWebhookSubscriptionsError = CoinbaseOpError;
 /** List webhook subscriptions Retrieve a paginated list of webhook subscriptions for the authenticated project. Returns subscriptions for all CDP product events (onchain, onramp/offramp, wallet, etc.) in descending order by creation time. ### Use Cases - Monitor all active webhook subscriptions across CDP products - Audit webhook configurations - Manage subscription lifecycle */
 export declare const listWebhookSubscriptions: API.OperationMethod<ListWebhookSubscriptionsRequest, ListWebhookSubscriptionsResponse, ListWebhookSubscriptionsError, CoinbaseOpContext>;
+export type ListX402BundlesError = CoinbaseOpError;
+/** List x402 bundles Lists the available curated x402 workflow bundles. A bundle is an ordered, named grouping of curated x402 resources that together cover a common agent workflow. The result set is small and server-controlled, so this endpoint is not paginated. */
+export declare const listX402Bundles: API.OperationMethod<ListX402BundlesRequest, X402BundlesResponse, ListX402BundlesError, CoinbaseOpContext>;
 export type ListX402DiscoveryMerchantError = CoinbaseOpError;
 /** List merchant discovery info Gets x402 merchant discovery information for a given merchant payment address. This endpoint returns all active x402 resources associated with the specified `payTo` address, allowing clients to discover what payment-gated resources a merchant exposes and their corresponding payment requirements. If no active resources are found for the `payTo` address, the endpoint returns an empty `resources` list. The response is paginated, and by default, returns 20 items per page. */
 export declare const listX402DiscoveryMerchant: API.OperationMethod<ListX402DiscoveryMerchantRequest, X402DiscoveryMerchantResponse, ListX402DiscoveryMerchantError, CoinbaseOpContext>;
@@ -4898,21 +6387,21 @@ export declare const listX402DiscoveryResources: API.OperationMethod<ListX402Dis
 export type LookupEndUserError = CoinbaseOpError;
 /** Look up end users by identity Looks up end users. Exactly one lookup type must be provided per request: - **email**: searches across all email-based authentication methods (email, Google, Apple, GitHub). May return multiple end users if the same email address appears across different auth methods. - **oauthProvider + oauthSubject**: looks up a user by their OAuth provider and subject (the `sub` claim from the provider's ID token). Both params must be provided together. - **phoneNumber**: looks up a user by their SMS-verified phone number. - **siweAddress**: looks up a user by the Ethereum address they authenticated with via Sign In With Ethereum (EIP-4361). Returns all matching end users. If no end users match, an empty array is returned. This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key. */
 export declare const lookupEndUser: API.OperationMethod<LookupEndUserRequest, LookupEndUserResponse, LookupEndUserError, CoinbaseOpContext>;
-export type PostX402DiscoveryMcpError = CoinbaseOpError;
-/** Handle MCP JSON-RPC request Handles JSON-RPC requests for the Model Context Protocol (MCP). Supports MCP methods for discovering x402 payment resources and tools. */
-export declare const postX402DiscoveryMcp: API.OperationMethod<PostX402DiscoveryMcpRequest, X402McpResponse, PostX402DiscoveryMcpError, CoinbaseOpContext>;
 export type PrepareAndSendUserOperationError = CoinbaseOpError;
 /** Prepare and send user operation Prepares, signs, and sends a user operation for an EVM Smart Account. This API can be used only if the owner on Smart Account is a CDP EVM Account. */
 export declare const prepareAndSendUserOperation: API.OperationMethod<PrepareAndSendUserOperationRequest, EvmUserOperation, PrepareAndSendUserOperationError, CoinbaseOpContext>;
 export type PrepareUserOperationError = CoinbaseOpError;
 /** Prepare user operation Prepares a new user operation on a Smart Account for a specific network. */
 export declare const prepareUserOperation: API.OperationMethod<PrepareUserOperationRequest, EvmUserOperation, PrepareUserOperationError, CoinbaseOpContext>;
+export type RefundPaymentSessionError = CoinbaseOpError;
+/** Refund a payment session Returns captured funds to the payer. The session must have a positive `refundable` balance and the `refundExpiresAt` deadline must not have passed. This is an asynchronous operation. The refund is returned in `pending` status and transitions to `succeeded` or `failed`. If `amount` is omitted, the full remaining refundable amount is refunded. Multiple partial refunds are supported. */
+export declare const refundPaymentSession: API.OperationMethod<RefundPaymentSessionRequest, Refund, RefundPaymentSessionError, CoinbaseOpContext>;
 export type RequestEvmFaucetError = CoinbaseOpError;
 /** Request funds on EVM test networks Request funds from the CDP Faucet on supported EVM test networks. Faucets are available for ETH, USDC, EURC, and cbBTC on Base Sepolia and Ethereum Sepolia, and for ETH only on Ethereum Hoodi. To prevent abuse, we enforce rate limits within a rolling 24-hour window to control the amount of funds that can be requested. These limits are applied at both the CDP User level and the blockchain address level. A single blockchain address cannot exceed the specified limits, even if multiple users submit requests to the same address. */
 export declare const requestEvmFaucet: API.OperationMethod<RequestEvmFaucetRequest, RequestEvmFaucetResponse, RequestEvmFaucetError, CoinbaseOpContext>;
 export type RequestLimitsUpgradeError = CoinbaseOpError;
-/** Request limit upgrade Requests a limit upgrade for an onramp user by submitting identity information. Only phone number is currently supported as a userId. The verification process is asynchronous. After calling this endpoint, use the [Get Onramp User Limits](https://docs.cdp.coinbase.com/api-reference/v2/rest-api/onramp/get-onramp-user-limits) endpoint to check the status in the `limitUpgradeOptions` array. **Prerequisites:** - The phone number must have been previously verified by your app via OTP. - Upgrades may not be available until a certain number of successful transactions by the user. **Supported fields:** - `ssnLast4`: Last 4 digits of the Social Security Number (no dashes or spaces). - `dateOfBirth`: Date of birth (day, month, year as zero-padded strings). */
-export declare const requestLimitsUpgrade: API.OperationMethod<RequestLimitsUpgradeRequest, RequestLimitsUpgradeResponse, RequestLimitsUpgradeError, CoinbaseOpContext>;
+/** Request limit upgrade Requests a limit upgrade for an onramp user. Only phone number is currently supported as a userId. The default API mode submits identity information directly and returns HTTP 202 when the request is accepted. Embedded mode (`interactionMode: embedded`) returns a Coinbase-hosted `upgradeUrl` where the user enters identity information. The verification process is asynchronous. After calling this endpoint, use the [Get Onramp User Limits](https://docs.cdp.coinbase.com/api-reference/v2/rest-api/onramp/get-onramp-user-limits) endpoint to check the status in the `limitUpgradeOptions` array. **Prerequisites:** - The phone number must have been previously verified by your app via OTP. - Upgrades may not be available until a certain number of successful transactions by the user. **Supported fields:** - `ssnLast4`: Last 4 digits of the Social Security Number (no dashes or spaces). - `dateOfBirth`: Date of birth (day, month, year as zero-padded strings). */
+export declare const requestLimitsUpgrade: API.OperationMethod<RequestLimitsUpgradeRequest, OnrampLimitUpgradeEmbeddedResponse, RequestLimitsUpgradeError, CoinbaseOpContext>;
 export type RequestSolanaFaucetError = CoinbaseOpError;
 /** Request funds on Solana devnet Request funds from the CDP Faucet on Solana devnet. Faucets are available for SOL, USDC, and CBTUSD. To prevent abuse, we enforce rate limits within a rolling 24-hour window to control the amount of funds that can be requested. These limits are applied at both the CDP Project level and the blockchain address level. A single blockchain address cannot exceed the specified limits, even if multiple users submit requests to the same address. */
 export declare const requestSolanaFaucet: API.OperationMethod<RequestSolanaFaucetRequest, RequestSolanaFaucetResponse, RequestSolanaFaucetError, CoinbaseOpContext>;
@@ -4991,6 +6480,9 @@ export declare const signSolanaTransaction: API.OperationMethod<SignSolanaTransa
 export type SignSolanaTransactionWithEndUserAccountError = CoinbaseOpError;
 /** Sign transaction via end user Solana account Signs a transaction with the given end user Solana account. The unsigned transaction should be serialized into a byte array and then encoded as base64. **Transaction types** The following transaction types are supported: * [Legacy transactions](https://solana-labs.github.io/solana-web3.js/classes/Transaction.html) * [Versioned transactions](https://solana-labs.github.io/solana-web3.js/classes/VersionedTransaction.html) The developer is responsible for ensuring that the unsigned transaction is valid, as the API will not validate the transaction. */
 export declare const signSolanaTransactionWithEndUserAccount: API.OperationMethod<SignSolanaTransactionWithEndUserAccountRequest, SignSolanaTransactionWithEndUserAccountResponse, SignSolanaTransactionWithEndUserAccountError, CoinbaseOpContext>;
+export type SignSolanaX402PaymentWithEndUserAccountError = CoinbaseOpError;
+/** Sign x402 payment via end user Solana account Signs an x402 payment payload using the end user's given Solana account. Accepts the full x402 payment required response body from a resource server plus an index into the accepts array selecting which payment option to sign. The paymentRequired envelope's x402Version, resource, and extensions are carried through into the signed payment payload; only the selected accept entry becomes paymentPayload.accepted. Returns a signed payment payload that can be base64-encoded and sent in the PAYMENT-SIGNATURE header of the resource request. If acceptsIndex is out of range for paymentRequired.accepts, or the selected accept is not a Solana network payment option, the request fails with 422. */
+export declare const signSolanaX402PaymentWithEndUserAccount: API.OperationMethod<SignSolanaX402PaymentWithEndUserAccountRequest, SignSolanaX402PaymentWithEndUserAccountResponse, SignSolanaX402PaymentWithEndUserAccountError, CoinbaseOpContext>;
 export type SubmitDepositTravelRuleError = CoinbaseOpError;
 /** Submit deposit travel rule information Submit travel rule information for a deposit transfer held pending compliance review. Required fields vary by jurisdiction and may include originator name, address, date of birth, personal ID, and VASP information. If the submitted information satisfies all jurisdictional requirements, `status` will be `completed` and the transfer will proceed. Otherwise, `status` will be `incomplete` and `missingFields` will indicate which fields still need to be provided. */
 export declare const submitDepositTravelRule: API.OperationMethod<SubmitDepositTravelRuleRequest, DepositTravelRuleResponse, SubmitDepositTravelRuleError, CoinbaseOpContext>;
@@ -5000,6 +6492,9 @@ export declare const submitOnrampVerification: API.OperationMethod<SubmitOnrampV
 export type SupportedX402PaymentKindsError = CoinbaseOpError;
 /** Get supported payment schemes and networks Get the supported x402 protocol payment schemes and networks that the facilitator is able to verify and settle payments for. */
 export declare const supportedX402PaymentKinds: API.OperationMethod<SupportedX402PaymentKindsRequest, SupportedX402PaymentKindsResponse, SupportedX402PaymentKindsError, CoinbaseOpContext>;
+export type UpdateCustomerByIdError = CoinbaseOpError;
+/** Update a customer Update customer information and/or request capability changes. This endpoint supports partial updates. Provide only the fields you wish to change. */
+export declare const updateCustomerById: API.OperationMethod<UpdateCustomerByIdRequest, Customer, UpdateCustomerByIdError, CoinbaseOpContext>;
 export type UpdateEvmAccountError = CoinbaseOpError;
 /** Update EVM account Updates an existing EVM account. Use this to update the account's name or account-level policy. */
 export declare const updateEvmAccount: API.OperationMethod<UpdateEvmAccountRequest, EvmAccount, UpdateEvmAccountError, CoinbaseOpContext>;
@@ -5024,4 +6519,7 @@ export declare const validateX402Resource: API.OperationMethod<ValidateX402Resou
 export type VerifyX402PaymentError = CoinbaseOpError;
 /** Verify payment Verify an x402 protocol payment with a specific scheme and network. */
 export declare const verifyX402Payment: API.OperationMethod<VerifyX402PaymentRequest, VerifyX402PaymentResponse, VerifyX402PaymentError, CoinbaseOpContext>;
+export type VoidPaymentSessionError = CoinbaseOpError;
+/** Void a payment session Releases all remaining capturable funds back to the payer. The session must have a positive `capturable` balance. This is an asynchronous operation. The void is returned in `pending` status and transitions to `succeeded` or `failed`. After voiding, no further captures can be made. Unlike **Cancel**, which works before authorization, void works after authorization. */
+export declare const voidPaymentSession: API.OperationMethod<VoidPaymentSessionRequest, Void, VoidPaymentSessionError, CoinbaseOpContext>;
 //# sourceMappingURL=cdp.d.ts.map