import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode } from 'react';
import * as _phantom_browser_sdk from '@phantom/browser-sdk';
import { BrowserSDKConfig, DebugConfig, AuthOptions, BrowserSDK, WalletAddress, ConnectResult, AuthProviderType, AutoConfirmEnableParams, AutoConfirmResult, AutoConfirmSupportedChainsResult, InjectedWalletInfo, AddressType } from '@phantom/browser-sdk';
export { AddressType, AuthOptions, AutoConfirmEnableParams, AutoConfirmResult, AutoConfirmSupportedChainsResult, ConnectErrorEventData, ConnectEventData, ConnectStartEventData, DebugLevel, DebugMessage, DisconnectEventData, EmbeddedProviderEvent, EmbeddedProviderEventMap, EventCallback, InjectedWalletId, InjectedWalletInfo, NetworkId, SignedTransaction, WalletAddress, base64urlDecode, base64urlEncode, debug, isMobileDevice } from '@phantom/browser-sdk';
import { PhantomTheme } from '@phantom/wallet-sdk-ui';
export { ComputedPhantomTheme, HexColor, PhantomTheme, darkTheme, lightTheme, mergeTheme, useTheme } from '@phantom/wallet-sdk-ui';
import { ISolanaChain, IEthereumChain } from '@phantom/chain-interfaces';
export { EthTransactionRequest, IEthereumChain, ISolanaChain } from '@phantom/chain-interfaces';
import * as _phantom_embedded_provider_core from '@phantom/embedded-provider-core';

type PhantomSDKConfig = BrowserSDKConfig;
interface PhantomDebugConfig extends DebugConfig {
}
interface ConnectOptions {
    embeddedWalletType?: "app-wallet" | "user-wallet";
    authOptions?: AuthOptions;
}
interface PhantomProviderProps {
    children: ReactNode;
    config: PhantomSDKConfig;
    debugConfig?: PhantomDebugConfig;
    theme?: Partial<PhantomTheme>;
    appIcon?: string;
    appName?: string;
}
declare function PhantomProvider({ children, config, debugConfig, theme, appIcon, appName }: PhantomProviderProps): react_jsx_runtime.JSX.Element;

interface PhantomErrors {
    connect?: Error;
    spendingLimit?: boolean;
}
interface PhantomContextValue {
    sdk: BrowserSDK | null;
    isConnected: boolean;
    isConnecting: boolean;
    isLoading: boolean;
    errors: PhantomErrors;
    addresses: WalletAddress[];
    isClient: boolean;
    user: ConnectResult | null;
    theme: PhantomTheme;
    allowedProviders: AuthProviderType[];
    clearError: (key: keyof PhantomErrors) => void;
}
declare function usePhantom(): PhantomContextValue;

declare function useConnect(): {
    connect: (options: AuthOptions) => Promise<_phantom_browser_sdk.ConnectResult>;
    isConnecting: boolean;
    isLoading: boolean;
    error: Error | undefined;
};

declare function useDisconnect(): {
    disconnect: () => Promise<void>;
    isDisconnecting: boolean;
    error: Error | null;
};

declare function useModal(): {
    open: () => void;
    close: () => void;
    isOpened: boolean;
};

declare function useAccounts(): _phantom_embedded_provider_core.WalletAddress[] | null;

/**
 * React hook to check if Phantom extension is installed
 * Uses waitForPhantomExtension for proper detection with retry logic
 */
declare function useIsExtensionInstalled(): {
    isLoading: boolean;
    isInstalled: boolean;
};

/**
 * React hook to check if Phantom Login is available
 * Checks if extension is installed and supports phantom_login feature
 */
declare function useIsPhantomLoginAvailable(): {
    isLoading: boolean;
    isAvailable: boolean;
};

interface UseAutoConfirmResult {
    enable: (params: AutoConfirmEnableParams) => Promise<AutoConfirmResult>;
    disable: () => Promise<void>;
    status: AutoConfirmResult | null;
    supportedChains: AutoConfirmSupportedChainsResult | null;
    isLoading: boolean;
    error: Error | null;
    refetch: () => Promise<void>;
}
declare function useAutoConfirm(): UseAutoConfirmResult;

/**
 * Hook for Solana chain operations
 *
 * @returns Solana chain interface with connection enforcement
 */
declare function useSolana(): {
    solana: ISolanaChain;
    isAvailable: boolean;
};

/**
 * Hook for Ethereum chain operations
 *
 * @returns Ethereum chain interface with connection enforcement
 */
declare function useEthereum(): {
    ethereum: IEthereumChain;
    isAvailable: boolean;
};

interface UseDiscoveredWalletsResult {
    wallets: InjectedWalletInfo[];
    isLoading: boolean;
    error: Error | null;
    refetch: () => Promise<void>;
}
declare function useDiscoveredWallets(): UseDiscoveredWalletsResult;

interface UseModalResult {
    open: () => void;
    close: () => void;
    isOpened: boolean;
}

interface ConnectButtonProps {
    addressType?: AddressType;
    fullWidth?: boolean;
}
declare function ConnectButton({ addressType, fullWidth }: ConnectButtonProps): react_jsx_runtime.JSX.Element;

interface ConnectBoxProps {
    maxWidth?: string | number;
    transparent?: boolean;
    appIcon?: string;
    appName?: string;
}
declare function ConnectBox({ maxWidth, transparent, appIcon, appName }: ConnectBoxProps): react_jsx_runtime.JSX.Element;

export { ConnectBox, ConnectBoxProps, ConnectButton, ConnectButtonProps, ConnectOptions, PhantomDebugConfig, PhantomProvider, PhantomProviderProps, PhantomSDKConfig, UseDiscoveredWalletsResult, UseModalResult, useAccounts, useAutoConfirm, useConnect, useDisconnect, useDiscoveredWallets, useEthereum, useIsExtensionInstalled, useIsPhantomLoginAvailable, useModal, usePhantom, useSolana };