@unifold/core 0.1.74 → 0.1.76

package/dist/index.d.mts

@@ -454,35 +454,37 @@ interface OnrampSessionResponse {
  */
 declare function createOnrampSession(request: OnrampSessionRequest, publishableKey?: string): Promise<OnrampSessionResponse>;
 /**
- * A bank-transfer onramp provider returned by `getBankTransferProviders()`.
- * Mirrors the shape of `IntegrationExchangeInfo` so SDK consumers can render
- * exchanges + bank-transfer with the same UI primitives.
+ * One bank-transfer rail from `getBankTransferProviders()`. **A row is a rail,
+ * not a provider**, so two rows can share a `service_provider` — the response is
+ * the currency selector's option list, ordered usable-first, so `data[0]` is the
+ * right default. `unifold` never names the provider behind a rail; what to do
+ * next comes off the session.
  */
 interface BankTransferProvider {
+    /** Not unique within a response — see the note above. */
     service_provider: string;
     service_provider_display_name: string;
     description: string;
     icon_url: string;
     icon_urls: IconUrl[];
     /**
-     * True when the provider is configured AND the rail supports the caller's
-     * country. Use this to decide whether the row is clickable.
+     * Whether this rail serves the caller's country. Unusable rails are still
+     * returned so a selector can grey them out rather than making "EUR only" look
+     * like "no bank transfer".
      */
     enabled: boolean;
     /**
-     * Payment methods this provider supports. Forward one of these as
-     * `payment_method` when calling `/onramps/sessions`. Stored as an array so
-     * a single provider can light up multiple rails (e.g. SEPA + ACH) without
-     * forking the row.
+     * Always one element, like `supported_currencies` — a row is one rail. Read
+     * `[0]` and forward as `payment_method_type`. Corridor-level, never
+     * network-level: one account accepts ACH / wire / RTP at once and the payer's
+     * bank picks, so the networks arrive on the deposit instructions.
      */
-    payment_methods: OnrampSessionPaymentMethodType[];
-    /** All fiat currencies the rail accepts (e.g. ['eur', 'gbp']). */
+    payment_method_types: OnrampSessionPaymentMethodType[];
+    /** Always one element — read `[0]` and forward as `source_currency`. */
     supported_currencies: string[];
-    /**
-     * Preferred fiat for the caller's country, picked from `supported_currencies`.
-     * Forward as `source_currency` to `/onramps/sessions` — avoids the SDK
-     * re-implementing the country → fiat mapping.
-     */
+    /** @deprecated Read `payment_method_types`. Identical contents. */
+    payment_methods: OnrampSessionPaymentMethodType[];
+    /** @deprecated Read `supported_currencies[0]`. */
     source_currency: string;
 }
 interface BankTransferProvidersResponse {
@@ -587,6 +589,12 @@ interface DefaultTokenResponse {
 declare function getDefaultOnrampToken(params: {
     country_code?: string;
     subdivision_code?: string;
+    /**
+     * Service provider the default token will be used with (e.g. binancepay).
+     * Reserved for provider-aware defaults — accepted but not used in
+     * resolution yet.
+     */
+    service_provider?: string;
     token_address: string;
     chain_id: string;
     chain_type: string;
@@ -805,7 +813,7 @@ interface AddressBalancesResponse {
  */
 declare function getAddressBalances(address: string, chainType: ChainType, publishableKey?: string): Promise<AddressBalancesResponse>;
 /** Wallet ids supported by the connect-wallet flow. */
-type WalletMobileDeepLinkWallet = 'phantom' | 'metamask' | 'coinbase' | 'trust' | 'rainbow' | 'rabby' | 'okx' | 'solflare' | 'backpack';
+type WalletMobileDeepLinkWallet = 'phantom' | 'metamask' | 'coinbase' | 'trust' | 'rainbow' | 'rabby' | 'okx' | 'robinhood' | 'solflare' | 'backpack';
 /** Chain types an external wallet can connect on. */
 type ExternalWalletChainType = 'ethereum' | 'solana';
 /** A supported external (self-custody) wallet from the directory endpoint. */
@@ -827,6 +835,19 @@ interface ExternalWalletInfo {
      * client to only offer mobile-browse on those platforms.
      */
     mobile_browse_platforms: ('ios' | 'android')[] | null;
+    /**
+     * Whether the wallet ships a browser extension, so a desktop page can get an
+     * injected provider from it. `false` for mobile-only wallets: a desktop row
+     * could only ever offer an app download, never a connection, so clients should
+     * omit them on desktop unless the provider is already injected.
+     *
+     * Describes the wallet, not what Unifold supports, so it does not change as
+     * connectors are added — a wallet reachable only through a protocol the SDK has
+     * to implement (e.g. WalletConnect) keeps this `false` and advertises that
+     * through a separate additive field, so an SDK that can't speak the protocol
+     * keeps hiding it.
+     */
+    supports_desktop_extension: boolean;
 }
 interface ExternalWalletsResponse {
     data: ExternalWalletInfo[];
@@ -871,7 +892,7 @@ interface WalletMobileDeepLinkResponse {
  * on the merchant's site. `deeplink` is `null` for wallets without a reliable
  * dapp-browser deep link.
  *
- * @param wallet - Wallet id (phantom, metamask, coinbase, trust, rainbow, rabby, okx)
+ * @param wallet - Wallet id (phantom, metamask, coinbase, trust, rainbow, rabby, okx, robinhood)
  * @param depositAddresses - Unifold deposit addresses (one per source chain) to embed in the hosted pay URL
  * @param publishableKey - Optional publishable key, defaults to configured key
  * @param amountUsd - Optional USD amount to pre-fill on the hosted pay page so the user
@@ -953,6 +974,15 @@ interface ExchangeProviderInfo {
     enabled: boolean;
     supported_networks: string[];
     supported_currencies: string[];
+    /**
+     * The exchange's own minimum order in USD, or null when it sets none.
+     *
+     * Not a deposit minimum: `/supported_deposit_tokens` carries that per chain,
+     * and the two are independent, so an amount screen gates on whichever is
+     * higher. Undefined against API deployments that predate the field, which
+     * reads the same as "no floor of its own".
+     */
+    minimum_amount_usd?: number | null;
 }
 interface ExchangeProvidersResponse {
     data: ExchangeProviderInfo[];
@@ -982,6 +1012,17 @@ interface CreateExchangeSessionRequest {
     source_currency?: string;
     source_amount?: string;
     external_id?: string;
+    /**
+     * ISO 3166-1 alpha-2 country code of the user. Recorded on the session, and
+     * required by some redirect providers (e.g. Binance Pay via Meld).
+     */
+    country_code?: string;
+    /**
+     * State/subdivision code (e.g. CA). Recorded on the session, and worth sending
+     * whenever it is known: no exchange provider reports a subdivision back, so
+     * this is the only way the session can carry one.
+     */
+    subdivision_code?: string;
 }
 interface CreateExchangeSessionResponse {
     url: string;
@@ -994,6 +1035,37 @@ interface CreateExchangeSessionResponse {
  * @param publishableKey - Optional publishable key, defaults to configured key
  */
 declare function createExchangeSession(request: CreateExchangeSessionRequest, publishableKey?: string): Promise<CreateExchangeSessionResponse>;
+/**
+ * Where the provider says an onramp session has got to.
+ *
+ * - `pending`    — the provider has no transaction for this session yet (the
+ *                  user hasn't paid, or hasn't finished paying).
+ * - `processing` — payment taken, crypto on its way.
+ * - `completed`  — the provider has sent the crypto.
+ * - `failed`     — the payment or the delivery failed.
+ * - `expired`    — the session timed out before it was paid.
+ * - `unknown`    — we couldn't reach the provider. Not a verdict; retry.
+ */
+type OnrampSessionStatusValue = 'pending' | 'processing' | 'completed' | 'failed' | 'expired' | 'unknown';
+interface OnrampSessionStatusResponse {
+    status: OnrampSessionStatusValue;
+    /** Crypto delivered, once the provider reports it. */
+    destination_amount?: string;
+    /** Fiat charged, once the provider reports it. */
+    source_amount?: string;
+    source_currency?: string;
+    transaction_hash?: string;
+}
+/**
+ * Read an onramp session's status from its provider, by the `external_id` the
+ * session was created with. Polls transfer sessions rendered as a QR or
+ * deeplink (Binance Pay) and device-wallet orders paid on another device.
+ *
+ * This is the only channel that reports a *payment* — the deposit poller sees
+ * crypto arriving on-chain, which is a later and different event, and never
+ * arrives at all if the payment failed.
+ */
+declare function getOnrampSessionStatus(externalId: string, publishableKey?: string, signal?: AbortSignal): Promise<OnrampSessionStatusResponse>;
 interface ExchangeSessionStartParams {
     service_provider: string;
     chain_type: string;
@@ -1003,12 +1075,31 @@ interface ExchangeSessionStartParams {
     source_currency?: string;
     source_amount?: string;
     external_id?: string;
+    /** ISO 3166-1 alpha-2 country code of the user. Recorded on the session. */
+    country_code?: string;
+    /**
+     * State/subdivision code (e.g. CA). Recorded on the session, and the only
+     * source for it — no exchange provider reports a subdivision back.
+     */
+    subdivision_code?: string;
 }
 /**
  * Generate a URL for the exchanges/sessions/start endpoint that redirects to the exchange provider.
  * This avoids popup blockers in Safari by opening the URL directly via anchor tag or window.open().
  */
 declare function getExchangeSessionStartUrl(request: ExchangeSessionStartParams, publishableKey: string): string;
+/**
+ * How a Connect Exchange provider completes the transfer:
+ * - 'oauth': full account connection (holdings/amount/confirm in-app)
+ * - 'redirect': redirect/QR-style payment completed inside the exchange
+ *   (e.g. Binance Pay, or Coinbase in regions without OAuth). Named
+ *   'redirect' — not 'link' — to avoid confusion with Stripe Link.
+ *
+ * The server resolves this per provider per request, so clients should branch
+ * on this field rather than hardcoding provider names. Older API versions omit
+ * the field; treat undefined as 'oauth'.
+ */
+type IntegrationConnectionMethod = 'oauth' | 'redirect';
 interface IntegrationExchangeInfo {
     service_provider: string;
     service_provider_display_name: string;
@@ -1016,17 +1107,57 @@ interface IntegrationExchangeInfo {
     icon_url: string;
     icon_urls: IconUrl[];
     enabled: boolean;
+    connection_method?: IntegrationConnectionMethod;
     supported_networks: string[];
     supported_currencies: string[];
+    /**
+     * The exchange's own minimum order in USD, or null when it sets none.
+     *
+     * Not a deposit minimum: `/supported_deposit_tokens` carries that per chain,
+     * and the two are independent, so an amount screen gates on whichever is
+     * higher. Undefined against API deployments that predate the field, which
+     * reads the same as "no floor of its own".
+     */
+    minimum_amount_usd?: number | null;
 }
 interface IntegrationExchangesResponse {
     data: IntegrationExchangeInfo[];
 }
+interface GetIntegrationExchangesQuery {
+    /**
+     * ISO 3166-1 alpha-2 country code of the user. Lets the server apply
+     * region-based connection method overrides (e.g. Coinbase redirect flow in
+     * regions without OAuth).
+     */
+    country_code?: string;
+    /**
+     * State/subdivision code of the user (e.g. CA). Reserved for state-level
+     * connection-method/enablement control server-side.
+     */
+    subdivision_code?: string;
+}
+/**
+ * Get the exchanges available from the Connect Exchange entrypoint
+ * (Coinbase, Binance, Kraken, etc.).
+ * Returns provider info with icons, enabled status, connection_method
+ * ('oauth' or 'redirect'), and supported networks/currencies.
+ */
+declare function getIntegrationExchanges(publishableKey?: string, query?: GetIntegrationExchangesQuery): Promise<IntegrationExchangesResponse>;
+type CreateIntegrationExchangeSessionRequest = CreateExchangeSessionRequest;
+type CreateIntegrationExchangeSessionResponse = CreateExchangeSessionResponse;
+type IntegrationExchangeSessionStartParams = ExchangeSessionStartParams;
+/**
+ * Create a redirect-based exchange payment session for a Connect Exchange
+ * provider whose connection_method is 'redirect'.
+ * Returns a URL that opens the exchange with the deposit address pre-filled.
+ */
+declare function createIntegrationExchangeSession(request: CreateIntegrationExchangeSessionRequest, publishableKey?: string): Promise<CreateIntegrationExchangeSessionResponse>;
 /**
- * Get available integration OAuth exchanges (Coinbase, Binance, Kraken, etc.)
- * Returns provider info with icons, enabled status, and supported networks/currencies.
+ * Generate a URL for the integrations exchanges/sessions/start endpoint that
+ * redirects (302) to the exchange provider. Opening this URL directly via
+ * anchor tag or window.open() avoids popup blockers in Safari.
  */
-declare function getIntegrationExchanges(publishableKey?: string): Promise<IntegrationExchangesResponse>;
+declare function getIntegrationExchangeSessionStartUrl(request: IntegrationExchangeSessionStartParams, publishableKey: string): string;
 interface StartIntegrationOAuthResult {
     redirect_url: string;
     state: string;
@@ -2103,6 +2234,23 @@ declare function generateKSUID(): string;
  */
 declare function generatePrefixedKSUID(prefix: string): string;
 
+/**
+ * The settlement event names, defined once here because every surface emits
+ * the same ones: the modal ({@link DepositEventType},
+ * {@link WithdrawEventType}) and the headless controllers
+ * (`DepositSessionEventType`, `OnrampSessionEventType`) all alias these
+ * members, so one host-side handler can serve any of them. Aliasing rather
+ * than restating the strings is what keeps that promise from drifting — the
+ * enums stay distinct types, but they cannot disagree on a value.
+ */
+declare enum DirectExecutionEventType {
+    /** A deposit matching the session's addresses was first observed. */
+    DETECTED = "direct_execution.detected",
+    /** An observed execution changed status. */
+    UPDATED = "direct_execution.updated",
+    SUCCEEDED = "direct_execution.succeeded",
+    FAILED = "direct_execution.failed"
+}
 /** Event types emitted by the deposit flow, following `resource.action` convention */
 declare enum DepositEventType {
     ONRAMP_SESSION_CREATED = "onramp_session.created",
@@ -2637,6 +2785,79 @@ declare function mapWalletToDepositAddress(wallet: Wallet): DepositAddress;
  * which custom (headless) UIs need to render an execution timeline.
  */
 declare function mapDirectExecution(execution: DirectExecutionResponse): DirectExecution;
+/**
+ * One provider's quote for a fiat → crypto onramp purchase.
+ *
+ * camelCase SDK projection of the wire {@link OnrampQuote} returned by
+ * `POST /v1/public/onramps/quotes`. Amounts are denominated in
+ * `sourceCurrency` (fees, source) and `destinationCurrency` (destination).
+ */
+interface OnrampProviderQuote {
+    /** Stable provider identifier — pass to `selectQuote()` / session creation. */
+    serviceProvider: string;
+    serviceProviderDisplayName: string;
+    paymentMethodType: OnrampSessionPaymentMethodType;
+    sourceCurrency: string;
+    countryCode: string;
+    sourceAmount: number;
+    sourceAmountWithoutFees: number;
+    totalFee: number;
+    networkFee: number;
+    transactionFee: number;
+    /** Provider-charged partner fee, when disclosed. */
+    partnerFee: number | null;
+    destinationAmount: number;
+    destinationAmountWithoutFees: number | null;
+    destinationCurrency: string;
+    destinationNetwork: string;
+    exchangeRate: number;
+    /** Backend ranking signal (higher is better) used for the default ordering. */
+    customerScore: number;
+    /** True when the provider settles without a document-upload KYC step. */
+    lowKyc: boolean;
+    iconUrl: string;
+    iconUrls: IconUrl[];
+    institutionName: string | null;
+}
+/** Map a wire {@link OnrampQuote} to the SDK-facing {@link OnrampProviderQuote}. */
+declare function mapOnrampQuote(quote: OnrampQuote): OnrampProviderQuote;
+/**
+ * The onramp-side destination for a card purchase: which provider network /
+ * currency the funds are bought on, and the token that lands there before
+ * Unifold converts it to the host's destination.
+ *
+ * camelCase SDK projection of the wire {@link DefaultTokenResponse} returned
+ * by `GET /v1/public/onramps/default_token`.
+ */
+interface OnrampDestinationToken {
+    /** Provider-side network identifier — the `destination_network` for quotes/sessions. */
+    network: string;
+    /** Provider-side currency code — the `destination_currency` for quotes/sessions. */
+    currency: string;
+    /**
+     * Whether the token the host asked to receive is a stablecoin. Quoting by a
+     * fixed `destinationAmount` prices an exact quantity of the provider-side
+     * currency above, so it only matches the requested token when that token is
+     * a stablecoin too — the session refuses destination mode otherwise.
+     */
+    isStablecoin: boolean;
+    token: {
+        symbol: string;
+        name: string;
+        tokenAddress: string;
+        decimals: number;
+        chainId: string;
+        chainType: ChainType;
+        chainName: string;
+        iconUrl: string;
+        iconUrls: IconUrl[];
+        chainIconUrl: string;
+    };
+    /** Estimated provider processing time in seconds, when known. */
+    estimatedProcessingTimeSeconds: number | null;
+}
+/** Map a wire {@link DefaultTokenResponse} to the SDK-facing {@link OnrampDestinationToken}. */
+declare function mapDefaultOnrampToken(response: DefaultTokenResponse): OnrampDestinationToken;
 
 /** How often `/direct_executions/query` is polled (modal: POLL_INTERVAL_MS). */
 declare const DETECTION_POLL_INTERVAL_MS = 2500;
@@ -2672,7 +2893,6 @@ declare enum DepositSessionEventType {
     EXECUTION_DETECTED = "direct_execution.detected",
     /** Any status transition on a tracked execution. */
     EXECUTION_UPDATED = "direct_execution.updated",
-    /** Kept byte-compatible with the modal's DepositEventType member. */
     EXECUTION_SUCCEEDED = "direct_execution.succeeded",
     EXECUTION_FAILED = "direct_execution.failed"
 }
@@ -2958,6 +3178,523 @@ declare class DepositSession {
     private emitExecutionEvent;
 }
 
+/** How often quotes auto-refresh while awaiting checkout (modal: 60s countdown). */
+declare const QUOTE_REFRESH_INTERVAL_MS = 60000;
+/**
+ * Events emitted by {@link OnrampSession}, following the
+ * `resource.action` convention. Two names are intentionally byte-compatible
+ * with existing surfaces so one host-side handler can serve modal `onEvent`
+ * events and headless session events — both are **aliased** from their
+ * defining enum rather than restated, so the two can never drift apart:
+ *
+ * - `onramp_session.created` from the modal's
+ *   {@link DepositEventType.ONRAMP_SESSION_CREATED} (its `data.object` is a
+ *   superset of the modal's `{ externalId }`),
+ * - `direct_execution.*` from the shared {@link DirectExecutionEventType} —
+ *   the onramp settlement is the same direct-execution resource as a manual
+ *   transfer, so `DepositSessionEventType` aliases the same members.
+ */
+declare enum OnrampSessionEventType {
+    SESSION_STARTED = "onramp_session.started",
+    ADDRESSES_CREATED = "onramp_session.addresses_created",
+    /** A fresh set of provider quotes was fetched (initial, refresh, or after updateQuoteRequest). */
+    QUOTES_UPDATED = "onramp_session.quotes_updated",
+    /** Provider checkout created — the modal's `onramp_session.created`. */
+    CHECKOUT_CREATED = "onramp_session.created",
+    SESSION_STOPPED = "onramp_session.stopped",
+    /** Non-fatal (quote refresh / polling outage) and fatal errors; `data.object.fatal` distinguishes. */
+    SESSION_ERRORED = "onramp_session.errored",
+    EXECUTION_DETECTED = "direct_execution.detected",
+    EXECUTION_UPDATED = "direct_execution.updated",
+    EXECUTION_SUCCEEDED = "direct_execution.succeeded",
+    EXECUTION_FAILED = "direct_execution.failed"
+}
+type OnrampSessionErrorCode = 'ADDRESS_CREATION_FAILED' | 'DESTINATION_TOKEN_FAILED' | 'DESTINATION_AMOUNT_UNSUPPORTED' | 'QUOTES_FAILED' | 'POLLING_ERROR' | 'DEPOSIT_FAILED' | 'INVALID_RECIPIENT';
+interface OnrampSessionError {
+    code: OnrampSessionErrorCode;
+    message: string;
+    /** Fatal errors end the run (status 'error'); non-fatal ones don't stop the flow. */
+    fatal: boolean;
+    cause?: unknown;
+}
+interface OnrampSessionEventDataMap {
+    [OnrampSessionEventType.SESSION_STARTED]: {
+        sessionId: string;
+    };
+    [OnrampSessionEventType.ADDRESSES_CREATED]: {
+        sessionId: string;
+        addresses: DepositAddress[];
+    };
+    [OnrampSessionEventType.QUOTES_UPDATED]: {
+        sessionId: string;
+        quotes: OnrampProviderQuote[];
+        selectedQuote: OnrampProviderQuote | null;
+    };
+    [OnrampSessionEventType.CHECKOUT_CREATED]: {
+        /** Kept first-class for byte-compatibility with the modal's `{ externalId }`. */
+        externalId: string;
+        sessionId: string;
+        url: string;
+        serviceProvider: string;
+    };
+    [OnrampSessionEventType.SESSION_STOPPED]: {
+        sessionId: string;
+    };
+    [OnrampSessionEventType.SESSION_ERRORED]: {
+        sessionId: string;
+        code: OnrampSessionErrorCode;
+        message: string;
+        fatal: boolean;
+    };
+    [OnrampSessionEventType.EXECUTION_DETECTED]: DirectExecution;
+    [OnrampSessionEventType.EXECUTION_UPDATED]: DirectExecution & {
+        previousStatus: ExecutionStatus | null;
+    };
+    [OnrampSessionEventType.EXECUTION_SUCCEEDED]: DirectExecution;
+    [OnrampSessionEventType.EXECUTION_FAILED]: DirectExecution;
+}
+/**
+ * Event envelope emitted by the onramp session. Mirrors the
+ * server-side webhook payload shape (top-level `id`, `type`, `created`,
+ * resource under `data.object`), with `sevt_` IDs to distinguish from
+ * backend `evt_` IDs.
+ */
+type OnrampSessionEvent = {
+    [K in OnrampSessionEventType]: {
+        id: string;
+        type: K;
+        created: number;
+        /** Rail hint — 'card' (or 'apple_pay' when paymentMethodType is apple_pay). */
+        method?: DepositMethod;
+        data: {
+            object: OnrampSessionEventDataMap[K];
+        };
+    };
+}[OnrampSessionEventType];
+/** Map from event type to its fully-narrowed envelope. */
+type OnrampSessionEventMap = {
+    [K in OnrampSessionEventType]: Extract<OnrampSessionEvent, {
+        type: K;
+    }>;
+};
+/**
+ * The mutable amount side of the quote request. Everything else about the
+ * flow (destination, user) is session identity and requires a new session.
+ *
+ * Quoting works in one of two AMOUNT MODES — provide exactly one:
+ *
+ * - **Source mode** (`sourceAmount`): "spend 100 USD" — the user pays exactly
+ *   this, fees included; the crypto received is what remains
+ *   (`quote.destinationAmount`).
+ * - **Destination mode** (`destinationAmount`): "receive 100 USDC" — the
+ *   crypto amount is fixed and provider fees are added on top; the fiat the
+ *   user pays is `quote.sourceAmount`. Only providers that can quote by a
+ *   fixed destination amount participate (the backend omits the rest from
+ *   the results, so `quotes` is already filtered).
+ */
+interface OnrampQuoteRequest {
+    /**
+     * ISO 3166-1 alpha-2 country of the payer. OPTIONAL — when omitted, the
+     * session auto-detects it from the caller's IP during start() (public
+     * `/ip_address` endpoint, same signal as the modal), falling back to 'US'
+     * when detection fails (modal parity). Provide it only to override
+     * detection with your own geo signal. The effective value is exposed as
+     * `snapshot.countryCode`.
+     */
+    countryCode?: string;
+    /**
+     * ISO 3166-2 subdivision (e.g. 'US-NY') when relevant for provider
+     * routing. Auto-detected alongside the country when `countryCode` is
+     * omitted; never mixed with an explicit `countryCode` (a detected
+     * subdivision only applies to the detected country).
+     */
+    subdivisionCode?: string;
+    /**
+     * Fiat amount to spend, as a decimal string (e.g. '100' / '99.50'), fees
+     * included. Mutually exclusive with `destinationAmount`.
+     */
+    sourceAmount?: string;
+    /**
+     * Fixed crypto (destination) amount to receive, as a decimal string, with
+     * provider fees added on top. Mutually exclusive with `sourceAmount`.
+     *
+     * Only available when the destination token is a stablecoin
+     * (`snapshot.destinationToken.isStablecoin`): the amount prices an exact
+     * quantity of the provider-side currency, which only matches the requested
+     * token 1:1 for stablecoins. Otherwise quoting stops with a non-fatal
+     * `DESTINATION_AMOUNT_UNSUPPORTED` error (modal parity) until the host
+     * switches back to `sourceAmount`.
+     */
+    destinationAmount?: string;
+    /** ISO 4217 fiat currency code the user pays in. @default 'usd' */
+    sourceCurrency?: string;
+}
+interface OnrampSessionParams {
+    /** Host platform's stable user identifier (maps to external_user_id). */
+    externalUserId: string;
+    /** Destination — what the purchase converts into and where it lands. */
+    destination: DepositSessionDestination;
+    /** Initial fiat quote request; mutable later via {@link OnrampSession.updateQuoteRequest}. */
+    quoteRequest: OnrampQuoteRequest;
+    /**
+     * Payment rail forwarded to the provider session. @default 'card'
+     * (`apple_pay` / `sepa` / `us_bank_account` reuse the same unified flow).
+     */
+    paymentMethodType?: OnrampSessionPaymentMethodType;
+    /** Prefill email forwarded to the provider checkout. */
+    email?: string;
+    /**
+     * Auto-refresh interval for quotes while awaiting checkout.
+     * Set 0 to disable (call refreshQuotes() yourself). @default 60000
+     */
+    quoteRefreshIntervalMs?: number;
+}
+/** Internal construction config — created via `UnifoldClient.createOnrampSession`. */
+interface OnrampSessionConfig extends OnrampSessionParams {
+    publishableKey: string;
+}
+/**
+ * Session status is LIFECYCLE-ONLY (same principle as {@link DepositSession}):
+ * a card purchase can settle as multiple executions, so execution outcomes
+ * never appear here — they live on `snapshot.executions` / `latestExecution`,
+ * the `direct_execution.succeeded`/`.failed` events, and `waitForSuccess()`.
+ */
+type OnrampSessionStatus = 'idle' | 'preparing' | 'quoting' | 'ready' | 'awaiting_payment' | 'processing' | 'error';
+/** A provider-hosted checkout created by {@link OnrampSession.createCheckout}. */
+interface OnrampCheckout {
+    /**
+     * Single-use redirect URL to the provider's hosted checkout. Open it
+     * synchronously from your click handler (`window.open(checkout.url)`) —
+     * building it requires no network round-trip, so popup blockers stay happy.
+     */
+    url: string;
+    /** Correlation id (`orsext_*`) stamped on the provider session. */
+    externalId: string;
+    serviceProvider: string;
+    /** The quote the checkout was created from (price shown to the user). */
+    quote: OnrampProviderQuote;
+    /** Requested fiat spend; null in destination mode (read `quote.sourceAmount` for the fee-inclusive fiat). */
+    sourceAmount: string | null;
+    /** Requested fixed crypto amount; null in source mode. */
+    destinationAmount: string | null;
+    sourceCurrency: string;
+    /** Epoch ms the checkout was created. */
+    createdAt: number;
+}
+interface OnrampSessionSnapshot {
+    status: OnrampSessionStatus;
+    /**
+     * Effective payer country driving quotes: the host-supplied override when
+     * given, otherwise the IP-detected country ('US' when detection failed).
+     * Null until known (before start() finishes preparing, when no override).
+     */
+    countryCode: string | null;
+    /** Deposit addresses backing the purchase (one per chain type); empty until created. */
+    addresses: DepositAddress[];
+    /**
+     * Provider-side network/currency the fiat is converted on; null until
+     * resolved, and briefly again while a payer-country change is re-resolving
+     * it (the routing is geo-dependent).
+     */
+    destinationToken: OnrampDestinationToken | null;
+    /** Latest provider quotes, backend priority order; empty while loading or on failure. */
+    quotes: OnrampProviderQuote[];
+    /** Quote used by createCheckout() — auto-picked (quotes[0]) unless selectQuote() was called. */
+    selectedQuote: OnrampProviderQuote | null;
+    /** False once the host picked a provider via selectQuote() (sticky across refreshes). */
+    isQuoteAutoSelected: boolean;
+    /**
+     * True when there is more than one quote to pick between — gate your
+     * provider-picker UI on this. False when the project's fiat-onramp smart
+     * routing is enabled (the backend collapses the list to a single routed
+     * quote; there is no dedicated response flag) or when only one provider
+     * quotes this request.
+     */
+    canSelectProvider: boolean;
+    /** True while a (re)fetch of quotes is in flight. */
+    isRefreshingQuotes: boolean;
+    /** Epoch ms of the last successful quote fetch — drive your own countdown. */
+    quotesUpdatedAt: number | null;
+    /** The active provider checkout; null until createCheckout(). */
+    checkout: OnrampCheckout | null;
+    /** All executions observed since checkout, newest first. */
+    executions: DirectExecution[];
+    latestExecution: DirectExecution | null;
+    /** True while the backend is actively scanning for the provider's transfer. */
+    isCheckingDeposit: boolean;
+    /** Latest non-fatal (quote refresh / polling outage) or fatal error, if any. */
+    error: OnrampSessionError | null;
+}
+interface OnrampSessionWaitOptions {
+    /**
+     * Abort the wait (reject with code 'ABORTED'). Cancels only the wait — the
+     * session keeps watching, because a card purchase is not cancelable from
+     * the SDK once the user has paid at the provider. For a deadline, compose
+     * `waitForSuccess({ signal: AbortSignal.timeout(60_000) })` and treat it as
+     * "outcome unknown", not "outcome bad".
+     */
+    signal?: AbortSignal;
+}
+type OnrampSessionWaitErrorCode = 'ABORTED' | 'DESTROYED' | 'DEPOSIT_FAILED' | 'SESSION_ERROR';
+/** Rejection type for {@link OnrampSession.waitForStatus} / {@link OnrampSession.waitForSuccess}. */
+declare class OnrampSessionWaitError extends Error {
+    readonly code: OnrampSessionWaitErrorCode;
+    /** Failed execution (`DEPOSIT_FAILED`) or fatal {@link OnrampSessionError} (`SESSION_ERROR`). */
+    readonly cause?: unknown;
+    constructor(code: OnrampSessionWaitErrorCode, message: string, cause?: unknown);
+}
+/**
+ * Headless controller for one attempt by one user to buy crypto with a card
+ * (fiat onramp) into a destination — the no-UI equivalent of the modal's
+ * `beginDeposit({ initialScreen: 'card' })`. Owns:
+ *
+ * 1. creating/fetching the deposit addresses the provider settles into,
+ * 2. resolving the onramp destination token (provider network/currency),
+ * 3. fetching + auto-refreshing provider quotes, with sticky manual selection,
+ * 4. building the provider checkout URL (synchronous — popup-blocker safe),
+ * 5. watching for the provider's on-chain settlement by composing a
+ *    {@link DepositSession} (method 'card') — same detection polling, scan
+ *    nudge, lookback window, and `direct_execution.*` events as a transfer.
+ *
+ * UI state should come from {@link getSnapshot} (or the React hook built on
+ * it); events are for side effects (analytics, toasts, navigation).
+ *
+ * Geo: the payer country drives quoting, so when the host doesn't supply
+ * `countryCode` the session auto-detects it from the caller's IP (public
+ * `/ip_address` endpoint; 'US' fallback — modal parity). An explicit
+ * `countryCode` always overrides and suppresses detection. This deliberately
+ * differs from DepositSession's not-IP-aware stance: there geo is a policy
+ * gate the host opts into; here it is a functional input of the quote.
+ * Fiat min/max validation is host-side against `getFiatCurrencies()` — the
+ * session only requires a parseable amount > 0.
+ */
+declare class OnrampSession {
+    /** Immutable id for correlation, `osess_<ksuid>`. Client-generated. */
+    readonly id: string;
+    private readonly emitter;
+    private readonly listeners;
+    private readonly publishableKey;
+    private readonly externalUserId;
+    private readonly destination;
+    private readonly paymentMethodType;
+    private readonly email?;
+    private readonly quoteRefreshIntervalMs;
+    private readonly method;
+    private explicitCountryCode?;
+    private explicitSubdivisionCode?;
+    private detectedCountryCode;
+    private detectedSubdivisionCode;
+    private sourceAmount?;
+    private destinationAmount?;
+    private sourceCurrency;
+    private runToken;
+    private startPromise;
+    private destroyed;
+    /** Pending waiter rejections, invoked by destroy() so waiters never hang. */
+    private waiterDestroyCallbacks;
+    /** In-flight destination-token + quotes pipeline (see syncQuoteInputs). */
+    private syncPromise;
+    /** A sync was asked for mid-pipeline; the loop owes it another pass. */
+    private syncRequested;
+    /** Code of the non-fatal error already reported, so a streak emits once. */
+    private nonFatalErrorLatch;
+    /** True once run() got past preparing — gates live quote-input syncing. */
+    private prepared;
+    private refreshTimer;
+    /** service_provider chosen via selectQuote(); sticky across quote refreshes. */
+    private manualSelection;
+    /** First execution to succeed this run — waitForSuccess's one-shot answer. */
+    private firstSuccess;
+    private watcher;
+    private watcherOffs;
+    private status;
+    private addresses;
+    private destinationToken;
+    /** Geo `destinationToken` was resolved for; null while unresolved. */
+    private destinationTokenGeoKey;
+    private quotes;
+    private selectedQuote;
+    private isRefreshingQuotes;
+    private quotesUpdatedAt;
+    private checkout;
+    private executions;
+    private checkingDeposit;
+    private error;
+    private snapshot;
+    constructor(config: OnrampSessionConfig);
+    /** Synchronous snapshot; the reference is stable until state changes. */
+    getSnapshot(): OnrampSessionSnapshot;
+    /**
+     * Subscribe to snapshot changes (external-store contract; drives
+     * `useSyncExternalStore` in the React binding). Returns an unsubscribe fn.
+     */
+    subscribe(listener: () => void): () => void;
+    /** Typed event subscription. Returns an unsubscribe function. */
+    on<K extends OnrampSessionEventType>(type: K, handler: (event: OnrampSessionEventMap[K]) => void): () => void;
+    on(type: '*', handler: (event: OnrampSessionEvent) => void): () => void;
+    /**
+     * Creates/fetches addresses, resolves the onramp destination token (both
+     * with fail-fast recipient validation), and fetches the first quotes.
+     * Idempotent while running; callable again after stop() or a fatal error.
+     */
+    start(): Promise<void>;
+    /**
+     * Update the quote request (amount / currency / country) and refetch
+     * quotes. Debounce keystrokes host-side — every call that changes
+     * something hits the quotes API. No-op after createCheckout().
+     *
+     * Amount-mode switching: patching `sourceAmount` while in destination mode
+     * (or `destinationAmount` while in source mode) switches modes — the other
+     * amount is cleared. Patching BOTH to truthy values in one call throws
+     * (exactly one drives quoting).
+     */
+    updateQuoteRequest(patch: Partial<OnrampQuoteRequest>): void;
+    /** Refetch quotes with the current request. Resolves when the fetch settles. */
+    refreshQuotes(): Promise<void>;
+    /**
+     * Pick a provider quote by `serviceProvider`. The selection is sticky
+     * across refreshes: while the provider keeps quoting it stays selected
+     * (with fresh pricing); if it drops out, selection falls back to the
+     * backend's top quote and auto-selection resumes.
+     *
+     * Returns the selected quote, or null when no quote matches.
+     */
+    selectQuote(serviceProvider: string): OnrampProviderQuote | null;
+    /**
+     * Build the provider-hosted checkout and start watching the deposit
+     * addresses for the provider's on-chain settlement.
+     *
+     * Uses `snapshot.selectedQuote` (backend's top quote unless the host called
+     * selectQuote()). Hosts that manage their own selection UI can instead pass
+     * `options.serviceProvider` for a one-shot choice without mutating the
+     * sticky selection.
+     *
+     * Synchronous by design: the URL is assembled locally (single-use token
+     * exchange happens when it is opened), so hosts can `window.open()` the
+     * result inside the click handler without tripping popup blockers.
+     *
+     * Throws when the session is not ready (no matching quote / addresses or
+     * destination token missing) — gate your button on `status === 'ready'`
+     * and `selectedQuote`.
+     */
+    createCheckout(options?: {
+        serviceProvider?: string;
+        email?: string;
+        externalId?: string;
+    }): OnrampCheckout;
+    /**
+     * Stops quote refresh and settlement watching. The session can be
+     * restarted with start(), which resets quotes/checkout/executions
+     * (fresh run).
+     */
+    stop(): void;
+    /** stop() + release all listeners. Terminal — start() rejects afterwards. */
+    destroy(): void;
+    /**
+     * Resolve when the session reaches one of the given statuses (immediately
+     * if it's already there) — e.g. `waitForStatus('ready')` awaits quotes,
+     * `waitForStatus('processing')` awaits detection of the settlement.
+     * Statuses carry no outcomes; await those with {@link waitForSuccess}.
+     *
+     * Rejects with {@link OnrampSessionWaitError} on abort or destroy().
+     * Does not start or stop the session — it only listens.
+     */
+    waitForStatus(status: OnrampSessionStatus | OnrampSessionStatus[], options?: OnrampSessionWaitOptions): Promise<OnrampSessionSnapshot>;
+    /**
+     * Resolve with the **first** succeeded {@link DirectExecution} observed by
+     * this session — same one-shot first-completion contract as
+     * {@link DepositSession.waitForSuccess}. A failure only rejects
+     * (`DEPOSIT_FAILED`) when no other observed execution is still in flight;
+     * fatal session errors reject with `SESSION_ERROR`. The session keeps
+     * watching after success — subscribe to `direct_execution.succeeded` to
+     * react to every settlement.
+     */
+    waitForSuccess(options?: OnrampSessionWaitOptions): Promise<DirectExecution>;
+    /** Shared waiter plumbing — AbortSignal / destroy() rejection with single settlement. */
+    private installWaiter;
+    private run;
+    private failFatally;
+    private createAddressesWithRetry;
+    /** Host-supplied geo wins; otherwise the IP-detected value; 'US' as a last resort. */
+    private effectiveCountryCode;
+    /**
+     * Explicit subdivision wins. A detected subdivision applies only while the
+     * country is also detected — mixing a detected subdivision into an
+     * explicitly-set country would pin quotes to a region of the wrong country.
+     */
+    private effectiveSubdivisionCode;
+    /**
+     * Auto-detect the payer's country from their IP when the host didn't
+     * supply one — so integrators don't need to build geo plumbing to render
+     * a buy screen. Never fatal: detection failure falls back to 'US' (modal
+     * parity — BuyWithCard quotes with `userIpInfo?.alpha2 || 'US'`). The
+     * detection result is cached for the session's lifetime (restarts reuse
+     * it); an explicit countryCode — at construction or via
+     * updateQuoteRequest — always overrides.
+     */
+    private resolveCountry;
+    /** Identity of the geo a destination-token resolution was made for. */
+    private geoKey;
+    /**
+     * Resolve the provider-side network/currency the destination maps to. The
+     * geo it was resolved for travels with the result: routing is
+     * geo-dependent, so the caller has to know when a later country change
+     * invalidates it.
+     */
+    private resolveDestinationToken;
+    /**
+     * Fail-fast recipient validation — parity with DepositSession. Fails open
+     * on network errors (the backend still enforces at execution time), but a
+     * definitive negative result is fatal.
+     */
+    private runStartChecks;
+    /**
+     * Bring the quote inputs and the destination token back in sync, then
+     * fetch quotes. Destination-token routing is geo-dependent (the modal
+     * re-runs its default-token effect whenever `userIpInfo` changes), so a
+     * payer-country change has to re-resolve it first — quoting on the network
+     * and currency routed for the previous geo would also carry into the
+     * checkout built from those quotes.
+     */
+    private syncQuoteInputs;
+    /** Loops until the session state matches the inputs it was built from. */
+    private syncQuoteInputsUntilFresh;
+    /**
+     * Re-resolve the destination token for the current geo. Returns false when
+     * the run ended or the lookup failed.
+     */
+    private resolveDestinationTokenForGeo;
+    /** Returns true when the request inputs moved and quotes must be refetched. */
+    private fetchQuotesOnce;
+    /**
+     * Record a non-fatal error and announce it once per streak — auto-refresh
+     * keeps retrying, and repeating the event every 60s would be noise.
+     */
+    private raiseNonFatal;
+    /** Sticky manual selection: keep the host's provider while it still quotes. */
+    private reconcileSelection;
+    /**
+     * Start (once) the composed {@link DepositSession} that watches the deposit
+     * addresses for the provider's on-chain settlement. Its baseline starts at
+     * checkout time — correct for card rails, where funds can only arrive after
+     * the user pays at the provider. Detection polling, the backend scan nudge
+     * (auto-armed), the lookback window, and `direct_execution.*` semantics are
+     * all inherited rather than reimplemented.
+     */
+    private startWatcher;
+    private syncFromWatcher;
+    private forwardExecutionEvent;
+    private teardownWatcher;
+    private anyExecutionInFlight;
+    private setStatus;
+    private clearRefreshTimer;
+    private buildSnapshot;
+    /** Rebuild the snapshot so getSnapshot() reflects current state. */
+    private commit;
+    private notify;
+    private emitSessionEvent;
+}
+
 interface UnifoldClientOptions {
     /** Publishable key (`pk_test_*` / `pk_live_*`). */
     publishableKey: string;
@@ -3011,6 +3748,8 @@ declare class UnifoldClient {
     constructor(options: UnifoldClientOptions);
     /** Create a headless deposit-session flow controller. */
     createDepositSession(params: DepositSessionParams): DepositSession;
+    /** Create a headless fiat-onramp flow controller (buy with card by default). */
+    createOnrampSession(params: OnrampSessionParams): OnrampSession;
     /**
      * Create (idempotently) and return the user's deposit addresses for a
      * destination — `POST /v1/public/deposit_addresses`.
@@ -3153,4 +3892,4 @@ declare const i18n: {
 };
 type I18nStrings = typeof i18n;
 
-export { type AccountConnectionData, ActionType, type AddressBalanceResponse, type AddressBalancesResponse, type AddressValidationFailureCode, type AddressValidationMetadata, type AddressVerification, type ApplePayLimitUpgradeStatus, type ApplePayProvider, type ApplePayProvidersResponse, type AuthenticateOAuthResult, type AutoSwapRequest, type AutoSwapResponse, type BankTransferConfig, type BankTransferProvider, type BankTransferProvidersResponse, type BlockedCountrySubdivision, type BuildHypercoreTransactionRequest, type BuildHypercoreTransactionResponse, type BuildSolanaTransactionRequest, type BuildSolanaTransactionResponse, type CashAppLimits, type CashAppSessionRequest, type CashAppSessionResponse, type CashAppSessionStatusResponse, type ChainType, type CheckoutEvent, CheckoutEventType, type CheckoutFlowFailedData, type CheckoutFlowStartedData, type CheckoutMethod, type CheckoutMethodSelectedData, type CheckoutPaymentIntent, type CheckoutPaymentIntentData, type CheckoutPaymentIntentSucceededEvent, type CoinbaseApplePayLimit, type CoinbaseApplePayLimitUpgradeOption, type CoinbaseApplePayLimitsResponse, type CoinbaseApplePaySessionResponse, type CoinbaseGooglePaySessionResponse, type CoinbaseLegalAgreement, type CoinbaseLegalAgreementsResponse, type CoinbaseWalletPayLimit, type CoinbaseWalletPayLimitUpgradeOption, type CoinbaseWalletPayLimitsResponse, type CoinbaseWalletPaySessionResponse, type ConfirmIntegrationTransferResult, type CreateCoinbaseApplePaySessionRequest, type CreateCoinbaseGooglePaySessionRequest, type CreateCoinbaseWalletPaySessionRequest, type CreateDepositAddressRequest, type CreateExchangeSessionRequest, type CreateExchangeSessionResponse, type CreateIntegrationTransferParams, type CreateIntegrationTransferResult, type CreateOnrampVerificationSessionRequest, DETECTION_ARM_DELAY_MS, DETECTION_POLL_INTERVAL_MS, type DefaultTokenChain, type DefaultTokenMetadata, type DefaultTokenResponse, type DepositAddress, type DepositAddressParams, type DepositAddressResponse, DepositAddressValidationError, type DepositEvent, DepositEventType, type DepositFlowFailedData, type DepositFlowStartedData, type DepositLimitReachedData, type DepositMethod, type DepositMethodSelectedData, type DepositQuote, type DepositQuoteRequest, DepositSession, type DepositSessionConfig, type DepositSessionDestination, type DepositSessionError, type DepositSessionErrorCode, type DepositSessionEvent, type DepositSessionEventMap, DepositSessionEventType, type DepositSessionParams, type DepositSessionSnapshot, type DepositSessionStatus, DepositSessionWaitError, type DepositSessionWaitErrorCode, type DepositSessionWaitOptions, type DestinationToken, type DestinationTokenChain, type DirectExecution, type DirectExecutionFailedEvent, type DirectExecutionResponse, type DirectExecutionSucceededEvent, type EvmContractCall, type ExchangeProviderInfo, type ExchangeProvidersResponse, type ExchangeSessionStartParams, type ExchangeWalletAddress, ExecutionStatus, type ExternalWalletChainType, type ExternalWalletInfo, type ExternalWalletsResponse, type FeaturedToken, type FeaturedWallet, type FiatCurrenciesResponse, type FiatCurrency, type GetBankTransferProvidersOptions, type GetExchangesQuery, type GooglePayProvider, type GooglePayProvidersResponse, type HypercoreActivationRequest, type HypercoreActivationResponse, type I18nStrings, type IconUrl, IneligibilityReason, type IntegrationAccount, type IntegrationExchangeInfo, type IntegrationExchangesResponse, type IntegrationFeeAmount, type IntegrationHoldingsResponse, IntegrationProvider, IntegrationTransferError, type IntegrationTransferErrorType, type IpAddressResponse, LOOKBACK_MS, type ListExecutionsParams, type LockedQuoteLimits, type LockedQuotePreview, type LockedQuotePreviewRequest, type OnrampQuote, type OnrampQuotesRequest, type OnrampQuotesResponse, type OnrampSessionCreatedData, type OnrampSessionCreatedEvent, type OnrampSessionPaymentMethod, type OnrampSessionPaymentMethodType, type OnrampSessionRequest, type OnrampSessionResponse, type OnrampVerificationFactor, type OnrampVerificationFactorStatus, type OnrampVerificationSession, type OnrampVerificationStatus, type OnrampVerificationTokenResponse, type PaymentIntent, type PaymentIntentDepositAddress, type PaymentIntentExecutionsResponse, type PaymentIntentStatus, type PaymentIntentType, type PaymentNetwork, type PollExecutionsRequest, type PollExecutionsResponse, type ProductType, type ProjectConfigResponse, type ProviderSelectedData, type PublicIncidentResponse, type QueryExecutionsRequest, type QueryExecutionsResponse, type RefreshIntegrationTokenResult, type RequestCoinbaseApplePayLimitUpgradeRequest, type RequestCoinbaseApplePayLimitUpgradeResponse, type RequestCoinbaseWalletPayLimitUpgradeRequest, type RequestCoinbaseWalletPayLimitUpgradeResponse, SCAN_NUDGE_INTERVAL_MS, SOLANA_USDC_ADDRESS, type SendHypercoreTransactionRequest, type SendHypercoreTransactionResponse, type SendSolanaTransactionRequest, type SendSolanaTransactionResponse, type SourceToken, type SourceTokenNetwork, type StartIntegrationOAuthResult, type StripeAccessTokenResponse, StripeApiResponseError, type StripeAuthIntentResponse, type StripeConfigResponse, type StripeConfirmRequest, type StripeConsumerWallet, type StripeCreateSessionRequest, type StripeCryptoCustomer, type StripeCustomerVerification, type StripeDefaultTokenResponse, type StripeListResponse, type StripeOnrampErrorType, type StripeOnrampSession, type StripeOnrampTransactionDetails, type StripePaymentToken, type StripeQuoteRequest, type StripeQuotesResponse, type StripeTransactionLimitEntry, type StripeTransactionLimitsResponse, type SupportedChain, type SupportedDepositTokensParams, type SupportedDepositTokensResponse, type SupportedDestinationTokensResponse, type SupportedSourceTokensQuery, type SupportedSourceTokensResponse, type SupportedToken, type TokenBalance, type TokenChain, type TokenChainIconUrl, type TokenChainsResponse, type TokenDisplayMetadata, type TokenIconUrl, type TokenInfo, type TokenMetadata, type TokenSelectedData, type TransferDefaultTokenParams, type TransferDefaultTokenResult, UnifoldClient, type UnifoldClientOptions, type UserIpInfo, type VerificationData, type VerifyAddressParams, type VerifyAddressRequest, type VerifyAddressResponse, type Wallet, type WalletConnectionData, type WalletMobileDeepLinkDepositAddress, type WalletMobileDeepLinkResponse, type WalletMobileDeepLinkWallet, type WalletPayLimitUpgradeStatus, type WalletPayMethod, type WalletPayProvider, type WalletPayProvidersResponse, type WalletSelectedData, type WithdrawDirectExecutionFailedEvent, type WithdrawDirectExecutionSucceededEvent, type WithdrawEvent, WithdrawEventType, type WithdrawFlowStartedData, authenticateIntegrationOAuth, buildHypercoreTransaction, buildSolanaTransaction, checkHypercoreActivation, confirmIntegrationTransfer, createCashAppSession, createCoinbaseApplePaySession, createCoinbaseGooglePaySession, createCoinbaseWalletPaySession, createDepositAddress, createExchangeSession, createIntegrationTransfer, createOnrampSession, createOnrampVerificationSession, createUnifoldClient, exchangeOnrampVerificationToken, formatStablecoinAmount, generateKSUID, generatePrefixedKSUID, getAddressBalance, getAddressBalances, getApiBaseUrl, getApplePayLimitUpgradeStatus, getApplePayProviders, getBankTransferProviders, getCashAppLimits, getCashAppSessionStatus, getChainName, getCoinbaseApplePayLimits, getCoinbaseLegalAgreements, getCoinbaseWalletPayLimits, getDefaultOnrampToken, getDepositAddress, getDepositQuote, getExchangeSessionStartUrl, getExchanges, getExternalWallets, getFiatCurrencies, getFiatExchangeRates, getGooglePayLimitUpgradeStatus, getGooglePayProviders, getIconUrl, getIconUrlWithCdn, getIntegrationExchanges, getIntegrationHoldings, getIntegrationTransferDefaultToken, getIpAddress, getOnrampQuotes, getOnrampSessionStartUrl, getOnrampVerificationSession, getPreferredIconUrl, getProjectConfig, getPublicIncident, getSupportedDepositTokens, getSupportedDestinationTokens, getTokenChains, getTokenMetadata, getWalletByChainType, getWalletMobileDeepLink, getWalletPayLimitUpgradeStatus, getWalletPayProviders, i18n, isApplePayLimitReached, isDepositAddressValidationError, isGooglePayLimitReached, isWalletPayLimitReached, listPaymentIntentExecutions, mapDirectExecution, mapWalletToDepositAddress, pollDirectExecutions, queryExecutions, refreshIntegrationToken, requestCoinbaseApplePayLimitUpgrade, requestCoinbaseWalletPayLimitUpgrade, retrievePaymentIntent, revokeIntegrationToken, sendHypercoreTransaction, sendOnrampVerificationOtp, sendSolanaTransaction, setApiConfig, startIntegrationOAuth, stripeConfirmSession, stripeCreateAuthIntent, stripeCreateSession, stripeExchangeTokens, stripeGetConfig, stripeGetCustomer, stripeGetDefaultToken, stripeGetQuotes, stripeGetSession, stripeGetTransactionLimits, stripeListPaymentTokens, stripeListWallets, stripeRefreshQuote, stripeRefreshToken, useUserIp, verifyOnrampVerificationOtp, verifyRecipientAddress };
+export { type AccountConnectionData, ActionType, type AddressBalanceResponse, type AddressBalancesResponse, type AddressValidationFailureCode, type AddressValidationMetadata, type AddressVerification, type ApplePayLimitUpgradeStatus, type ApplePayProvider, type ApplePayProvidersResponse, type AuthenticateOAuthResult, type AutoSwapRequest, type AutoSwapResponse, type BankTransferConfig, type BankTransferProvider, type BankTransferProvidersResponse, type BlockedCountrySubdivision, type BuildHypercoreTransactionRequest, type BuildHypercoreTransactionResponse, type BuildSolanaTransactionRequest, type BuildSolanaTransactionResponse, type CashAppLimits, type CashAppSessionRequest, type CashAppSessionResponse, type CashAppSessionStatusResponse, type ChainType, type CheckoutEvent, CheckoutEventType, type CheckoutFlowFailedData, type CheckoutFlowStartedData, type CheckoutMethod, type CheckoutMethodSelectedData, type CheckoutPaymentIntent, type CheckoutPaymentIntentData, type CheckoutPaymentIntentSucceededEvent, type CoinbaseApplePayLimit, type CoinbaseApplePayLimitUpgradeOption, type CoinbaseApplePayLimitsResponse, type CoinbaseApplePaySessionResponse, type CoinbaseGooglePaySessionResponse, type CoinbaseLegalAgreement, type CoinbaseLegalAgreementsResponse, type CoinbaseWalletPayLimit, type CoinbaseWalletPayLimitUpgradeOption, type CoinbaseWalletPayLimitsResponse, type CoinbaseWalletPaySessionResponse, type ConfirmIntegrationTransferResult, type CreateCoinbaseApplePaySessionRequest, type CreateCoinbaseGooglePaySessionRequest, type CreateCoinbaseWalletPaySessionRequest, type CreateDepositAddressRequest, type CreateExchangeSessionRequest, type CreateExchangeSessionResponse, type CreateIntegrationExchangeSessionRequest, type CreateIntegrationExchangeSessionResponse, type CreateIntegrationTransferParams, type CreateIntegrationTransferResult, type CreateOnrampVerificationSessionRequest, DETECTION_ARM_DELAY_MS, DETECTION_POLL_INTERVAL_MS, type DefaultTokenChain, type DefaultTokenMetadata, type DefaultTokenResponse, type DepositAddress, type DepositAddressParams, type DepositAddressResponse, DepositAddressValidationError, type DepositEvent, DepositEventType, type DepositFlowFailedData, type DepositFlowStartedData, type DepositLimitReachedData, type DepositMethod, type DepositMethodSelectedData, type DepositQuote, type DepositQuoteRequest, DepositSession, type DepositSessionConfig, type DepositSessionDestination, type DepositSessionError, type DepositSessionErrorCode, type DepositSessionEvent, type DepositSessionEventMap, DepositSessionEventType, type DepositSessionParams, type DepositSessionSnapshot, type DepositSessionStatus, DepositSessionWaitError, type DepositSessionWaitErrorCode, type DepositSessionWaitOptions, type DestinationToken, type DestinationTokenChain, type DirectExecution, DirectExecutionEventType, type DirectExecutionFailedEvent, type DirectExecutionResponse, type DirectExecutionSucceededEvent, type EvmContractCall, type ExchangeProviderInfo, type ExchangeProvidersResponse, type ExchangeSessionStartParams, type ExchangeWalletAddress, ExecutionStatus, type ExternalWalletChainType, type ExternalWalletInfo, type ExternalWalletsResponse, type FeaturedToken, type FeaturedWallet, type FiatCurrenciesResponse, type FiatCurrency, type GetBankTransferProvidersOptions, type GetExchangesQuery, type GetIntegrationExchangesQuery, type GooglePayProvider, type GooglePayProvidersResponse, type HypercoreActivationRequest, type HypercoreActivationResponse, type I18nStrings, type IconUrl, IneligibilityReason, type IntegrationAccount, type IntegrationConnectionMethod, type IntegrationExchangeInfo, type IntegrationExchangeSessionStartParams, type IntegrationExchangesResponse, type IntegrationFeeAmount, type IntegrationHoldingsResponse, IntegrationProvider, IntegrationTransferError, type IntegrationTransferErrorType, type IpAddressResponse, LOOKBACK_MS, type ListExecutionsParams, type LockedQuoteLimits, type LockedQuotePreview, type LockedQuotePreviewRequest, type OnrampCheckout, type OnrampDestinationToken, type OnrampProviderQuote, type OnrampQuote, type OnrampQuoteRequest, type OnrampQuotesRequest, type OnrampQuotesResponse, OnrampSession, type OnrampSessionConfig, type OnrampSessionCreatedData, type OnrampSessionCreatedEvent, type OnrampSessionError, type OnrampSessionErrorCode, type OnrampSessionEvent, type OnrampSessionEventMap, OnrampSessionEventType, type OnrampSessionParams, type OnrampSessionPaymentMethod, type OnrampSessionPaymentMethodType, type OnrampSessionRequest, type OnrampSessionResponse, type OnrampSessionSnapshot, type OnrampSessionStatus, type OnrampSessionStatusResponse, type OnrampSessionStatusValue, OnrampSessionWaitError, type OnrampSessionWaitErrorCode, type OnrampSessionWaitOptions, type OnrampVerificationFactor, type OnrampVerificationFactorStatus, type OnrampVerificationSession, type OnrampVerificationStatus, type OnrampVerificationTokenResponse, type PaymentIntent, type PaymentIntentDepositAddress, type PaymentIntentExecutionsResponse, type PaymentIntentStatus, type PaymentIntentType, type PaymentNetwork, type PollExecutionsRequest, type PollExecutionsResponse, type ProductType, type ProjectConfigResponse, type ProviderSelectedData, type PublicIncidentResponse, QUOTE_REFRESH_INTERVAL_MS, type QueryExecutionsRequest, type QueryExecutionsResponse, type RefreshIntegrationTokenResult, type RequestCoinbaseApplePayLimitUpgradeRequest, type RequestCoinbaseApplePayLimitUpgradeResponse, type RequestCoinbaseWalletPayLimitUpgradeRequest, type RequestCoinbaseWalletPayLimitUpgradeResponse, SCAN_NUDGE_INTERVAL_MS, SOLANA_USDC_ADDRESS, type SendHypercoreTransactionRequest, type SendHypercoreTransactionResponse, type SendSolanaTransactionRequest, type SendSolanaTransactionResponse, type SourceToken, type SourceTokenNetwork, type StartIntegrationOAuthResult, type StripeAccessTokenResponse, StripeApiResponseError, type StripeAuthIntentResponse, type StripeConfigResponse, type StripeConfirmRequest, type StripeConsumerWallet, type StripeCreateSessionRequest, type StripeCryptoCustomer, type StripeCustomerVerification, type StripeDefaultTokenResponse, type StripeListResponse, type StripeOnrampErrorType, type StripeOnrampSession, type StripeOnrampTransactionDetails, type StripePaymentToken, type StripeQuoteRequest, type StripeQuotesResponse, type StripeTransactionLimitEntry, type StripeTransactionLimitsResponse, type SupportedChain, type SupportedDepositTokensParams, type SupportedDepositTokensResponse, type SupportedDestinationTokensResponse, type SupportedSourceTokensQuery, type SupportedSourceTokensResponse, type SupportedToken, type TokenBalance, type TokenChain, type TokenChainIconUrl, type TokenChainsResponse, type TokenDisplayMetadata, type TokenIconUrl, type TokenInfo, type TokenMetadata, type TokenSelectedData, type TransferDefaultTokenParams, type TransferDefaultTokenResult, UnifoldClient, type UnifoldClientOptions, type UserIpInfo, type VerificationData, type VerifyAddressParams, type VerifyAddressRequest, type VerifyAddressResponse, type Wallet, type WalletConnectionData, type WalletMobileDeepLinkDepositAddress, type WalletMobileDeepLinkResponse, type WalletMobileDeepLinkWallet, type WalletPayLimitUpgradeStatus, type WalletPayMethod, type WalletPayProvider, type WalletPayProvidersResponse, type WalletSelectedData, type WithdrawDirectExecutionFailedEvent, type WithdrawDirectExecutionSucceededEvent, type WithdrawEvent, WithdrawEventType, type WithdrawFlowStartedData, authenticateIntegrationOAuth, buildHypercoreTransaction, buildSolanaTransaction, checkHypercoreActivation, confirmIntegrationTransfer, createCashAppSession, createCoinbaseApplePaySession, createCoinbaseGooglePaySession, createCoinbaseWalletPaySession, createDepositAddress, createExchangeSession, createIntegrationExchangeSession, createIntegrationTransfer, createOnrampSession, createOnrampVerificationSession, createUnifoldClient, exchangeOnrampVerificationToken, formatStablecoinAmount, generateKSUID, generatePrefixedKSUID, getAddressBalance, getAddressBalances, getApiBaseUrl, getApplePayLimitUpgradeStatus, getApplePayProviders, getBankTransferProviders, getCashAppLimits, getCashAppSessionStatus, getChainName, getCoinbaseApplePayLimits, getCoinbaseLegalAgreements, getCoinbaseWalletPayLimits, getDefaultOnrampToken, getDepositAddress, getDepositQuote, getExchangeSessionStartUrl, getExchanges, getExternalWallets, getFiatCurrencies, getFiatExchangeRates, getGooglePayLimitUpgradeStatus, getGooglePayProviders, getIconUrl, getIconUrlWithCdn, getIntegrationExchangeSessionStartUrl, getIntegrationExchanges, getIntegrationHoldings, getIntegrationTransferDefaultToken, getIpAddress, getOnrampQuotes, getOnrampSessionStartUrl, getOnrampSessionStatus, getOnrampVerificationSession, getPreferredIconUrl, getProjectConfig, getPublicIncident, getSupportedDepositTokens, getSupportedDestinationTokens, getTokenChains, getTokenMetadata, getWalletByChainType, getWalletMobileDeepLink, getWalletPayLimitUpgradeStatus, getWalletPayProviders, i18n, isApplePayLimitReached, isDepositAddressValidationError, isGooglePayLimitReached, isWalletPayLimitReached, listPaymentIntentExecutions, mapDefaultOnrampToken, mapDirectExecution, mapOnrampQuote, mapWalletToDepositAddress, pollDirectExecutions, queryExecutions, refreshIntegrationToken, requestCoinbaseApplePayLimitUpgrade, requestCoinbaseWalletPayLimitUpgrade, retrievePaymentIntent, revokeIntegrationToken, sendHypercoreTransaction, sendOnrampVerificationOtp, sendSolanaTransaction, setApiConfig, startIntegrationOAuth, stripeConfirmSession, stripeCreateAuthIntent, stripeCreateSession, stripeExchangeTokens, stripeGetConfig, stripeGetCustomer, stripeGetDefaultToken, stripeGetQuotes, stripeGetSession, stripeGetTransactionLimits, stripeListPaymentTokens, stripeListWallets, stripeRefreshQuote, stripeRefreshToken, useUserIp, verifyOnrampVerificationOtp, verifyRecipientAddress };