import * as react_jsx_runtime from 'react/jsx-runtime';
import { AutoSwapResponse, ChainType, Wallet, FiatCurrency, ExecutionStatus, FeaturedToken, PaymentNetwork } from '@unifold/core';
export { ChainType } from '@unifold/core';
import * as class_variance_authority_types from 'class-variance-authority/types';
import * as React 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;
    /** 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;
}
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, depositConfirmationMode, depositWalletId, enabled, onDepositSuccess, onDepositError, }: UseDepositPollingOptions): UseDepositPollingResult;

interface DepositModalProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    userId: string;
    publishableKey: string;
    modalTitle?: string;
    destinationTokenSymbol?: string;
    recipientAddress?: string;
    destinationChainType?: ChainType;
    destinationChainId?: string;
    destinationTokenAddress?: 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;
    /** Enable "Pay with Exchange" option. Overrides dashboard default. Defaults to dashboard value or true. */
    enablePayWithExchange?: boolean;
    onDepositSuccess?: (data: {
        message: string;
        transaction?: unknown;
        executionId?: string;
    }) => 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;
}
declare function DepositModal({ open, onOpenChange, userId, publishableKey, modalTitle, destinationTokenSymbol, recipientAddress, destinationChainType, destinationChainId, destinationTokenAddress, hideDepositTracker, showBalanceHeader, transferInputVariant, depositConfirmationMode, enableConnectWallet, enablePayWithExchange, onDepositSuccess, onDepositError, theme, hideOverlay, }: 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";
    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;
    recipientAddress?: string;
    destinationChainType?: ChainType;
    destinationChainId?: string;
    destinationTokenAddress?: 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 TransferCryptoSingleInput({ userId, publishableKey, recipientAddress, destinationChainType, destinationChainId, destinationTokenAddress, depositConfirmationMode, onExecutionsChange, onDepositSuccess, onDepositError, wallets: externalWallets, }: TransferCryptoSingleInputProps): react_jsx_runtime.JSX.Element;

interface TransferCryptoDoubleInputProps {
    userId: string;
    publishableKey: string;
    recipientAddress?: string;
    destinationChainType?: ChainType;
    destinationChainId?: string;
    destinationTokenAddress?: 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, 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;
    onDepositError?: (error: {
        message: string;
        error?: unknown;
        code?: string;
    }) => void;
    themeClass?: string;
    wallets?: Wallet[];
    assetCdnUrl?: string;
}
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, themeClass, wallets: externalWallets, assetCdnUrl, }: 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;
}
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 DepositTrackerButtonProps {
    onClick: () => void;
    title: string;
    subtitle: string;
    badge?: number;
}
declare function DepositTrackerButton({ onClick, title, subtitle, badge, }: DepositTrackerButtonProps): react_jsx_runtime.JSX.Element;

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;
    removeListener(event: string, callback: (...args: unknown[]) => void): void;
}

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

interface DepositDetailContentProps {
    execution: AutoSwapResponse;
}
declare function DepositDetailContent({ execution }: DepositDetailContentProps): react_jsx_runtime.JSX.Element;

interface DepositPollingUiProps {
    depositConfirmationMode: DepositConfirmationMode;
    /** Whether polling has been triggered and waiting UI should be visible */
    showWaitingUi: boolean;
    /** Whether at least one execution has been detected (hides the processing card) */
    hasExecution: boolean;
    /** Called when user clicks "I've made the deposit" in manual mode */
    onIveDeposited: () => void;
}
/**
 * Deposit polling UI that renders the correct element based on confirmation mode:
 * - manual (before click): "I've made the deposit" button
 * - auto_ui / manual (after click): "Processing deposit transactions" spinner card
 * - auto_silent: nothing (null)
 */
declare function DepositPollingUi({ depositConfirmationMode, showWaitingUi, hasExecution, onIveDeposited, }: DepositPollingUiProps): react_jsx_runtime.JSX.Element | 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.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
}
declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;

declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
    /** Render inline without portal, overlay, or close button (for embedded/inline mode) */
    hideOverlay?: boolean;
}
declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
declare const DialogHeader: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogFooter: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;

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

declare const TooltipProvider: React.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.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.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

/**
 * Result of the useAllowedCountry hook
 */
interface AllowedCountryResult {
    /** Whether the user is in an allowed country. null while loading. */
    isAllowed: boolean | null;
    /** ISO 3166-1 alpha-2 country code in lowercase (e.g., "us", "pt") */
    alpha2: string | null;
    /** Full country name (e.g., "United States", "Portugal") */
    country: 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;

/**
 * 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.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, Button, type ButtonProps, type ButtonTokens, BuyWithCard, type CardTokens, type ComponentConfig, type ComponentOverrides, type ComponentTokens, type ContainerTokens, CurrencyListItem, CurrencyListSection, CurrencyModal, type CustomThemeColors, type DepositConfirmationMode, DepositDetailContent, DepositExecutionItem, DepositHeader, DepositModal, DepositPollingUi, DepositSuccessToast, DepositTrackerButton, DepositWithCardButton, DepositsModal, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, type FontConfig, type HeaderTokens, type InputTokens, type ListTokens, type ResolvedFonts, type SearchTokens, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, StyledQRCode, type ThemeColors, type ThemeConfig, type ThemeMode, ThemeProvider, type ThemeProviderProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, TransferCryptoButton, TransferCryptoDoubleInput, TransferCryptoSingleInput, buttonVariants, cn, colors, defaultColors, getColors, mergeColors, resolveComponentTokens, truncateAddress, useAllowedCountry, useDepositPolling, useTheme };
