import * as react_jsx_runtime from 'react/jsx-runtime';
import React from 'react';
import { smartWallet } from 'thirdweb/wallets';
import { PreparedTransaction } from 'thirdweb';
import { Chain } from 'thirdweb/chains';
export { C as CHAIN_CONFIG, D as DEFAULT_SHARE_RATES, O as OneChainSelector, i as OneChainSelectorProps, b as OneCycleSelector, k as OneCycleSelectorProps, e as OneForexCapitalSplit, n as OneForexCapitalSplitProps, f as OneForexConsoleView, o as OneForexConsoleViewProps, g as OneForexPairSelector, p as OneForexPairSelectorProps, d as OneForexPoolCard, m as OneForexPoolCardProps, h as OneForexTradeHistory, q as OneForexTradeHistoryProps, c as OnePairSelector, l as OnePairSelectorProps, a as OneTierSelector, j as OneTierSelectorProps, P as PAIR_ICONS, T as Tier } from '../OneForexTradeHistory-BMbwdkMm.js';
import { ViewStyle } from 'react-native';
import { N as CombinedLogEntry, a as BotLogEntry, t as ForexLogEntry, a6 as AIAgent, K as ConsoleMetrics, R as RiskStatus, c as BotState, D as AIPosition, G as AIDecision } from '../console-BoAIxikK.js';

interface OneConnectButtonProps {
    label?: string;
    theme?: 'light' | 'dark';
    className?: string;
    style?: React.CSSProperties;
    chain?: Parameters<typeof smartWallet>[0]['chain'];
    sponsorGas?: boolean;
    authOptions?: {
        email?: boolean;
        google?: boolean;
        apple?: boolean;
        discord?: boolean;
        passkey?: boolean;
    };
    onConnect?: (address: string) => void;
    onDisconnect?: () => void;
    accountAbstraction?: {
        chain: Parameters<typeof smartWallet>[0]['chain'];
        sponsorGas?: boolean;
    };
}
declare function OneConnectButton({ label, theme, className, style, chain, sponsorGas, authOptions, onConnect, onDisconnect, accountAbstraction, }: OneConnectButtonProps): react_jsx_runtime.JSX.Element;
declare function OneConnectButtonSimple(props: Omit<OneConnectButtonProps, 'authOptions'>): react_jsx_runtime.JSX.Element;
declare function OneConnectButtonFull(props: Omit<OneConnectButtonProps, 'authOptions'>): react_jsx_runtime.JSX.Element;

type PayMode = 'fund_wallet' | 'direct_payment' | 'transaction';
interface OnePayWidgetProps {
    mode?: PayMode;
    recipientAddress?: string;
    amount?: string;
    tokenAddress?: string;
    chainId?: number;
    transaction?: any;
    theme?: 'light' | 'dark';
    className?: string;
    style?: React.CSSProperties;
    buyWithCrypto?: boolean;
    buyWithFiat?: boolean;
    supportedTokens?: {
        [chainId: number]: string[];
    };
    onSuccess?: (result: any) => void;
    onError?: (error: Error) => void;
    onCancel?: () => void;
}
declare function OnePayWidget({ mode, recipientAddress, amount, tokenAddress, chainId, transaction, theme, className, style, buyWithCrypto, buyWithFiat, supportedTokens, onSuccess, onError, onCancel, }: OnePayWidgetProps): react_jsx_runtime.JSX.Element;
declare function OneFundWalletWidget(props: Omit<OnePayWidgetProps, 'mode'>): react_jsx_runtime.JSX.Element;
declare function OneDirectPayWidget(props: Omit<OnePayWidgetProps, 'mode'> & {
    recipientAddress: string;
    amount: string;
}): react_jsx_runtime.JSX.Element;
declare function OneCryptoOnlyPayWidget(props: Omit<OnePayWidgetProps, 'buyWithFiat'>): react_jsx_runtime.JSX.Element;
declare function OneFiatOnlyPayWidget(props: Omit<OnePayWidgetProps, 'buyWithCrypto'>): react_jsx_runtime.JSX.Element;

interface OneTransactionButtonProps {
    to: string;
    value?: bigint;
    data?: `0x${string}`;
    chain: Chain;
    transaction?: PreparedTransaction;
    label?: string;
    loadingLabel?: string;
    theme?: 'light' | 'dark';
    className?: string;
    style?: React.CSSProperties;
    disabled?: boolean;
    onSuccess?: (result: {
        transactionHash: string;
    }) => void;
    onError?: (error: Error) => void;
    onSubmitted?: (txHash: string) => void;
}
declare function OneTransactionButton({ to, value, data, chain, transaction: preparedTx, label, loadingLabel, theme, className, style, disabled, onSuccess, onError, onSubmitted, }: OneTransactionButtonProps): react_jsx_runtime.JSX.Element;
interface OneSendETHButtonProps extends Omit<OneTransactionButtonProps, 'data'> {
    amount: string;
}
declare function OneSendETHButton({ amount, ...props }: OneSendETHButtonProps): react_jsx_runtime.JSX.Element;
interface OneApproveButtonProps extends Omit<OneTransactionButtonProps, 'to' | 'data' | 'value'> {
    tokenAddress: string;
    spenderAddress: string;
    amount?: bigint;
}
declare function OneApproveButton({ tokenAddress, spenderAddress, amount, chain, ...props }: OneApproveButtonProps): react_jsx_runtime.JSX.Element;

interface OneSendWidgetProps {
    defaultRecipient?: string;
    defaultAmount?: string;
    defaultChain?: Chain;
    tokenAddress?: string;
    tokenSymbol?: string;
    tokenDecimals?: number;
    theme?: 'light' | 'dark';
    className?: string;
    style?: React.CSSProperties;
    onSuccess?: (txHash: string) => void;
    onError?: (error: Error) => void;
    onCancel?: () => void;
}
declare function OneSendWidget({ defaultRecipient, defaultAmount, defaultChain, tokenAddress, tokenSymbol, tokenDecimals, theme, className, style, onSuccess, onError, onCancel, }: OneSendWidgetProps): react_jsx_runtime.JSX.Element;
declare function OneSendETHWidget(props: Omit<OneSendWidgetProps, 'tokenAddress' | 'tokenSymbol' | 'tokenDecimals'>): react_jsx_runtime.JSX.Element;
declare function OneSendUSDCWidget(props: Omit<OneSendWidgetProps, 'tokenSymbol' | 'tokenDecimals'> & {
    tokenAddress: string;
}): react_jsx_runtime.JSX.Element;

interface OneOnrampWidgetProps {
    defaultFiat?: string;
    defaultCrypto?: string;
    defaultAmount?: number;
    defaultNetwork?: string;
    supportedFiats?: string[];
    supportedCryptos?: string[];
    supportedNetworks?: string[];
    email?: string;
    country?: string;
    theme?: 'light' | 'dark';
    accentColor?: string;
    className?: string;
    style?: React.CSSProperties;
    mode?: 'form' | 'embed' | 'popup';
    embedHeight?: number;
    onSuccess?: (transaction: OnrampTransaction) => void;
    onError?: (error: Error) => void;
    onClose?: () => void;
    onQuoteUpdate?: (quote: OnrampQuote) => void;
}
interface OnrampQuote {
    fiatCurrency: string;
    fiatAmount: number;
    cryptoCurrency: string;
    cryptoAmount: number;
    network: string;
    rate: number;
    fees: {
        network: number;
        provider: number;
        total: number;
    };
    estimatedTime: string;
}
interface OnrampTransaction {
    id: string;
    status: 'pending' | 'processing' | 'completed' | 'failed';
    fiatCurrency: string;
    fiatAmount: number;
    cryptoCurrency: string;
    cryptoAmount?: number;
    walletAddress: string;
    txHash?: string;
    provider: string;
}
declare function OneOnrampWidget({ defaultFiat, defaultCrypto, defaultAmount, defaultNetwork, supportedFiats, supportedCryptos, supportedNetworks, email, country, theme, accentColor, className, style, mode, embedHeight, onSuccess, onError, onClose, onQuoteUpdate, }: OneOnrampWidgetProps): react_jsx_runtime.JSX.Element;
declare function OneBuyUSDTWidget(props: Omit<OneOnrampWidgetProps, 'defaultCrypto'>): react_jsx_runtime.JSX.Element;
declare function OneBuyUSDCWidget(props: Omit<OneOnrampWidgetProps, 'defaultCrypto'>): react_jsx_runtime.JSX.Element;
declare function OneBuyETHWidget(props: Omit<OneOnrampWidgetProps, 'defaultCrypto'>): react_jsx_runtime.JSX.Element;
declare function OneBuyBTCWidget(props: Omit<OneOnrampWidgetProps, 'defaultCrypto'>): react_jsx_runtime.JSX.Element;

interface OneOfframpWidgetProps {
    defaultFiat?: string;
    defaultCrypto?: string;
    defaultAmount?: string;
    defaultNetwork?: string;
    supportedFiats?: string[];
    supportedCryptos?: string[];
    supportedNetworks?: string[];
    email?: string;
    country?: string;
    theme?: 'light' | 'dark';
    accentColor?: string;
    className?: string;
    style?: React.CSSProperties;
    mode?: 'form' | 'embed' | 'popup';
    embedHeight?: number;
    onSuccess?: (transaction: OfframpTransaction) => void;
    onError?: (error: Error) => void;
    onClose?: () => void;
    onQuoteUpdate?: (quote: OfframpQuote) => void;
}
interface OfframpQuote {
    cryptoCurrency: string;
    cryptoAmount: number;
    fiatCurrency: string;
    fiatAmount: number;
    network: string;
    rate: number;
    fees: {
        network: number;
        provider: number;
        total: number;
    };
    estimatedTime: string;
}
interface OfframpTransaction {
    id: string;
    status: 'pending' | 'processing' | 'completed' | 'failed';
    cryptoCurrency: string;
    cryptoAmount: number;
    fiatCurrency: string;
    fiatAmount?: number;
    walletAddress: string;
    txHash?: string;
    provider: string;
}
declare function OneOfframpWidget({ defaultFiat, defaultCrypto, defaultAmount, defaultNetwork, supportedFiats, supportedCryptos, supportedNetworks, email, country, theme, accentColor, // Red for sell
className, style, mode, embedHeight, onSuccess, onError, onClose, onQuoteUpdate, }: OneOfframpWidgetProps): react_jsx_runtime.JSX.Element;
declare function OneSellUSDTWidget(props: Omit<OneOfframpWidgetProps, 'defaultCrypto'>): react_jsx_runtime.JSX.Element;
declare function OneSellUSDCWidget(props: Omit<OneOfframpWidgetProps, 'defaultCrypto'>): react_jsx_runtime.JSX.Element;
declare function OneSellETHWidget(props: Omit<OneOfframpWidgetProps, 'defaultCrypto'>): react_jsx_runtime.JSX.Element;

interface SwapToken {
    address: string;
    symbol: string;
    name: string;
    decimals: number;
    logoURI?: string;
    chainId: number;
}
interface SwapRoute {
    provider: string;
    fromChain: number;
    toChain: number;
    fromToken: SwapToken;
    toToken: SwapToken;
    fromAmount: string;
    toAmount: string;
    estimatedGas: string;
    priceImpact: string;
    executionTime: string;
    steps: SwapStep[];
}
interface SwapStep {
    type: 'swap' | 'bridge' | 'approve';
    protocol: string;
    fromToken: string;
    toToken: string;
    fromChain: number;
    toChain: number;
}
interface OneSwapWidgetProps {
    defaultFromToken?: SwapToken;
    defaultToToken?: SwapToken;
    defaultFromChain?: Chain;
    defaultToChain?: Chain;
    supportedChains?: Chain[];
    tokens?: SwapToken[];
    mode?: 'same-chain' | 'cross-chain' | 'auto';
    theme?: 'light' | 'dark';
    accentColor?: string;
    className?: string;
    style?: React.CSSProperties;
    quoteEndpoint?: string;
    executeEndpoint?: string;
    onSwapSuccess?: (txHash: string, route?: SwapRoute) => void;
    onSwapError?: (error: Error) => void;
    onQuoteReceived?: (route: SwapRoute) => void;
    onChainChange?: (fromChain: number, toChain: number) => void;
}
declare function OneSwapWidget({ defaultFromToken, defaultToToken, defaultFromChain, defaultToChain, supportedChains, tokens, mode, theme, accentColor, className, style, quoteEndpoint, executeEndpoint, onSwapSuccess, onSwapError, onQuoteReceived, onChainChange, }: OneSwapWidgetProps): react_jsx_runtime.JSX.Element;
declare function OneSameChainSwap(props: Omit<OneSwapWidgetProps, 'mode'>): react_jsx_runtime.JSX.Element;
declare function OneCrossChainSwap(props: Omit<OneSwapWidgetProps, 'mode'>): react_jsx_runtime.JSX.Element;

interface TokenBalance {
    symbol: string;
    name: string;
    balance: string;
    balanceFormatted: string;
    balanceUsd: number;
    price: number;
    priceChange24h: number;
    chainId: number;
    chain: string;
    contractAddress?: string;
    logoURI?: string;
}
interface OneWalletBalanceProps {
    showTotalBalance?: boolean;
    showTokenList?: boolean;
    showChainFilter?: boolean;
    showPriceChange?: boolean;
    chains?: Chain[];
    balanceEndpoint?: string;
    theme?: 'light' | 'dark';
    className?: string;
    style?: React.CSSProperties;
    compact?: boolean;
    onTokenClick?: (token: TokenBalance) => void;
    onRefresh?: () => void;
}
declare function OneWalletBalance({ showTotalBalance, showTokenList, showChainFilter, showPriceChange, chains, balanceEndpoint, theme, className, style, compact, onTokenClick, onRefresh, }: OneWalletBalanceProps): react_jsx_runtime.JSX.Element;
declare function OneBalanceDisplay({ theme, className, style, }: Pick<OneWalletBalanceProps, 'theme' | 'className' | 'style'>): react_jsx_runtime.JSX.Element;

interface NFTItem {
    id: string;
    tokenId: string;
    contractAddress: string;
    name: string;
    description?: string;
    image?: string;
    animationUrl?: string;
    attributes?: Array<{
        trait_type: string;
        value: string | number;
    }>;
    chain: string;
    chainId: number;
    collection?: {
        name: string;
        image?: string;
    };
}
interface OneNFTGalleryProps {
    nfts?: NFTItem[];
    fetchEndpoint?: string;
    columns?: 2 | 3 | 4;
    showCollection?: boolean;
    showChain?: boolean;
    theme?: 'light' | 'dark';
    className?: string;
    style?: React.CSSProperties;
    onNFTClick?: (nft: NFTItem) => void;
    onTransfer?: (nft: NFTItem) => void;
}
declare function OneNFTGallery({ nfts: propNfts, fetchEndpoint, columns, showCollection, showChain, theme, className, style, onNFTClick, onTransfer, }: OneNFTGalleryProps): react_jsx_runtime.JSX.Element;

interface OneReceiveWidgetProps {
    chains?: Chain[];
    defaultChain?: Chain;
    showChainSelector?: boolean;
    showCopyButton?: boolean;
    showQRCode?: boolean;
    theme?: 'light' | 'dark';
    className?: string;
    style?: React.CSSProperties;
    qrSize?: number;
    onCopy?: (address: string) => void;
    onChainChange?: (chain: Chain) => void;
}
declare function OneReceiveWidget({ chains, defaultChain, showChainSelector, showCopyButton, showQRCode, theme, className, style, qrSize, onCopy, onChainChange, }: OneReceiveWidgetProps): react_jsx_runtime.JSX.Element;

/**
 * OneTradingConsole - Total unified console view (AI + Forex)
 * Part of ONE Ecosystem SDK
 */

interface OneTradingConsoleProps {
    mode?: 'combined' | 'ai-only' | 'forex-only';
    combinedLogs?: CombinedLogEntry[];
    aiLogs?: BotLogEntry[];
    forexLogs?: ForexLogEntry[];
    agents?: AIAgent[];
    metrics?: ConsoleMetrics;
    riskStatus?: RiskStatus | null;
    maxLogs?: number;
    autoScroll?: boolean;
    showMetrics?: boolean;
    showRisk?: boolean;
    showControls?: boolean;
    consoleHeight?: number;
    isAIRunning?: boolean;
    isForexRunning?: boolean;
    onStartAI?: () => void;
    onStopAI?: () => void;
    onStartForex?: () => void;
    onStopForex?: () => void;
    onStartAll?: () => void;
    onStopAll?: () => void;
    onClearLogs?: () => void;
    onRefresh?: () => void;
    onAgentSelect?: (agent: AIAgent) => void;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OneTradingConsole: React.FC<OneTradingConsoleProps>;

/**
 * OneAIQuantConsole - All 7 AI agents overview
 * Part of ONE Ecosystem SDK
 */

interface OneAIQuantConsoleProps {
    agents: AIAgent[];
    metrics?: ConsoleMetrics;
    riskStatus?: RiskStatus | null;
    layout?: 'list' | 'grid' | 'compact';
    showMetrics?: boolean;
    showRisk?: boolean;
    showPerformance?: boolean;
    showPositions?: boolean;
    onAgentSelect?: (agent: AIAgent) => void;
    onStartAll?: () => void;
    onStopAll?: () => void;
    isRunning?: boolean;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OneAIQuantConsole: React.FC<OneAIQuantConsoleProps>;

/**
 * OneAgentConsole - Individual agent detail view
 * Part of ONE Ecosystem SDK
 */

interface OneAgentConsoleProps {
    agent?: AIAgent;
    strategyId?: string;
    strategyName?: string;
    logs: BotLogEntry[];
    botState?: BotState;
    positions?: AIPosition[];
    decisions?: AIDecision[];
    showConsole?: boolean;
    showPositions?: boolean;
    showDecisions?: boolean;
    showMetrics?: boolean;
    maxLogs?: number;
    autoScroll?: boolean;
    consoleHeight?: number;
    onPositionPress?: (position: AIPosition) => void;
    onDecisionPress?: (decision: AIDecision) => void;
    onClosePosition?: (positionId: string) => void;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OneAgentConsole: React.FC<OneAgentConsoleProps>;

/**
 * OnePositionDetail - Detailed position tracking view
 * Part of ONE Ecosystem SDK
 */

interface OnePositionDetailProps {
    position: AIPosition;
    showTimeline?: boolean;
    showReasoning?: boolean;
    showRiskLevels?: boolean;
    showHistory?: boolean;
    priceUpdateInterval?: number;
    onClose?: (positionId: string) => void;
    onUpdateStopLoss?: (positionId: string, stopLoss: number) => void;
    onUpdateTakeProfit?: (positionId: string, takeProfit: number) => void;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OnePositionDetail: React.FC<OnePositionDetailProps>;

/**
 * OneAgentCard - Displays agent status and mini metrics
 * Part of ONE Ecosystem SDK
 */

interface OneAgentCardProps {
    agent: AIAgent;
    onPress?: (agent: AIAgent) => void;
    showMetrics?: boolean;
    showIndicators?: boolean;
    compact?: boolean;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OneAgentCard: React.FC<OneAgentCardProps>;

/**
 * OnePositionCard - Displays position with live P&L
 * Part of ONE Ecosystem SDK
 */

interface OnePositionCardProps {
    position: AIPosition;
    onPress?: (position: AIPosition) => void;
    onClose?: (positionId: string) => void;
    showDetails?: boolean;
    showRiskLevels?: boolean;
    compact?: boolean;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OnePositionCard: React.FC<OnePositionCardProps>;

/**
 * OneRiskIndicator - Displays risk status with visual indicators
 * Part of ONE Ecosystem SDK
 */

interface OneRiskIndicatorProps {
    riskStatus: RiskStatus;
    showDetails?: boolean;
    showWarnings?: boolean;
    showLimits?: boolean;
    compact?: boolean;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OneRiskIndicator: React.FC<OneRiskIndicatorProps>;

/**
 * OneMetricsDashboard - Displays trading metrics and performance
 * Part of ONE Ecosystem SDK
 */

interface OneMetricsDashboardProps {
    metrics: ConsoleMetrics;
    showNAV?: boolean;
    showPnL?: boolean;
    showTrades?: boolean;
    showPositions?: boolean;
    showStrategies?: boolean;
    compact?: boolean;
    style?: ViewStyle;
    dark?: boolean;
}
declare const OneMetricsDashboard: React.FC<OneMetricsDashboardProps>;

/**
 * OneDecisionTimeline - Displays AI decision history with reasoning
 * Part of ONE Ecosystem SDK
 */

interface OneDecisionTimelineProps {
    decisions: AIDecision[];
    maxItems?: number;
    showReasoning?: boolean;
    showIndicators?: boolean;
    showConfidence?: boolean;
    onDecisionPress?: (decision: AIDecision) => void;
    style?: ViewStyle;
    height?: number;
    dark?: boolean;
}
declare const OneDecisionTimeline: React.FC<OneDecisionTimelineProps>;

export { type NFTItem, type OfframpQuote, type OfframpTransaction, OneAIQuantConsole, type OneAIQuantConsoleProps, OneAgentCard, type OneAgentCardProps, OneAgentConsole, type OneAgentConsoleProps, OneApproveButton, type OneApproveButtonProps, OneBalanceDisplay, OneBuyBTCWidget, OneBuyETHWidget, OneBuyUSDCWidget, OneBuyUSDTWidget, OneConnectButton, OneConnectButtonFull, type OneConnectButtonProps, OneConnectButtonSimple, OneCrossChainSwap, OneCryptoOnlyPayWidget, OneDecisionTimeline, type OneDecisionTimelineProps, OneDirectPayWidget, OneFiatOnlyPayWidget, OneFundWalletWidget, OneMetricsDashboard, type OneMetricsDashboardProps, OneNFTGallery, type OneNFTGalleryProps, OneOfframpWidget, type OneOfframpWidgetProps, OneOnrampWidget, type OneOnrampWidgetProps, OnePayWidget, type OnePayWidgetProps, OnePositionCard, type OnePositionCardProps, OnePositionDetail, type OnePositionDetailProps, OneReceiveWidget, type OneReceiveWidgetProps, OneRiskIndicator, type OneRiskIndicatorProps, OneSameChainSwap, OneSellETHWidget, OneSellUSDCWidget, OneSellUSDTWidget, OneSendETHButton, type OneSendETHButtonProps, OneSendETHWidget, OneSendUSDCWidget, OneSendWidget, type OneSendWidgetProps, OneSwapWidget, type OneSwapWidgetProps, OneTradingConsole, type OneTradingConsoleProps, OneTransactionButton, type OneTransactionButtonProps, OneWalletBalance, type OneWalletBalanceProps, type OnrampQuote, type OnrampTransaction, type PayMode, type SwapRoute, type SwapStep, type SwapToken, type TokenBalance };
