import * as react_jsx_runtime from 'react/jsx-runtime';
import { AutoSwapResponse, ChainType, DepositEvent, Wallet, ProductType, FiatCurrency, ExecutionStatus, FeaturedToken, PaymentNetwork, ConfirmIntegrationTransferResult, DestinationToken, DestinationTokenChain, PaymentIntent, DepositQuote, SupportedDestinationTokensResponse, SupportedDepositTokensResponse, VerifyAddressResponse } from '@unifold/core';
export { ChainType } from '@unifold/core';
import * as _tanstack_react_query from '@tanstack/react-query';
import * as class_variance_authority_types from 'class-variance-authority/types';
import * as React$1 from 'react';
import { VariantProps } from 'class-variance-authority';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { ClassValue } from 'clsx';

type DepositConfirmationMode = "auto_ui" | "auto_silent" | "manual";
interface UseDepositPollingOptions {
    userId: string | undefined;
    publishableKey: string;
    /**
     * When provided, polls executions via the payment-intent-scoped endpoint
     * instead of the user-scoped queryExecutions endpoint.
     */
    clientSecret?: string;
    /** Controls when polling starts and whether a waiting UI is shown.
     *  - "auto_ui": After 10s, starts polling and shows "Processing..." card (default)
     *  - "auto_silent": After 10s, starts polling silently (no waiting UI)
     *  - "manual": User must click "I've made the deposit" to start polling
     */
    depositConfirmationMode?: DepositConfirmationMode;
    /** Deposit wallet ID used to trigger the backend poll endpoint */
    depositWalletId?: string;
    enabled?: boolean;
    onDepositSuccess?: (data: {
        message: string;
        transaction?: unknown;
        executionId?: string;
    }) => void;
    onDepositError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    /**
     * When true (with `depositWalletId`), enables `pollDirectExecutions` as soon as `enabled`
     * becomes true — no 10s delay. Use when polling only starts after the on-chain tx is sent
     * (e.g. browser wallet confirming step).
     */
    immediateDirectPolling?: boolean;
}
interface UseDepositPollingResult {
    executions: AutoSwapResponse[];
    isPolling: boolean;
    /** Whether the backend poll endpoint has been enabled */
    pollingEnabled: boolean;
    /** Whether the "Processing deposit transactions" card should be shown */
    showWaitingUi: boolean;
    /** Call this when user clicks "I've made the deposit" (manual mode) */
    handleIveDeposited: () => void;
}
declare function useDepositPolling({ userId, publishableKey, clientSecret, depositConfirmationMode, depositWalletId, enabled, immediateDirectPolling, onDepositSuccess, onDepositError, }: UseDepositPollingOptions): UseDepositPollingResult;

declare global {
    interface Window {
        phantom?: {
            solana?: PhantomSolanaProvider;
            ethereum?: EthereumProvider;
        };
        solana?: PhantomSolanaProvider;
        ethereum?: EthereumProvider;
    }
}
interface PhantomSolanaProvider {
    isPhantom?: boolean;
    isConnected?: boolean;
    publicKey?: {
        toString(): string;
    };
    connect(opts?: {
        onlyIfTrusted?: boolean;
    }): Promise<{
        publicKey: {
            toString(): string;
        };
    }>;
    disconnect(): Promise<void>;
    on(event: string, callback: (...args: unknown[]) => void): void;
    off(event: string, callback: (...args: unknown[]) => void): void;
}
interface EthereumProvider {
    isMetaMask?: boolean;
    isPhantom?: boolean;
    selectedAddress?: string;
    request(args: {
        method: string;
        params?: unknown[];
    }): Promise<unknown>;
    on(event: string, callback: (...args: unknown[]) => void): void;
    off?(event: string, callback: (...args: unknown[]) => void): void;
    removeListener?(event: string, callback: (...args: unknown[]) => void): void;
}

/** Quick amount chips on the browser wallet "Enter amount" step */
type BrowserWalletAmountQuickSelect = "usd" | "percentage";
interface SolanaWalletProvider {
    isPhantom?: boolean;
    isConnected?: boolean;
    publicKey?: {
        toString(): string;
    };
    connect(opts?: {
        onlyIfTrusted?: boolean;
    }): Promise<{
        publicKey: {
            toString(): string;
        };
    }>;
    disconnect(): Promise<void>;
    signTransaction(transaction: any): Promise<any>;
    on(event: string, callback: (...args: unknown[]) => void): void;
    off(event: string, callback: (...args: unknown[]) => void): void;
}
interface EvmWalletProvider {
    isMetaMask?: boolean;
    isPhantom?: boolean;
    isCoinbaseWallet?: boolean;
    selectedAddress?: string;
    request(args: {
        method: string;
        params?: unknown[];
    }): Promise<unknown>;
    on(event: string, callback: (...args: unknown[]) => void): void;
    off?(event: string, callback: (...args: unknown[]) => void): void;
    removeListener?(event: string, callback: (...args: unknown[]) => void): void;
}

type DepositModalInitialScreen = "main" | "transfer" | "card" | "cashapp" | "tracker";
interface DepositModalProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    userId: string;
    publishableKey: string;
    modalTitle?: string;
    /** Main menu — Transfer Crypto row title. @default `"Transfer Crypto"` (from `i18n.depositModal.transferCrypto.title`) */
    transferCryptoTitle?: string;
    /** Main menu — Deposit with Card row title. @default `"Deposit with Card"` */
    depositWithCardTitle?: string;
    /** Main menu — Pay with Exchange row title. @default `"Pay with Exchange"` */
    payWithExchangeTitle?: string;
    /** Main menu — Deposit Tracker row title. @default `"Deposit Tracker"` */
    depositTrackerTitle?: string;
    /** Main menu — Deposit Tracker row description. @default `"Track your deposit progress"` */
    depositTrackerSubTitle?: string;
    destinationTokenSymbol?: string;
    recipientAddress?: string;
    destinationChainType?: ChainType;
    destinationChainId?: string;
    destinationTokenAddress?: string;
    /**
     * Pre-select source token/chain in the Transfer Crypto view.
     * All four props are optional. To match, provide `chainType` + `chainId` + (`symbol` OR `tokenAddress`).
     * If omitted or no match is found in `/supported_deposit_tokens`, the first available token and chain are used.
     */
    defaultSourceChainType?: ChainType;
    /** Source chain ID (e.g. `"mainnet"`, `"137"`). Must be paired with `defaultSourceChainType` + symbol or token address. */
    defaultSourceChainId?: string;
    /** Source token contract address. Must be paired with `defaultSourceChainType` + `defaultSourceChainId`. */
    defaultSourceTokenAddress?: string;
    /** Source token symbol (e.g. `"USDC"`). Must be paired with `defaultSourceChainType` + `defaultSourceChainId`. */
    defaultSourceSymbol?: string;
    hideDepositTracker?: boolean;
    /** Show balance in deposit modal header. Defaults to false */
    showBalanceHeader?: boolean;
    /** Input variant for Transfer Crypto view: "single_input" or "double_input" (default) */
    transferInputVariant?: "single_input" | "double_input";
    /** Controls when deposit polling starts and what UI is shown.
     *  - "auto_ui": After 10s, starts polling and shows "Processing..." card (default)
     *  - "auto_silent": After 10s, starts polling silently (no waiting UI)
     *  - "manual": User must click "I've made the deposit" to start polling
     */
    depositConfirmationMode?: DepositConfirmationMode;
    /** Enable browser wallet connection option. Defaults to false */
    enableConnectWallet?: boolean;
    /**
     * Connect Wallet → Enter amount: percentage chips (10%, 25%, 50%, 75%, MAX) from USD balance, or fixed USD ($25…).
     * @default "percentage"
     */
    browserWalletAmountQuickSelect?: BrowserWalletAmountQuickSelect;
    /** Enable "Pay with Exchange" option. Overrides dashboard default. Defaults to dashboard value or true. */
    enablePayWithExchange?: boolean;
    /** Enable the fiat on-ramp option (shown as "Deposit with Card"). Overrides dashboard default. Defaults to dashboard value or true. */
    enableFiatOnramp?: boolean;
    /** Enable "Connect Exchange" option for direct Coinbase Connect integration. Defaults to false. */
    enableConnectExchange?: boolean;
    /** Enable "Pay with Cash App" option. Defaults to false. */
    enableCashApp?: boolean;
    /** Deposit with Card — onramp step: hide the You use / You buy / You receive card. @default false */
    hideDepositFlowInfo?: boolean;
    /** Deposit with Card — onramp step: hide the temporary wallet address disclaimer. @default false */
    hideDisplayDescription?: boolean;
    onDepositSuccess?: (data: {
        message: string;
        transaction?: unknown;
        executionId?: string;
    }) => void;
    onEvent?: (event: DepositEvent) => void;
    onDepositError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    theme?: "light" | "dark" | "auto";
    /** Hide the dialog overlay and close button for inline/embedded mode */
    hideOverlay?: boolean;
    /** First screen when the modal opens. Default `main` (deposit menu). */
    initialScreen?: DepositModalInitialScreen;
}
declare function DepositModal({ open, onOpenChange, userId, publishableKey, modalTitle, destinationTokenSymbol, recipientAddress, destinationChainType, destinationChainId, destinationTokenAddress, defaultSourceChainType, defaultSourceChainId, defaultSourceTokenAddress, defaultSourceSymbol, hideDepositTracker, showBalanceHeader, transferInputVariant, depositConfirmationMode, enableConnectWallet, browserWalletAmountQuickSelect, enablePayWithExchange, enableFiatOnramp, enableConnectExchange, enableCashApp, hideDepositFlowInfo, hideDisplayDescription, onDepositSuccess, onDepositError, onEvent, theme, hideOverlay, initialScreen, transferCryptoTitle, depositWithCardTitle, payWithExchangeTitle, depositTrackerTitle, depositTrackerSubTitle, }: DepositModalProps): react_jsx_runtime.JSX.Element;

interface DepositHeaderProps {
    title: string;
    subtitle?: string;
    showBack?: boolean;
    showClose?: boolean;
    onBack?: () => void;
    onClose?: () => void;
    badge?: {
        count: number;
    };
    showBalance?: boolean;
    balanceAddress?: string;
    balanceChainType?: "ethereum" | "solana" | "bitcoin" | "algorand" | "xrpl" | "cardano";
    balanceChainId?: string;
    balanceTokenAddress?: string;
    /** Project name for balance label e.g. "{projectName} Balance: $0.00" */
    projectName?: string;
    publishableKey?: string;
}
declare function DepositHeader({ title, subtitle, showBack, showClose, onBack, onClose, badge, showBalance, balanceAddress, balanceChainType, balanceChainId, balanceTokenAddress, projectName, publishableKey, }: DepositHeaderProps): react_jsx_runtime.JSX.Element;

interface TransferCryptoSingleInputProps {
    userId: string;
    publishableKey: string;
    /** When provided, polls executions via the payment-intent-scoped endpoint instead of user-scoped. */
    clientSecret?: string;
    recipientAddress?: string;
    destinationChainType?: ChainType;
    destinationChainId?: string;
    destinationTokenAddress?: string;
    defaultSourceChainType?: ChainType;
    defaultSourceChainId?: string;
    defaultSourceTokenAddress?: string;
    defaultSourceSymbol?: string;
    /** Controls when polling starts and whether a waiting UI is shown.
     *  - "auto_ui": After 10s, starts polling and shows "Processing..." card (default)
     *  - "auto_silent": After 10s, starts polling silently (no waiting UI)
     *  - "manual": User must click "I've made the deposit" to start polling
     */
    depositConfirmationMode?: DepositConfirmationMode;
    onExecutionsChange?: (executions: AutoSwapResponse[]) => void;
    onDepositSuccess?: (data: {
        message: string;
        transaction?: unknown;
        executionId?: string;
    }) => void;
    onDepositError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    wallets?: Wallet[];
    /** Called when the user changes the selected source token/chain. */
    onSourceTokenChange?: (info: {
        symbol: string;
        chainType: string;
        chainId: string;
        tokenAddress: string;
        decimals: number;
        minimumDepositAmountUsd: number;
        isStablecoin: boolean;
    }) => void;
    /** Checkout mode: estimated source amount to send (from /public/quotes). Shown above the QR code. */
    checkoutQuote?: {
        sourceAmount: string;
        sourceTokenDecimals: number;
        sourceTokenSymbol: string;
        sourceAmountUsd: string | null;
        isStablecoin?: boolean;
    } | null;
    /** When true, shows a skeleton for the "You send" row while the quote is loading. */
    isCheckoutQuoteLoading?: boolean;
    /** When true, keep showing "Checking for deposit" even after executions arrive (e.g. checkout sessions that require multiple deposits). */
    persistCheckingIndicator?: boolean;
    /** Product context sent to the API — "deposit" (default) or "payment". */
    productType?: ProductType;
}
declare function TransferCryptoSingleInput({ userId, publishableKey, clientSecret, recipientAddress, destinationChainType, destinationChainId, destinationTokenAddress, defaultSourceChainType, defaultSourceChainId, defaultSourceTokenAddress, defaultSourceSymbol, depositConfirmationMode, onExecutionsChange, onDepositSuccess, onDepositError, wallets: externalWallets, onSourceTokenChange, checkoutQuote, isCheckoutQuoteLoading, persistCheckingIndicator, productType, }: TransferCryptoSingleInputProps): react_jsx_runtime.JSX.Element;

interface TransferCryptoDoubleInputProps {
    userId: string;
    publishableKey: string;
    recipientAddress?: string;
    destinationChainType?: ChainType;
    destinationChainId?: string;
    destinationTokenAddress?: string;
    defaultSourceChainType?: ChainType;
    defaultSourceChainId?: string;
    defaultSourceTokenAddress?: string;
    defaultSourceSymbol?: string;
    /** Controls when polling starts and whether a waiting UI is shown.
     *  - "auto_ui": After 10s, starts polling and shows "Processing..." card (default)
     *  - "auto_silent": After 10s, starts polling silently (no waiting UI)
     *  - "manual": User must click "I've made the deposit" to start polling
     */
    depositConfirmationMode?: DepositConfirmationMode;
    onExecutionsChange?: (executions: AutoSwapResponse[]) => void;
    onDepositSuccess?: (data: {
        message: string;
        transaction?: unknown;
        executionId?: string;
    }) => void;
    onDepositError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    wallets?: Wallet[];
}
declare function TransferCryptoDoubleInput({ userId, publishableKey, recipientAddress, destinationChainType, destinationChainId, destinationTokenAddress, defaultSourceChainType, defaultSourceChainId, defaultSourceTokenAddress, defaultSourceSymbol, depositConfirmationMode, onExecutionsChange, onDepositSuccess, onDepositError, wallets: externalWallets, }: TransferCryptoDoubleInputProps): react_jsx_runtime.JSX.Element;

interface BuyWithCardProps {
    userId: string;
    publishableKey: string;
    view?: "amount" | "quotes" | "onramp";
    onViewChange?: (view: "amount" | "quotes" | "onramp", quotesCount?: number) => void;
    maxAmountUsd?: number;
    accentColor?: string;
    destinationTokenSymbol?: string;
    recipientAddress?: string;
    destinationChainType?: ChainType;
    destinationChainId?: string;
    destinationTokenAddress?: string;
    onDepositSuccess?: (data: {
        message: string;
        transaction?: unknown;
        executionId?: string;
    }) => void;
    onEvent?: (event: DepositEvent) => void;
    onDepositError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    themeClass?: string;
    wallets?: Wallet[];
    assetCdnUrl?: string;
    /** When true, hides the onramp “You use / You buy / You receive” flow card. @default false */
    hideDepositFlowInfo?: boolean;
    /** When true, hides the temporary wallet address disclaimer below the flow. @default false */
    hideDisplayDescription?: boolean;
}
declare function BuyWithCard({ userId, publishableKey, view: externalView, onViewChange, maxAmountUsd, accentColor, // Keep prop for backward compatibility but don't use default
destinationTokenSymbol, recipientAddress, destinationChainType, destinationChainId, destinationTokenAddress, onDepositSuccess, onDepositError, onEvent, themeClass, wallets: externalWallets, assetCdnUrl, hideDepositFlowInfo, hideDisplayDescription, }: BuyWithCardProps): react_jsx_runtime.JSX.Element;

interface CurrencyModalProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    currencies: FiatCurrency[];
    preferredCurrencyCodes: string[];
    selectedCurrency: string;
    onSelectCurrency: (currencyCode: string) => void;
    themeClass?: string;
}
declare function CurrencyModal({ open, onOpenChange, currencies, preferredCurrencyCodes, selectedCurrency, onSelectCurrency, themeClass, }: CurrencyModalProps): react_jsx_runtime.JSX.Element;

interface DepositSuccessToastProps {
    depositTx: string;
    completionTx?: string;
    orderSubmittedAt: string;
    orderFilledAt: string;
    explorerUrl: string;
    completionExplorerUrl?: string;
    status: ExecutionStatus;
    tokenIconUrl?: string;
    sourceAmountUsd?: string;
    onClose: () => void;
    execution?: AutoSwapResponse;
}
declare function DepositSuccessToast({ depositTx, orderSubmittedAt, status, tokenIconUrl, sourceAmountUsd, onClose, execution, }: DepositSuccessToastProps): react_jsx_runtime.JSX.Element;

interface DepositsModalProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    onCloseAll?: () => void;
    executions: AutoSwapResponse[];
    userId: string;
    publishableKey: string;
    themeClass?: string;
}
declare function DepositsModal({ open, onOpenChange, onCloseAll, executions: sessionExecutions, userId, publishableKey, themeClass, }: DepositsModalProps): react_jsx_runtime.JSX.Element;

interface StyledQRCodeProps {
    value: string;
    size?: number;
    imageUrl?: string;
    imageSize?: number;
    darkMode?: boolean;
}
interface QRCodeSkeletonProps {
    size?: number;
    darkMode?: boolean;
}
declare function QRCodeSkeleton({ size, darkMode }: QRCodeSkeletonProps): react_jsx_runtime.JSX.Element;
declare function StyledQRCode({ value, size, imageUrl, imageSize, darkMode, }: StyledQRCodeProps): react_jsx_runtime.JSX.Element;

interface TransferCryptoButtonProps {
    onClick: () => void;
    title: string;
    subtitle: string;
    featuredTokens?: FeaturedToken[];
}
declare function TransferCryptoButton({ onClick, title, subtitle, featuredTokens, }: TransferCryptoButtonProps): react_jsx_runtime.JSX.Element;

interface DepositWithCardButtonProps {
    onClick: () => void;
    title: string;
    subtitle: string;
    paymentNetworks?: PaymentNetwork[];
}
declare function DepositWithCardButton({ onClick, title, subtitle, paymentNetworks, }: DepositWithCardButtonProps): react_jsx_runtime.JSX.Element;

interface ExchangeIconInfo {
    icon_url?: string;
    icon_urls?: Array<{
        url: string;
        format: string;
    }>;
    service_provider_display_name?: string;
}
interface ConnectedExchangeInfo {
    name: string;
    iconUrl?: string;
    balanceUsd: string | null;
    isLoading?: boolean;
}
interface ConnectExchangeButtonProps {
    onClick: () => void;
    onDisconnect?: () => void;
    title: string;
    subtitle: string;
    exchanges?: ExchangeIconInfo[];
    connectedExchange?: ConnectedExchangeInfo | null;
}
declare function ConnectExchangeButton({ onClick, onDisconnect, title, subtitle, exchanges, connectedExchange, }: ConnectExchangeButtonProps): react_jsx_runtime.JSX.Element;

interface DepositTrackerButtonProps {
    onClick: () => void;
    title: string;
    subtitle: string;
    badge?: number;
}
declare function DepositTrackerButton({ onClick, title, subtitle, badge, }: DepositTrackerButtonProps): react_jsx_runtime.JSX.Element;

interface DepositWallet {
    id: string;
    chain_type: string;
    address: string;
}
interface CoinbaseConnectProps {
    publishableKey: string;
    userId: string;
    wallets: DepositWallet[];
    recipientAddress?: string;
    destinationTokenAddress: string;
    destinationChainId: string;
    destinationChainType: string;
    onTransferSuccess?: (result: ConfirmIntegrationTransferResult) => void;
    onTransferError?: (error: {
        message: string;
    }) => void;
    onClose?: () => void;
    onBack?: () => void;
    onDisconnect?: () => void;
    skipToHoldings?: boolean;
    onExecutionsChange?: (executions: AutoSwapResponse[]) => void;
}
declare function CoinbaseConnect({ publishableKey, userId, wallets, recipientAddress, destinationTokenAddress, destinationChainId, destinationChainType, onTransferSuccess, onTransferError, onClose, onBack: parentOnBack, onDisconnect, skipToHoldings, onExecutionsChange, }: CoinbaseConnectProps): react_jsx_runtime.JSX.Element | null;
declare namespace CoinbaseConnect {
    var displayName: string;
}

interface DepositExecutionItemProps {
    execution: AutoSwapResponse;
    onClick?: () => void;
}
declare function DepositExecutionItem({ execution, onClick, }: DepositExecutionItemProps): react_jsx_runtime.JSX.Element;

interface DepositDetailContentProps {
    execution: AutoSwapResponse;
    /** Merged into root (e.g. wider horizontal padding in embedded deposit details). */
    className?: string;
    /** Use "withdraw" to show "Withdrawal Tx" instead of "Deposit Tx" in details. */
    variant?: "deposit" | "withdraw";
}
declare function DepositDetailContent({ execution, className, variant, }: DepositDetailContentProps): react_jsx_runtime.JSX.Element;

interface ManualDepositButtonProps {
    depositConfirmationMode: DepositConfirmationMode;
    showWaitingUi: boolean;
    onIveDeposited: () => void;
}
/**
 * Renders the manual-mode "I've made the deposit" button.
 * Returns null for auto modes or after the user has clicked.
 */
declare function ManualDepositButton({ depositConfirmationMode, showWaitingUi, onIveDeposited, }: ManualDepositButtonProps): react_jsx_runtime.JSX.Element | null;
/**
 * Inline "Checking for deposit" spinner for the footer row.
 */
declare function CheckingForDepositIndicator({ showWaitingUi, hasExecution, }: {
    showWaitingUi: boolean;
    hasExecution: boolean;
}): react_jsx_runtime.JSX.Element | null;

interface ConfirmingViewProps {
    isConfirming: boolean;
    onClose: () => void;
    executions?: AutoSwapResponse[];
    isPolling?: boolean;
    onNewDeposit?: () => void;
    onDone?: () => void;
    paymentIntentStatus?: string;
    /** Live amount_received_usd from the payment intent (updates via polling). */
    amountReceivedUsd?: string;
    /** Snapshot of amount_received_usd taken when the transaction was submitted. */
    amountReceivedUsdAtSubmission?: string | null;
}
declare function ConfirmingView({ isConfirming, onClose, executions, isPolling, onNewDeposit, onDone, paymentIntentStatus, amountReceivedUsd, amountReceivedUsdAtSubmission, }: ConfirmingViewProps): react_jsx_runtime.JSX.Element;

interface CheckoutModalProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    clientSecret: string;
    publishableKey: string;
    modalTitle?: string;
    /** Enable browser wallet connection option. Defaults to false */
    enableConnectWallet?: boolean;
    /**
     * Pre-select source token/chain in the Transfer Crypto view.
     * All four props are optional. To match, provide `chainType` + `chainId` + (`symbol` OR `tokenAddress`).
     * If omitted or no match is found in `/supported_deposit_tokens`, the first available token and chain are used.
     */
    defaultSourceChainType?: ChainType;
    /** Source chain ID (e.g. `"mainnet"`, `"137"`). Must be paired with `defaultSourceChainType` + symbol or token address. */
    defaultSourceChainId?: string;
    /** Source token contract address. Must be paired with `defaultSourceChainType` + `defaultSourceChainId`. */
    defaultSourceTokenAddress?: string;
    /** Source token symbol (e.g. `"USDC"`). Must be paired with `defaultSourceChainType` + `defaultSourceChainId`. */
    defaultSourceSymbol?: string;
    theme?: "light" | "dark" | "auto";
    onCheckoutSuccess?: (data: {
        paymentIntentId: string;
        status: string;
    }) => void;
    onCheckoutError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
}
declare function CheckoutModal({ open, onOpenChange, clientSecret, publishableKey, modalTitle, enableConnectWallet, defaultSourceChainType, defaultSourceChainId, defaultSourceTokenAddress, defaultSourceSymbol, theme, onCheckoutSuccess, onCheckoutError, }: CheckoutModalProps): react_jsx_runtime.JSX.Element;

interface WithdrawTransactionInfo {
    /** Source (sending) chain type */
    sourceChainType: ChainType;
    /** Source (sending) chain ID */
    sourceChainId: string;
    /** Source token contract address — the token being sent */
    sourceTokenAddress: string;
    /** Source token symbol */
    sourceTokenSymbol: string;
    /** Destination (receiving) chain type */
    destinationChainType: string;
    /** Destination (receiving) chain ID */
    destinationChainId: string;
    /** Destination token contract address */
    destinationTokenAddress: string;
    /** Destination token symbol */
    destinationTokenSymbol: string;
    amount: string;
    amountBaseUnit: string;
    /** The Unifold deposit wallet address to send funds to */
    withdrawIntentAddress: string;
    /** The user-provided final destination address */
    recipientAddress: string;
}
interface WithdrawModalProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    publishableKey: string;
    modalTitle?: string;
    externalUserId: string;
    sourceChainType: ChainType;
    sourceChainId: string;
    sourceTokenAddress: string;
    sourceTokenSymbol?: string;
    recipientAddress?: string;
    senderAddress: string;
    /**
     * Pre-select the destination (receive) token/chain in the withdraw view.
     * All four props are optional. To match a specific token, provide `chainType` + `chainId` + (`symbol` OR `tokenAddress`).
     * If omitted or no match is found in `/supported_destination_tokens`, the first available token and chain are used.
     */
    defaultDestinationChainType?: string;
    /** Destination chain ID (e.g. `"mainnet"`, `"137"`). Must be paired with `defaultDestinationChainType` + symbol or token address. */
    defaultDestinationChainId?: string;
    /** Destination token contract address. Must be paired with `defaultDestinationChainType` + `defaultDestinationChainId`. */
    defaultDestinationTokenAddress?: string;
    /** Destination token symbol (e.g. `"USDC"`). Must be paired with `defaultDestinationChainType` + `defaultDestinationChainId`. */
    defaultDestinationSymbol?: string;
    onWithdraw: (txInfo: WithdrawTransactionInfo) => void | Promise<void>;
    onWithdrawSuccess?: (data: {
        message: string;
        transaction?: unknown;
    }) => void;
    onWithdrawError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    theme?: "light" | "dark" | "auto";
    hideOverlay?: boolean;
}
declare function WithdrawModal({ open, onOpenChange, publishableKey, modalTitle, externalUserId, sourceChainType, sourceChainId, sourceTokenAddress, sourceTokenSymbol, recipientAddress: recipientAddressProp, senderAddress, defaultDestinationChainType, defaultDestinationChainId, defaultDestinationTokenAddress, defaultDestinationSymbol, onWithdraw, onWithdrawSuccess, onWithdrawError, theme, hideOverlay, }: WithdrawModalProps): react_jsx_runtime.JSX.Element;

interface WithdrawTokenSelectorProps {
    tokens: DestinationToken[];
    onSelect: (token: DestinationToken, chain: DestinationTokenChain) => void;
    onBack: () => void;
}
declare function WithdrawTokenSelector({ tokens, onSelect, onBack, }: WithdrawTokenSelectorProps): react_jsx_runtime.JSX.Element;

interface WithdrawDoubleInputProps {
    tokens: DestinationToken[];
    selectedTokenSymbol: string | null;
    selectedChainKey: string | null;
    onTokenChange: (symbol: string) => void;
    onChainChange: (chainKey: string) => void;
    isLoading?: boolean;
}
declare function WithdrawDoubleInput({ tokens, selectedTokenSymbol, selectedChainKey, onTokenChange, onChainChange, isLoading, }: WithdrawDoubleInputProps): react_jsx_runtime.JSX.Element;

interface AddressBalanceResult {
    balanceBaseUnit: string;
    balanceHuman: string;
    balanceUsd: string | null;
    exchangeRate: string | null;
    decimals: number;
    symbol: string;
}
/**
 * Hook to fetch a token balance for a given address.
 * Uses React Query for caching and deduplication.
 */
declare function useAddressBalance(params: {
    address?: string;
    chainType?: ChainType;
    chainId?: string;
    tokenAddress?: string;
    publishableKey: string;
    enabled?: boolean;
}): _tanstack_react_query.UseQueryResult<AddressBalanceResult | null, Error>;

interface WithdrawFormProps {
    publishableKey: string;
    externalUserId: string;
    sourceChainType: ChainType;
    selectedToken: DestinationToken | null;
    selectedChain: DestinationTokenChain | null;
    sourceTokenSymbol?: string;
    recipientAddressProp?: string;
    balanceData: AddressBalanceResult | null;
    isLoadingBalance: boolean;
    isStablecoin: boolean;
    minimumWithdrawAmountUsd: number | null;
    estimatedProcessingTime: number | null;
    maxSlippagePercent: number | null;
    priceImpactPercent: number | null;
    senderAddress: string;
    sourceChainId: string;
    sourceTokenAddress: string;
    /** Called when the user confirms the withdrawal. The host app signs and submits the transaction. */
    onWithdraw: (txInfo: WithdrawTransactionInfo) => void | Promise<void>;
    onWithdrawError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    /** Creates the deposit wallet and starts polling. Returns the wallet address + id. */
    onDepositWalletCreation: (params: {
        destinationChainType: string;
        destinationChainId: string;
        destinationTokenAddress: string;
        recipientAddress: string;
    }) => Promise<{
        id: string;
        address: string;
    }>;
    /** Called after a successful withdraw submit — navigates to confirming view */
    onWithdrawSubmitted?: (txInfo: WithdrawTransactionInfo) => void;
    /** Optional element rendered on the left side of the footer row (e.g. tracker link) */
    footerLeft?: React.ReactNode;
}
declare function WithdrawForm({ publishableKey, externalUserId, sourceChainType, selectedToken, selectedChain, sourceTokenSymbol, recipientAddressProp, balanceData, isLoadingBalance, isStablecoin, minimumWithdrawAmountUsd, estimatedProcessingTime, maxSlippagePercent, priceImpactPercent, senderAddress, sourceChainId, sourceTokenAddress, onWithdraw, onWithdrawError, onDepositWalletCreation, onWithdrawSubmitted, footerLeft, }: WithdrawFormProps): react_jsx_runtime.JSX.Element;

interface WithdrawExecutionItemProps {
    execution: AutoSwapResponse;
    onClick?: () => void;
}
declare function WithdrawExecutionItem({ execution, onClick, }: WithdrawExecutionItemProps): react_jsx_runtime.JSX.Element;

interface WithdrawConfirmingViewProps {
    txInfo: WithdrawTransactionInfo;
    executions: AutoSwapResponse[];
    onClose: () => void;
    onViewTracker: () => void;
}
declare function WithdrawConfirmingView({ txInfo, executions, onClose, onViewTracker, }: WithdrawConfirmingViewProps): react_jsx_runtime.JSX.Element;

declare const HYPERCORE_CHAIN_ID = "1337";

type DetectedWallet = {
    name: string;
    address: string;
} & ({
    chainFamily: "evm";
    provider: EvmWalletProvider;
} | {
    chainFamily: "solana";
    provider: SolanaWalletProvider;
});
declare function sendEvmWithdraw(params: {
    provider: EvmWalletProvider;
    fromAddress: string;
    depositWalletAddress: string;
    sourceTokenAddress: string;
    sourceChainId: string;
    amountBaseUnit: string;
}): Promise<string>;
declare function sendSolanaWithdraw(params: {
    provider: SolanaWalletProvider;
    fromAddress: string;
    depositWalletAddress: string;
    sourceTokenAddress: string;
    amountBaseUnit: string;
    publishableKey: string;
}): Promise<string>;

declare function isHypercoreChain(chainId: string): boolean;
declare function sendHypercoreWithdraw(params: {
    provider: EvmWalletProvider;
    fromAddress: string;
    depositWalletAddress: string;
    sourceTokenAddress: string;
    amount: string;
    tokenSymbol: string;
    publishableKey: string;
}): Promise<void>;

declare function detectBrowserWallet(chainType: string, senderAddress?: string): Promise<DetectedWallet | null>;

interface CurrencyListItemProps {
    currency: FiatCurrency;
    isSelected: boolean;
    onSelect: (currencyCode: string) => void;
}
declare function CurrencyListItem({ currency, isSelected, onSelect, }: CurrencyListItemProps): react_jsx_runtime.JSX.Element;

interface CurrencyListSectionProps {
    title: string;
    currencies: FiatCurrency[];
    selectedCurrency: string;
    onSelect: (currencyCode: string) => void;
}
declare function CurrencyListSection({ title, currencies, selectedCurrency, onSelect, }: CurrencyListSectionProps): react_jsx_runtime.JSX.Element | null;

declare const buttonVariants: (props?: ({
    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
}
declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
interface DialogContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
    /** Render inline without portal, overlay, or close button (for embedded/inline mode) */
    hideOverlay?: boolean;
    /**
     * When a `PortalContainerProvider` is set, portal content into it **without** the dimming
     * overlay (same geometry as the default portaled dialog). Use for nested sheets that
     * should fill the host shell (e.g. deposit details over browser-wallet confirming view).
     * Does not combine with `hideOverlay` (embedded DepositModal still uses `hideOverlay` only).
     */
    omitOverlay?: boolean;
    /** Merged into `DialogOverlay` (e.g. z-index above in-app layers such as deposit toasts). */
    overlayClassName?: string;
}
declare const DialogContent: React$1.ForwardRefExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDivElement>>;
declare const DialogHeader: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;

declare const Select: React$1.FC<SelectPrimitive.SelectProps>;
declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const SelectValue: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
declare const SelectTrigger: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const SelectScrollUpButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const SelectScrollDownButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const SelectContent: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
/**
 * Tooltip wrapper that supports both hover (desktop) and tap-to-toggle (mobile).
 *
 * Radix Tooltip only opens on hover, which is unusable on touch devices.
 * This wrapper adds controlled open state so the trigger's onClick can toggle it,
 * while preserving the default hover behavior on desktop.
 */
declare function Tooltip({ children, ...props }: React$1.ComponentPropsWithoutRef<typeof TooltipPrimitive.Root>): react_jsx_runtime.JSX.Element;
/**
 * Tooltip trigger that adds click-to-toggle for mobile/touch support.
 * On desktop, hover still works as usual via Radix's built-in behavior.
 */
declare const TooltipTrigger: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

/**
 * Result of the useAllowedCountry hook
 */
interface AllowedCountryResult {
    /** Whether the user is in an allowed country/subdivision. null while loading. */
    isAllowed: boolean | null;
    /** ISO 3166-1 alpha-2 country code (e.g., "US", "PT") */
    alpha2: string | null;
    /** Full country name (e.g., "United States", "Portugal") */
    country: string | null;
    /** ISO 3166-2 subdivision code (e.g., "NY", "43"), null if unavailable */
    subdivisionCode: string | null;
    /** Whether the hook is still loading data */
    isLoading: boolean;
    /** Error if either API call failed */
    error: Error | null;
}
/**
 * Hook to determine if the current user is in an allowed country
 *
 * Combines the IP geolocation API with the project's blocked countries configuration
 * to determine if the user should be allowed to access geo-restricted features.
 *
 * @param publishableKey - Publishable key for API calls (required)
 * @returns AllowedCountryResult with isAllowed status and location info
 *
 * @example
 * ```tsx
 * function MyComponent({ publishableKey }: { publishableKey: string }) {
 *   const { isAllowed, alpha2, country, isLoading, error } = useAllowedCountry(publishableKey);
 *
 *   if (isLoading) return <LoadingSpinner />;
 *   if (error) return <ErrorMessage error={error} />;
 *   if (!isAllowed) return <GeoBlockedModal country={country} />;
 *
 *   return <YourContent />;
 * }
 * ```
 */
declare function useAllowedCountry(publishableKey: string): AllowedCountryResult;

interface UsePaymentIntentParams {
    clientSecret: string;
    publishableKey: string;
    /** Whether the query should execute. Defaults to true. */
    enabled?: boolean;
    /** Polling interval in ms. Defaults to 5000 (5s). Set to 0 to disable. */
    pollingInterval?: number;
}
/**
 * Hook to retrieve and poll a payment intent via react-query.
 *
 * Fetches the payment intent on mount and polls at the configured interval
 * so `amount_received_usd` and `status` stay up-to-date in the UI. Polling
 * automatically stops once the PI reaches a terminal status. Locked-quote
 * states like `awaiting_refund` / `refunding` / `refund_failed` keep polling
 * because they can still flip.
 */
declare function usePaymentIntent(params: UsePaymentIntentParams): _tanstack_react_query.UseQueryResult<PaymentIntent, Error>;

interface UseDepositQuoteParams {
    publishableKey: string;
    sourceChainType: string;
    sourceChainId: string;
    sourceTokenAddress: string;
    destinationAmount: string;
    destinationChainType: string;
    destinationChainId: string;
    destinationTokenAddress: string;
    /** When true, inflates source amount by expected slippage. Typically set by checkout flows. */
    adjustForSlippage?: boolean;
    /** When true and both tokens are stablecoins, returns a 1:1 quote without swap provider. */
    stablecoinParity?: boolean;
    enabled?: boolean;
}
/**
 * Hook to fetch a deposit quote via react-query.
 *
 * Returns the estimated source token amount needed to receive a specific
 * destination amount, accounting for bridge fees and slippage.
 * Server-side cached for 1 minute; client re-fetches on param change.
 */
declare function useDepositQuote(params: UseDepositQuoteParams): _tanstack_react_query.UseQueryResult<DepositQuote, Error>;

interface UseWithdrawPollingOptions {
    userId: string | undefined;
    publishableKey: string;
    depositWalletId?: string;
    enabled?: boolean;
    onWithdrawSuccess?: (data: {
        message: string;
        transaction?: unknown;
        executionId?: string;
    }) => void;
    onWithdrawError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
}
interface UseWithdrawPollingResult {
    executions: AutoSwapResponse[];
    isPolling: boolean;
}
declare function useWithdrawPolling({ userId, publishableKey, depositWalletId, enabled, onWithdrawSuccess, onWithdrawError, }: UseWithdrawPollingOptions): UseWithdrawPollingResult;

/**
 * Hook to fetch supported destination tokens with caching and deduplication via react-query.
 * Used in the withdraw flow to show available tokens the user can withdraw to.
 *
 * @param publishableKey - Publishable key for API calls
 * @param enabled - Whether to fetch (defaults to true)
 */
declare function useSupportedDestinationTokens(publishableKey: string, enabled?: boolean): _tanstack_react_query.UseQueryResult<SupportedDestinationTokensResponse, Error>;

interface UseSupportedDepositTokensOptions {
    destination_token_address?: string;
    destination_chain_id?: string;
    destination_chain_type?: string;
    product_type?: ProductType;
}
/**
 * Hook to fetch supported deposit tokens with caching and deduplication via react-query.
 *
 * Replaces manual useEffect + useState fetching with automatic caching (5 min stale),
 * request deduplication across components, and built-in loading/error states.
 *
 * @param publishableKey - Publishable key for API calls
 * @param options - Optional destination filters (all three must be provided to filter)
 */
declare function useSupportedDepositTokens(publishableKey: string, options?: UseSupportedDepositTokensOptions): _tanstack_react_query.UseQueryResult<SupportedDepositTokensResponse, Error>;

interface UseVerifyRecipientAddressParams {
    chainType?: string;
    chainId?: string;
    tokenAddress?: string;
    recipientAddress?: string;
    publishableKey: string;
    enabled?: boolean;
}
/**
 * Hook to verify a recipient address via React Query.
 * Debounced by the caller — only fires when all params are present and enabled is true.
 * Caches results by the full (chain + token + address) tuple.
 */
declare function useVerifyRecipientAddress(params: UseVerifyRecipientAddressParams): _tanstack_react_query.UseQueryResult<VerifyAddressResponse, Error>;

interface SourceTokenValidationResult {
    isSupported: boolean;
    isStablecoin: boolean;
    minimumAmountUsd: number | null;
    estimatedProcessingTime: number | null;
    maxSlippagePercent: number | null;
    priceImpactPercent: number | null;
    errorMessage: string | null;
}
/**
 * Hook to validate that a source token is supported for withdrawal
 * by checking it against /supported_deposit_tokens.
 */
declare function useSourceTokenValidation(params: {
    sourceChainType?: string;
    sourceChainId?: string;
    sourceTokenAddress?: string;
    sourceTokenSymbol?: string;
    publishableKey: string;
    enabled?: boolean;
}): _tanstack_react_query.UseQueryResult<SourceTokenValidationResult, Error>;

/**
 * Unifold color palette for React (Web)
 * Matches the React Native theme colors
 */
declare const defaultColors: {
    light: {
        background: string;
        card: string;
        cardHover: string;
        foreground: string;
        foregroundMuted: string;
        foregroundSubtle: string;
        border: string;
        borderSecondary: string;
        primary: string;
        primaryForeground: string;
        success: string;
        successBackground: string;
        warning: string;
        warningBackground: string;
        error: string;
        errorBackground: string;
        overlay: string;
    };
    dark: {
        background: string;
        card: string;
        cardHover: string;
        foreground: string;
        foregroundMuted: string;
        foregroundSubtle: string;
        border: string;
        borderSecondary: string;
        primary: string;
        primaryForeground: string;
        success: string;
        successBackground: string;
        warning: string;
        warningBackground: string;
        error: string;
        errorBackground: string;
        overlay: string;
    };
};
declare const colors: {
    light: {
        background: string;
        card: string;
        cardHover: string;
        foreground: string;
        foregroundMuted: string;
        foregroundSubtle: string;
        border: string;
        borderSecondary: string;
        primary: string;
        primaryForeground: string;
        success: string;
        successBackground: string;
        warning: string;
        warningBackground: string;
        error: string;
        errorBackground: string;
        overlay: string;
    };
    dark: {
        background: string;
        card: string;
        cardHover: string;
        foreground: string;
        foregroundMuted: string;
        foregroundSubtle: string;
        border: string;
        borderSecondary: string;
        primary: string;
        primaryForeground: string;
        success: string;
        successBackground: string;
        warning: string;
        warningBackground: string;
        error: string;
        errorBackground: string;
        overlay: string;
    };
};
type ThemeColors = typeof defaultColors.light;
type ThemeMode = "light" | "dark";
/** Partial theme colors for customization */
type CustomThemeColors = Partial<ThemeColors>;
/** Theme customization options */
interface ThemeConfig {
    /** Override colors for light mode */
    light?: CustomThemeColors;
    /** Override colors for dark mode */
    dark?: CustomThemeColors;
}
/** Font configuration */
interface FontConfig {
    /** Regular weight font family */
    regular?: string;
    /** Medium weight font family */
    medium?: string;
    /** Semi-bold weight font family */
    semibold?: string;
    /** Bold weight font family */
    bold?: string;
}
/** Header component tokens */
interface HeaderTokens {
    titleColor: string;
    buttonColor: string;
}
/** Card/button component tokens */
interface CardTokens {
    backgroundColor: string;
    titleColor: string;
    subtitleColor: string;
    labelColor: string;
    headerColor: string;
    labelRightColor: string;
    labelHighlightRightColor: string;
    textRightColor: string;
    subtextRightColor: string;
    rowLeftLabel: string;
    rowRightLabel: string;
    iconColor: string;
    iconBackgroundColor: string;
    actionColor: string;
    actionIcon: string;
    descriptionColor: string;
    borderRadius: number;
    borderWidth: number;
    borderColor: string;
}
/** Input component tokens */
interface InputTokens {
    backgroundColor: string;
    textColor: string;
    placeholderColor: string;
    borderColor: string;
    borderRadius: number;
    borderWidth: number;
}
/** Button component tokens */
interface ButtonTokens {
    primaryBackground: string;
    primaryText: string;
    secondaryBackground: string;
    secondaryText: string;
    borderRadius: number;
    borderWidth: number;
    borderColor: string;
}
/** Container/status display component tokens */
interface ContainerTokens {
    titleColor: string;
    subtitleColor: string;
    actionColor: string;
    actionTitle: string;
    buttonColor: string;
    buttonTitleColor: string;
    iconBackgroundColor: string;
    iconColor: string;
    borderRadius: number;
}
/** Search component tokens */
interface SearchTokens {
    backgroundColor: string;
    inputColor: string;
    placeholderColor: string;
}
/** List component tokens */
interface ListTokens {
    titleSectionColor: string;
    rowBorderRadius: number;
}
/** All resolved component tokens */
interface ComponentTokens {
    header: HeaderTokens;
    card: CardTokens;
    input: InputTokens;
    button: ButtonTokens;
    container: ContainerTokens;
    search: SearchTokens;
    list: ListTokens;
}
/** Per-component overrides structure */
interface ComponentOverrides {
    header?: Partial<HeaderTokens>;
    card?: Partial<CardTokens>;
    input?: Partial<InputTokens>;
    button?: Partial<ButtonTokens>;
    container?: Partial<ContainerTokens>;
    search?: Partial<SearchTokens>;
    list?: Partial<ListTokens>;
}
/**
 * User-provided component overrides (all optional)
 * Can be flat (applies to both modes) or have light/dark variants
 */
interface ComponentConfig extends ComponentOverrides {
    /** Light mode specific overrides */
    light?: ComponentOverrides;
    /** Dark mode specific overrides */
    dark?: ComponentOverrides;
}
/**
 * Resolve component tokens from base colors + optional overrides
 *
 * Override priority (highest wins):
 * 1. Mode-specific overrides (config.light or config.dark)
 * 2. Flat overrides (config.header, config.card, etc.)
 * 3. Base color defaults (semantic colors)
 */
declare function resolveComponentTokens(baseColors: ThemeColors, overrides?: ComponentConfig, mode?: ThemeMode): ComponentTokens;
declare function getColors(mode: ThemeMode): ThemeColors;
/**
 * Merge custom colors with default colors
 */
declare function mergeColors(mode: ThemeMode, customColors?: CustomThemeColors, accentColor?: string): ThemeColors;

/** Resolved font families for use in styles */
interface ResolvedFonts {
    regular: string | undefined;
    medium: string | undefined;
    semibold: string | undefined;
    bold: string | undefined;
}
interface ThemeContextValue {
    /** Legacy theme class (uf-dark or empty string) for backward compatibility */
    themeClass: string;
    /** Current theme mode */
    mode: ThemeMode;
    /** Resolved theme colors */
    colors: ThemeColors;
    /** Resolved font families */
    fonts: ResolvedFonts;
    /** Component-specific design tokens */
    components: ComponentTokens;
    /** Whether dark mode is active */
    isDark: boolean;
}
interface ThemeProviderProps {
    children: React$1.ReactNode;
    /** Force a specific theme mode, or 'auto' to use system preference */
    mode?: ThemeMode | "auto";
    /** Simple accent/primary color override (applies to both light and dark) */
    accentColor?: string;
    /** Full theme customization per mode */
    theme?: ThemeConfig;
    /** Single font family for all weights */
    fontFamily?: string;
    /** Granular font family configuration */
    fonts?: FontConfig;
    /** Component-specific token overrides (optional, falls back to base colors) */
    components?: ComponentConfig;
    /** Legacy themeClass prop for backward compatibility */
    themeClass?: string;
}
declare function ThemeProvider({ children, mode, accentColor, theme, fontFamily, fonts: fontConfig, components: componentConfig, themeClass: legacyThemeClass, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
declare function useTheme(): ThemeContextValue;

declare function cn(...inputs: ClassValue[]): string;
/**
 * Format estimated processing time in human-readable format
 * @param seconds - Time in seconds (can be null/undefined)
 * @returns Formatted string like "< 30 secs", "< 5 mins", "< 1 hr 30 mins", or empty string if no value
 */
/**
 * Truncate a blockchain address to show first and last N characters
 * @param address - Full address string
 * @param startChars - Number of characters to show at the start (default 10)
 * @param endChars - Number of characters to show at the end (default 8)
 * @returns Truncated address like "0x1234...abcd" or full address if shorter than total chars
 */
declare function truncateAddress(address: string, startChars?: number, endChars?: number): string;

export { type AllowedCountryResult, type BrowserWalletAmountQuickSelect, Button, type ButtonProps, type ButtonTokens, BuyWithCard, type BuyWithCardProps, type CardTokens, CheckingForDepositIndicator, CheckoutModal, type CheckoutModalProps, CoinbaseConnect, type ComponentConfig, type ComponentOverrides, type ComponentTokens, ConfirmingView, ConnectExchangeButton, type ContainerTokens, CurrencyListItem, CurrencyListSection, CurrencyModal, type CustomThemeColors, type DepositConfirmationMode, DepositDetailContent, DepositExecutionItem, DepositHeader, DepositModal, type DepositModalInitialScreen, type DepositModalProps, DepositSuccessToast, DepositTrackerButton, DepositWithCardButton, DepositsModal, type DetectedWallet, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, type EvmWalletProvider, type FontConfig, HYPERCORE_CHAIN_ID, type HeaderTokens, type InputTokens, type ListTokens, ManualDepositButton, QRCodeSkeleton, type ResolvedFonts, type SearchTokens, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, type SolanaWalletProvider, StyledQRCode, type ThemeColors, type ThemeConfig, type ThemeMode, ThemeProvider, type ThemeProviderProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, TransferCryptoButton, TransferCryptoDoubleInput, TransferCryptoSingleInput, type UseDepositQuoteParams, type UsePaymentIntentParams, type UseSupportedDepositTokensOptions, WithdrawConfirmingView, WithdrawDoubleInput, WithdrawExecutionItem, WithdrawForm, WithdrawModal, type WithdrawModalProps, WithdrawTokenSelector, type WithdrawTransactionInfo, buttonVariants, cn, colors, defaultColors, detectBrowserWallet, getColors, isHypercoreChain, mergeColors, resolveComponentTokens, sendEvmWithdraw, sendHypercoreWithdraw, sendSolanaWithdraw, truncateAddress, useAddressBalance, useAllowedCountry, useDepositPolling, useDepositQuote, usePaymentIntent, useSourceTokenValidation, useSupportedDepositTokens, useSupportedDestinationTokens, useTheme, useVerifyRecipientAddress, useWithdrawPolling };
