@embarkai/ui-kit 0.4.16 → 0.4.18

package/dist/index.d.cts

@@ -0,0 +1,3034 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode, MutableRefObject, FC, HTMLAttributes, ButtonHTMLAttributes } from 'react';
+import { BlockscoutTokenBalance } from '@embarkai/core/clients';
+import * as viem from 'viem';
+import { Address as Address$1, Hex, PublicClient, Chain, Hash as Hash$1, TransactionReceipt } from 'viem';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+import { ChainConfig, createPublicClientForChain, createBundlerClientForChain, getChainConfig, getViemChain, lumiaTestnetChain, lumiaMainnetChain } from '@embarkai/core/read';
+import { BundlerClient } from 'viem/account-abstraction';
+import { UserOperationV07 } from '@embarkai/core/bundler';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as wagmi from 'wagmi';
+export { JwtTokens, LoginResponse, VerifyResponse, getValidTokens, jwtTokenManager, logout } from '@embarkai/core/auth';
+
+interface TokenBalance {
+    address: `0x${string}`;
+    name: string;
+    symbol: string;
+    decimals: number;
+    balance: string;
+    formattedBalance: string;
+    logo?: string;
+}
+/**
+ * Asset type classification
+ */
+type AssetType = 'native' | 'erc20' | 'erc721' | 'erc1155' | 'erc3643';
+/**
+ * NFT metadata from token instance
+ */
+interface NFTMetadata {
+    /** NFT name from metadata */
+    name?: string;
+    /** NFT description */
+    description?: string;
+    /** Image URL (resolved from IPFS if needed) */
+    image?: string;
+    /** External URL for more info */
+    externalUrl?: string;
+    /** Collection name */
+    collectionName?: string;
+    /** Additional attributes */
+    attributes?: Array<{
+        trait_type: string;
+        value: string | number;
+    }>;
+}
+/**
+ * Compliance status for security tokens (ERC3643)
+ */
+interface ComplianceStatus {
+    /** Whether the token is a security token (ERC3643) */
+    isSecurityToken: boolean;
+    /** Identity registry address */
+    identityRegistry?: `0x${string}`;
+    /** Whether current user is verified */
+    isVerified?: boolean;
+    /** Transfer restrictions message */
+    transferRestrictions?: string;
+}
+/**
+ * Error state for asset list
+ */
+interface AssetListError {
+    /** Error type for categorization */
+    type: 'network' | 'api' | 'timeout' | 'unknown';
+    /** Human-readable error message */
+    message: string;
+    /** Whether the request can be retried */
+    retryable: boolean;
+}
+/**
+ * Represents a token or NFT asset
+ */
+interface Asset {
+    /** Asset type classification */
+    type: AssetType;
+    /** Contract address (undefined for native token) */
+    address?: `0x${string}`;
+    /** Human-readable token name */
+    name: string;
+    /** Token symbol (e.g., "LUMIA", "USDC") */
+    symbol: string;
+    /** Raw balance as string (wei for fungible, count for NFT) */
+    balance: string;
+    /** Human-readable formatted balance */
+    formattedBalance: string;
+    /** Decimal precision (undefined for NFTs) */
+    decimals?: number;
+    /** USD rate reported by explorer when available */
+    exchangeRateUsd?: string;
+    /** NFT token ID (only for ERC721/ERC1155) */
+    tokenId?: string;
+    /** Token logo URL */
+    logo?: string;
+    /** NFT image URL (only for ERC721/ERC1155) */
+    image?: string;
+    /** NFT metadata (only for ERC721/ERC1155) */
+    nftMetadata?: NFTMetadata;
+    /** Security token compliance status (only for ERC3643) */
+    complianceStatus?: ComplianceStatus;
+}
+declare function useAssets(address?: `0x${string}`): {
+    nativeBalance: {
+        decimals: number;
+        formatted: string;
+        symbol: string;
+        value: bigint;
+    };
+    tokenBalances: any;
+    assets: Asset[];
+    getTokenBalance: (tokenAddress: `0x${string}`) => {
+        address: `0x${string}`;
+        name: string;
+        symbol: string;
+        decimals: number;
+        balance: string;
+        formattedBalance: string;
+        logo: string;
+    };
+    refreshBalances: () => Promise<void>;
+    isLoading: any;
+    isConnected: boolean;
+};
+declare function useTokenInfo(tokenAddress: `0x${string}`): {
+    isLoading: any;
+    tokenInfo: any;
+} | {
+    isLoading: boolean;
+    tokenInfo: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        address: `0x${string}`;
+    };
+};
+declare function useTokenBalance(tokenAddress: `0x${string}`, userAddress?: `0x${string}`): {
+    balance: bigint;
+    formattedBalance: string;
+    tokenInfo: any;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<bigint, viem.ReadContractErrorType>>;
+};
+
+/**  Default config can be overridden via Provider initialConfig */
+
+declare global {
+    interface Window {
+        __EMBARK_SERVICES__?: Partial<{
+            tssUrl: string;
+            shareVaultUrl: string;
+            dashboardApiUrl: string;
+            tssRequireWasm: boolean;
+            tssWasmDebug: boolean;
+        }>;
+        __EMBARK_PROJECT_ID__?: string;
+    }
+}
+interface SocialProvider {
+    id: string;
+    name: string;
+    enabled: boolean;
+    icon: React__default.ComponentType<{
+        className?: string;
+    }>;
+    comingSoon?: boolean;
+    meta?: Record<string, any>;
+}
+interface ProjectAsset extends Omit<Asset, 'type'> {
+    type: 'project';
+    balanceQueryKey: string[];
+    balanceQuery: () => Promise<{
+        cryptoFormatted: number;
+        cryptoFiatRate: number;
+        cryptoSymbol: string;
+        fiatFormatted: number;
+        fiatSymbol: string;
+    }>;
+    hideInPortfolio?: boolean;
+}
+interface AssetRateQueryInput {
+    symbol: string;
+    address?: `0x${string}`;
+}
+interface AssetRateQueryResult {
+    symbol: string;
+    price: string;
+}
+/**
+ * Token configuration for custom token watching.
+ * Used when chain doesn't have Blockscout API or for project-specific tokens.
+ * SDK will fetch balances via RPC multicall.
+ */
+interface WatchToken {
+    /** Contract address (required) */
+    address: `0x${string}`;
+    /** Token symbol for display (required) */
+    symbol: string;
+    /** Token name (optional, fetched from contract if missing) */
+    name?: string;
+    /** Token decimals (optional, fetched from contract if missing) */
+    decimals?: number;
+    /** Logo URL (optional) */
+    logo?: string;
+}
+type WalletMode = 'linked' | 'direct' | 'both';
+interface ProviderConfig {
+    projectId: string;
+    passkey: {
+        enabled: boolean;
+        showCreateButton: boolean;
+        primaryButtonText: string;
+    };
+    email: {
+        enabled: boolean;
+        placeholder: string;
+        buttonText: string;
+        verificationTitle: string;
+    };
+    social: {
+        enabled: boolean;
+        providers: SocialProvider[];
+    };
+    wallet: {
+        enabled: boolean;
+        supportedChains?: number[];
+        requireSignature: boolean;
+        walletConnectProjectId?: string;
+        /** Operating mode: 'linked' = AA (current), 'direct' = external wallet signs, 'both' = user choice */
+        mode?: WalletMode;
+        /** Filter RainbowKit wallet list. undefined = show all wallets */
+        allowedWallets?: string[];
+    };
+    preferedColorMode?: 'light' | 'dark';
+    projectAssets?: {
+        assets: ProjectAsset[];
+        showBalanceAs?: ProjectAsset['symbol'];
+    };
+    /**
+     * Host-provided portfolio data overrides.
+     * If tokenBalancesQuery is provided, SDK uses it instead of Blockscout
+     * for ERC-20 portfolio balances and keeps the legacy Blockscout path as fallback.
+     */
+    portfolio?: {
+        tokenBalancesQuery?: (address: `0x${string}`) => Promise<BlockscoutTokenBalance[]>;
+        tokenBalancesQueryKey?: readonly unknown[];
+        assetRateQuery?: (input: AssetRateQueryInput) => Promise<AssetRateQueryResult | null>;
+        assetRateQueryKey?: readonly unknown[];
+    };
+    /**
+     * Custom tokens to monitor per chain.
+     * SDK will fetch balances via RPC multicall.
+     * Useful for chains without Blockscout API (BSC, Sepolia, Arbitrum, Base, etc.).
+     * Can also be used on Blockscout chains - tokens are merged with discovered ones.
+     *
+     * @example
+     * watchTokens: {
+     *   97: [ // BSC Testnet
+     *     { address: '0x...', symbol: 'USDT', decimals: 18 },
+     *     { address: '0x...', symbol: 'BUSD', decimals: 18, logo: 'https://...' },
+     *   ],
+     *   11155111: [ // Sepolia
+     *     { address: '0x...', symbol: 'LINK', decimals: 18 },
+     *   ]
+     * }
+     */
+    watchTokens?: {
+        [chainId: number]: WatchToken[];
+    };
+    ui: {
+        title: string;
+        subtitle?: string;
+        useExternalIcons?: boolean;
+        dialogClassName?: string;
+        authOrder?: ('email' | 'social' | 'wallet')[];
+    };
+    network: {
+        name: string;
+        symbol: string;
+        /**
+         * Default chain ID for new users.
+         * Priority: User's explicit selection > dApp config chainId > SDK default (Testnet).
+         * If user manually switches chains, their choice is preserved in localStorage.
+         */
+        chainId: number;
+        rpcUrl: string;
+        explorerUrl?: string;
+        testnet?: boolean;
+        forceChain?: boolean;
+    };
+    services: {
+        tssUrl: string;
+        shareVaultUrl: string;
+        dashboardApiUrl?: string;
+        iframeUrl?: string;
+        tssRequireWasm?: boolean;
+        tssWasmDebug?: boolean;
+    };
+    features: {
+        mpcSecurity: boolean;
+        strictMode: boolean;
+        requestDeduplication: boolean;
+        kycNeeded?: boolean;
+        displayNameNeeded?: boolean;
+        showActiveBalanceAsFiat?: boolean;
+    };
+    warnings: {
+        backupWarning: boolean;
+        emailNotConnectedWarning: boolean;
+    };
+    kyc?: {
+        provider?: 'sumsub' | 'uaepass' | 'custom';
+        options?: Record<string, any>;
+    };
+    /** language -> project namespace -> resource map */
+    translations?: Record<string, Record<string, unknown>>;
+}
+
+interface WalletReadyStatus$1 {
+    ready: boolean;
+    userId?: string;
+    address?: `0x${string}`;
+    hasKeyshare: boolean;
+    hasSession: boolean;
+    timestamp: number;
+}
+interface CallbacksConfig {
+    onConnecting?: (payload: {
+        method: 'passkey' | 'email' | 'social' | 'wallet';
+        provider?: string;
+    }) => void;
+    onConnect?: (payload: {
+        address: `0x${string}`;
+        session: any;
+    }) => void;
+    onAccount?: (payload: {
+        userId?: string | null;
+        address?: `0x${string}` | null;
+        session?: any;
+        hasKeyshare?: boolean;
+    }) => void;
+    onAccountUpdate?: (payload: {
+        providers?: Array<any>;
+    }) => void;
+    onDisconnect?: (payload: {
+        address?: `0x${string}` | null;
+        userId?: string | null;
+    }) => void;
+    onError?: (payload: {
+        error: Error;
+        code?: string;
+        message: string;
+    }) => void;
+    onChainChange?: (payload: {
+        chainId: number;
+        previousChainId: number;
+    }) => void;
+    onWalletReady?: (status: WalletReadyStatus$1) => void;
+}
+interface UIContextType {
+    config: MutableRefObject<ProviderConfig>;
+    updateConfig: (updates: Partial<ProviderConfig>) => void;
+    /**
+     * Legacy snapshot of callbacks from provider props.
+     * This field is not reactive and may become stale after calling updateCallbacks().
+     * Use callbacksRef to read the current callbacks.
+     * @deprecated
+     */
+    callbacks?: CallbacksConfig;
+    callbacksRef: MutableRefObject<CallbacksConfig | undefined>;
+    updateCallbacks: (updates: Partial<CallbacksConfig> | null) => void;
+}
+interface ProviderProps {
+    children: ReactNode;
+    projectId?: string;
+    initialConfig?: Partial<ProviderConfig>;
+    callbacks?: CallbacksConfig;
+}
+/** NEVER EVER declare here any state (useState or whatever). This Provider should NEVER trigger self of child-app re-renders */
+declare function Provider(props: ProviderProps): react_jsx_runtime.JSX.Element;
+declare const useProviderConfig: () => UIContextType;
+
+interface ConnectWalletButtonProps {
+    /** Button Component to render as unsigned button instance */
+    ConnectButton?: FC<HTMLAttributes<HTMLButtonElement>>;
+    className?: string;
+    label?: string;
+    usePaymaster?: boolean;
+}
+declare function ConnectWalletButton(props: ConnectWalletButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Account session containing wallet and smart account information.
+ * Shared across multiple modules (session, user-operations, signing, deployment).
+ */
+interface AccountSession$1 {
+    ownerAddress: `0x${string}`;
+    smartAccountAddress: `0x${string}`;
+    factoryAddress: `0x${string}`;
+    ownerPrivateKey?: `0x${string}`;
+    mpcUserId?: string;
+    usePaymaster?: boolean;
+    kind: 'lumia';
+    address: `0x${string}`;
+}
+
+/**
+ * Deploy smart account contract if not already deployed.
+ *
+ * This sends a minimal UserOperation (to 0x0, value 0, data 0x) which triggers
+ * account deployment via factory without requiring user consent.
+ *
+ * By default, checks if account is already deployed to avoid unnecessary gas costs.
+ * If already deployed, returns null without sending a transaction.
+ *
+ * @param session - Account session with signing credentials
+ * @param feeType - Fee type: 'economy', 'standard', or 'fast' (default: 'economy')
+ * @param options - Deployment options
+ * @param options.force - If true, sends transaction even if already deployed (default: false)
+ * @param options.chainId - Chain ID
+ * @returns UserOperation hash if deployed, null if already deployed (when force=false)
+ *
+ * @example
+ * ```typescript
+ * // Deploy account immediately after DKG (skips if already deployed)
+ * const userOpHash = await deployAccount(session, 'economy');
+ * if (userOpHash) {
+ *   console.log('Account deployed:', userOpHash);
+ * } else {
+ *   console.log('Account already deployed');
+ * }
+ *
+ * // Force deployment even if already deployed (not recommended)
+ * const hash = await deployAccount(session, 'economy', { force: true });
+ * ```
+ */
+declare function deployAccount(session: AccountSession$1, feeType?: 'economy' | 'standard' | 'fast', options?: {
+    force?: boolean;
+    chainId?: number;
+}): Promise<`0x${string}` | null>;
+
+interface SmartAccountEntry {
+    chainId: number;
+    address: string;
+    factoryAddress?: string;
+    registeredAt: string;
+}
+interface RegisterSmartAccountResult {
+    success: boolean;
+    chainId: number;
+    smartAccountAddress: string;
+    alreadySet: boolean;
+}
+/**
+ * Get all registered Smart Accounts across all chains.
+ *
+ * @returns List of Smart Account entries with chain IDs
+ */
+declare function getAllSmartAccounts(): Promise<SmartAccountEntry[]>;
+/**
+ * Get Smart Account for a specific chain.
+ *
+ * @param chainId - The chain ID to get Smart Account for
+ * @returns Smart Account entry or null if not registered
+ */
+declare function getSmartAccountForChain(chainId: number): Promise<SmartAccountEntry | null>;
+
+interface AccountSession {
+    ownerAddress: `0x${string}`;
+    smartAccountAddress: `0x${string}`;
+    factoryAddress: `0x${string}`;
+    ownerPrivateKey?: `0x${string}`;
+    mpcUserId?: string;
+    usePaymaster?: boolean;
+    kind: 'lumia';
+    address: `0x${string}`;
+}
+/**
+ * Parameters for preparing a UserOperation
+ */
+interface PrepareUserOperationParams {
+    /** Target address for the transaction */
+    to: `0x${string}`;
+    /** Amount in wei to send (as string) */
+    value: string;
+    /** Call data for the transaction (optional, defaults to '0x') */
+    data?: `0x${string}`;
+    /** Fee tier: 'economy', 'standard' (default), or 'fast' */
+    feeType?: 'economy' | 'standard' | 'fast';
+    /** Chain ID (optional - uses activeChainId from store if not provided) */
+    chainId?: number;
+}
+/**
+ * Prepare and sign a UserOperation without sending it to the bundler.
+ * Returns the signed UserOp and its hash for backend verification and submission.
+ * Uses object-based parameters with multi-chain support.
+ *
+ * @param session - Account session with signing credentials
+ * @param params - Transaction parameters (to, value, data, feeType, chainId)
+ * @returns Object with signed UserOperation and its hash
+ *
+ * @example
+ * ```typescript
+ * const { userOp, userOpHash } = await prepareUserOperation(session, {
+ *   to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+ *   value: '1000000000000000000',
+ *   data: '0x',
+ *   feeType: 'standard'
+ * });
+ * ```
+ */
+declare function prepareUserOperation(session: AccountSession, params: PrepareUserOperationParams): Promise<{
+    userOp: UserOperationV07;
+    userOpHash: `0x${string}`;
+}>;
+/**
+ * EIP712 Domain descriptor
+ */
+interface TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: `0x${string}`;
+    salt?: `0x${string}`;
+}
+/**
+ * EIP712 Type definition
+ */
+interface TypedDataField {
+    name: string;
+    type: string;
+}
+/**
+ * Parameters for signing typed data (EIP712)
+ */
+/**
+ * Parameters for sending or preparing a UserOperation (UI-Kit layer)
+ * Higher-level API compared to core/bundler UserOperationParams
+ */
+interface SendUserOperationParams {
+    /** Target address for the transaction */
+    to: `0x${string}`;
+    /** Amount in wei to send (as string) */
+    value: string;
+    /** Call data for the transaction (optional, defaults to '0x') */
+    data?: `0x${string}`;
+    /** Fee tier: 'economy', 'standard' (default), or 'fast' */
+    feeType?: 'economy' | 'standard' | 'fast';
+    /** Chain ID (optional - uses activeChainId from store if not provided) */
+    chainId?: number;
+}
+/**
+ * Send a user operation with multi-chain support.
+ * Uses object-based parameters for better developer experience.
+ *
+ * @param session - Account session with signing credentials
+ * @param params - Transaction parameters (to, value, data, feeType, chainId)
+ * @returns Promise resolving to the user operation hash
+ *
+ * @example
+ * ```typescript
+ * const hash = await sendUserOperation(session, {
+ *   to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+ *   value: '1000000000000000000', // 1 ETH in wei
+ *   data: '0x',
+ *   feeType: 'standard'
+ * });
+ * ```
+ */
+declare function sendUserOperation(session: AccountSession, params: SendUserOperationParams): Promise<`0x${string}`>;
+/**
+ * Parameters for EIP-712 typed data signing
+ */
+interface SignTypedDataParams {
+    domain: TypedDataDomain;
+    types: Record<string, TypedDataField[]>;
+    primaryType: string;
+    message: Record<string, any>;
+    /** Chain ID (optional - overrides domain.chainId if provided) */
+    chainId?: number;
+}
+/**
+ * Sign typed data according to EIP712 standard.
+ * This method computes the EIP712 hash and signs it using MPC.
+ *
+ * @param session - Account session with signing credentials
+ * @param params - EIP712 typed data parameters (domain, types, primaryType, message)
+ * @returns Hex-encoded signature
+ *
+ * @example
+ * ```typescript
+ * const signature = await signTypedData(session, {
+ *   domain: {
+ *     name: 'MyApp',
+ *     version: '1',
+ *     chainId: 994,
+ *     verifyingContract: '0x...'
+ *   },
+ *   types: {
+ *     Order: [
+ *       { name: 'tokenIds', type: 'uint256[]' },
+ *       { name: 'price', type: 'uint256' },
+ *       { name: 'deadline', type: 'uint256' }
+ *     ]
+ *   },
+ *   primaryType: 'Order',
+ *   message: {
+ *     tokenIds: [1n, 2n, 3n],
+ *     price: 1000000000000000000n,
+ *     deadline: 1735689600n
+ *   }
+ * });
+ * ```
+ */
+declare function signTypedData(session: AccountSession, params: SignTypedDataParams): Promise<`0x${string}`>;
+
+/**
+ * Iframe Manager for Parent SDK
+ *
+ * Manages secure communication with the isolated iframe wallet at auth.lumiapassport.com
+ * Implements postMessage protocol with HMAC authentication and replay protection
+ */
+
+interface Transaction$1 {
+    to: Address$1;
+    value: string;
+    data?: Hex;
+    gasLimit?: string;
+}
+interface IframeManagerConfig {
+    iframeUrl: string;
+    projectId: string;
+    debug?: boolean;
+    onWalletReady?: (status: WalletReadyStatus) => void;
+}
+interface WalletReadyStatus {
+    ready: boolean;
+    userId?: string;
+    address?: `0x${string}`;
+    hasKeyshare: boolean;
+    hasSession: boolean;
+    timestamp: number;
+}
+declare class IframeManager {
+    private iframe;
+    private iframeUrl;
+    private projectId;
+    private debug;
+    private channelToken;
+    private isReady;
+    private readyPromise;
+    private readyResolve;
+    private initPromise;
+    private onWalletReadyCallback?;
+    private pendingRequests;
+    private usedNonces;
+    private messageListener;
+    private hiddenElements;
+    private pointerGuardCleanup;
+    private iframeHideTimeout;
+    private iframeActive;
+    private providerSessions;
+    private providerConnections;
+    private readonly REQUEST_TIMEOUT;
+    private readonly NONCE_EXPIRY;
+    private readonly HEARTBEAT_INTERVAL;
+    private heartbeatInterval?;
+    private isReconnecting;
+    private sseListeners;
+    constructor(config: IframeManagerConfig);
+    setDebug(debug: boolean): void;
+    /**
+     * Initialize iframe and wait for it to be ready
+     */
+    initialize(): Promise<void>;
+    private doInitialize;
+    /**
+     * Set the onWalletReady callback
+     */
+    setOnWalletReady(callback: (status: WalletReadyStatus) => void): void;
+    /**
+     * Authenticate SDK with iframe to establish secure channel
+     */
+    private authenticateSDK;
+    /**
+     * Start periodic heartbeat to check SDK channel validity
+     */
+    private startHeartbeat;
+    /**
+     * Stop heartbeat
+     */
+    private stopHeartbeat;
+    /**
+     * Reconnect SDK channel after it becomes invalid
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Setup visibility change handler to check channel when tab becomes visible
+     */
+    private setupVisibilityHandler;
+    /**
+     * Normalize legacy message types from cached iframe versions.
+     * Old iframe sends LUMIA_PASSPORT_*, new iframe sends IFRAME_MSG_*.
+     * This ensures both work until all browser caches expire.
+     */
+    private normalizeMessageType;
+    /**
+     * Handle incoming postMessage events
+     */
+    private handleMessage;
+    /**
+     * Handle token refresh request from iframe
+     */
+    private handleTokenRefreshRequest;
+    /**
+     * Send secure message to iframe
+     */
+    sendMessage(type: string, data: Record<string, any>): Promise<any>;
+    onSseEvent(listener: (data: any) => void): () => void;
+    /**
+     * Compute HMAC for message authentication using SDK channel token
+     */
+    private computeHMAC;
+    /**
+     * Generate unique message ID
+     */
+    private generateMessageId;
+    /**
+     * Generate nonce for replay protection
+     */
+    private generateNonce;
+    /**
+     * Show iframe (for consent/confirmation UI)
+     */
+    showIframe(): void;
+    /**
+     * Hide iframe
+     */
+    hideIframe(): void;
+    /**
+     * Hide all Radix Dialog modals (SendModal, etc.)
+     */
+    private hideAllDialogs;
+    /**
+     * Restore all previously hidden Radix Dialog modals
+     */
+    private restoreAllDialogs;
+    /**
+     * Stop Radix dismissable layers from swallowing the first click on the iframe.
+     * Radix attaches pointer event guards at the document level; we intercept at window
+     * capture phase so user clicks flow straight into the consent iframe.
+     */
+    private enablePointerEventGuards;
+    /**
+     * Remove pointer interception once iframe is hidden again.
+     */
+    private disablePointerEventGuards;
+    /**
+     * Authenticate user with application
+     */
+    authenticate(userId: string, avatar?: string | null, displayName?: string | null): Promise<{
+        userId: string;
+        address: Address$1 | undefined;
+    }>;
+    /**
+     * Start DKG (Distributed Key Generation)
+     */
+    startDKG(userId: string, accessToken?: string): Promise<Address$1>;
+    /**
+     * Sign transaction
+     */
+    signTransaction(userId: string, transaction: Transaction$1, accessToken?: string, avatar?: string | null, displayName?: string | null): Promise<Hex>;
+    /**
+     * Sign EIP712 typed data
+     */
+    signTypedData(userId: string, typedData: {
+        domain: {
+            name?: string;
+            version?: string;
+            chainId?: number;
+            verifyingContract?: string;
+            salt?: string;
+        };
+        types: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType: string;
+        message: Record<string, any>;
+    }, digest32: Hex, accessToken?: string, avatar?: string | null, displayName?: string | null): Promise<Hex>;
+    /**
+     * Get user's wallet address
+     */
+    getAddress(userId: string): Promise<Address$1 | undefined>;
+    /**
+     * Check if user has a keyshare
+     */
+    checkKeyshare(userId: string): Promise<{
+        hasKeyshare: boolean;
+        address?: Address$1;
+    }>;
+    /**
+     * Open social auth popup (Telegram, Discord, Twitter, etc.)
+     */
+    openSocialAuthPopup(provider: string, config?: Record<string, any>): Promise<{
+        provider: string;
+        success: boolean;
+        user?: any;
+        mode?: 'login' | 'link';
+        error?: string;
+    }>;
+    /**
+     * Verify current auth session with the backend.
+     * Can optionally track session state for a specific provider.
+     * @param options.silent - If true, suppress logging
+     * @param options.provider - Optional provider key to track session state for (e.g., 'x', 'telegram')
+     */
+    private verifyAuthSession;
+    /**
+     * Prime provider session/cache state to detect future changes.
+     */
+    private primeProviderSessions;
+    private getKnownSessionId;
+    private getKnownProviderConnection;
+    private recordProviderSession;
+    private recordProviderConnection;
+    private updateProviderTrackingFromUser;
+    private extractSessionId;
+    private getProvidersList;
+    /**
+     * Get trusted apps for user
+     */
+    getTrustedApps(userId: string): Promise<{
+        userId: string;
+        projectId: string;
+        origin: string;
+        trustedAt: number;
+        appName?: string;
+        appLogo?: string;
+    }[]>;
+    /**
+     * Remove app from trusted list
+     */
+    removeTrustedApp(userId: string, projectId: string, origin: string): Promise<boolean>;
+    /**
+     * Clear all authorizations for current project (for testing consent flow)
+     * This will force the consent modal to appear on next authentication
+     */
+    clearAuthorizations(): Promise<boolean>;
+    /**
+     * Create backup of keyshare
+     */
+    createBackup(userId: string, backupRequest: {
+        method: 'server' | 'cloud' | 'local';
+        password?: string;
+        cloudProvider?: string;
+    }, accessToken?: string): Promise<{
+        success: boolean;
+        method: string;
+        timestamp: number;
+        error?: string;
+    }>;
+    /**
+     * Restore keyshare from server backup
+     */
+    restoreFromServer(userId: string, password?: string, accessToken?: string): Promise<{
+        success: boolean;
+        timestamp: number;
+        error?: string;
+        data?: any;
+    }>;
+    /**
+     * Encrypt backup data without uploading (for cloud/local backups)
+     * Returns encrypted data that parent can upload/download
+     */
+    encryptBackupData(userId: string, password?: string): Promise<any>;
+    /**
+     * Encrypt current keyshare as EnvelopeEncryptedShare (for Guardian backup)
+     */
+    encryptEnvelopeData(userId: string, password: string): Promise<string>;
+    /**
+     * Decrypt EnvelopeEncryptedShare and restore keyshare (for Guardian restore)
+     */
+    decryptAndRestoreEnvelope(userId: string, envelopeJson: string, password: string): Promise<{
+        success: boolean;
+        timestamp: number;
+        error?: string;
+    }>;
+    /**
+     * Restore keyshare from local file backup
+     */
+    restoreFromLocalFile(userId: string, fileContent: string, password?: string): Promise<{
+        success: boolean;
+        timestamp: number;
+        error?: string;
+        data?: any;
+    }>;
+    /**
+     * Get backup status for user
+     */
+    getBackupStatus(userId: string): Promise<{
+        server: {
+            lastBackup?: number;
+            error?: string;
+        };
+        cloud: {
+            lastBackup?: number;
+            error?: string;
+        };
+        local: {
+            lastBackup?: number;
+            error?: string;
+        };
+    }>;
+    /**
+     * Get available cloud providers
+     */
+    getCloudProviders(): Promise<Array<{
+        id: string;
+        name: string;
+        available: boolean;
+    }>>;
+    /**
+     * Cleanup and destroy iframe
+     */
+    destroy(): void;
+    /**
+     * Debug logging
+     */
+    private log;
+}
+/**
+ * Get or create iframe manager singleton
+ */
+declare function getIframeManager(config?: IframeManagerConfig): IframeManager;
+/**
+ * Destroy iframe manager singleton
+ */
+declare function destroyIframeManager(): void;
+
+interface ChainParams {
+    activeChainId: number;
+    publicClient: ReturnType<typeof createPublicClientForChain>;
+    bundlerClient: ReturnType<typeof createBundlerClientForChain>;
+    chainConfig: ReturnType<typeof getChainConfig>;
+    viemChain: ReturnType<typeof getViemChain>;
+}
+interface SessionState {
+    session: AccountSession | null;
+    address: `0x${string}` | null;
+    status: string;
+    error: string | null;
+    recoveryUserId: string | null;
+    isIframeReady: boolean;
+    usePaymaster: boolean;
+    hasServerVault: boolean;
+    isLoading: boolean;
+    activeChainId: number | null;
+    publicClient: PublicClient | null;
+    bundlerClient: BundlerClient | null;
+    chainConfig: ChainConfig | null;
+    viemChain: Chain | null;
+    /** Tracks if user explicitly selected a chain (vs using dApp config default) */
+    walletReadyStatus: WalletReadyStatus | null;
+    /** Whether zustand persist has finished hydrating from localStorage */
+    hasHydrated: boolean;
+    setUsePaymaster: (usePaymaster: boolean) => void;
+    setIsIframeReady: (ready: boolean) => void;
+    setSession: (s: AccountSession | null) => void;
+    setAddress: (a: `0x${string}` | null) => void;
+    setStatus: (s: string) => void;
+    setError: (e: string | null) => void;
+    setRecoveryUserId: (userId: string | null) => void;
+    setHasServerVault: (hasServerVault: boolean) => void;
+    setIsLoading: (isLoading: boolean) => void;
+    setWalletReadyStatus: (status: WalletReadyStatus) => void;
+    setActiveChainId: (activeChainId: number | null) => void;
+    setActiveChain: (chainParams: ChainParams) => void;
+}
+/**
+ *  @function useSession is UNLIKELY to use outside EmbarkAI, as it is INTERNAL zustand session store!
+ *  Use it with caution, using zustand callback extraction. EX: const address = useSession((st) => st.address)
+ *  @description refactor your app to NOT use this directly in your application, use set of new dedicated session hooks: useAccountSession, useAddress, etc.
+ */
+declare const useSession: zustand.UseBoundStore<Omit<zustand.StoreApi<SessionState>, "setState" | "persist"> & {
+    setState(partial: SessionState | Partial<SessionState> | ((state: SessionState) => SessionState | Partial<SessionState>), replace?: false): unknown;
+    setState(state: SessionState | ((state: SessionState) => SessionState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<SessionState, {
+            activeChainId: number;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SessionState) => void) => () => void;
+        onFinishHydration: (fn: (state: SessionState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<SessionState, {
+            activeChainId: number;
+        }, unknown>>;
+    };
+}>;
+/**
+ * Wait for zustand persist hydration to complete.
+ * Use in async functions to ensure activeChainId and other persisted state is available.
+ */
+declare function waitForStoreHydration(): Promise<void>;
+/**
+ * Require active chain ID from session store (for non-React usage)
+ * Throws an error if the chain ID is not yet set (e.g., before store hydration)
+ *
+ * @returns Current active chain ID
+ * @throws Error if activeChainId is null (store not hydrated yet)
+ *
+ * @example
+ * ```typescript
+ * import { requireActiveChainId } from '@embarkai/ui-kit'
+ *
+ * // In non-React code (e.g., sendUserOperation)
+ * const chainId = requireActiveChainId()
+ * const client = createPublicClientForChain(chainId)
+ * ```
+ */
+declare const requireActiveChainId: () => number;
+
+declare const useIsMobileView: () => boolean;
+declare const useBalance: () => {
+    walletBalance: {
+        decimals: number;
+        formatted: string;
+        symbol: string;
+        value: bigint;
+    };
+    fiatBalance: number;
+    cryptoRate: number;
+    fiatSymbol: string;
+    cryptoSymbol: string;
+};
+declare const useIFrameReady: () => boolean;
+declare const useAccountSession: () => AccountSession;
+declare const useAddress: () => `0x${string}`;
+declare const useError: () => string;
+declare const useLoadingStatus: () => {
+    isSessionLoading: boolean;
+    sessionStatus: string;
+};
+declare const useRecoveryUserId: () => string;
+declare const useHasServerVault: () => boolean;
+declare const useActiveChainId: () => number;
+declare const useHydrated: () => boolean;
+
+declare enum PageKey {
+    AUTH = "auth",
+    LANGUAGES = "languages",
+    TERMS_OF_SERVICE = "terms-of-service",
+    MAIN_MENU = "main-menu",
+    SETTINGS = "settings",
+    SEND = "send",
+    RECEIVE = "receive",
+    BUY = "buy",
+    KYC = "kyc",
+    TRANSACTIONS = "transactions",
+    ASSETS = "assets",
+    MANAGE_WALLET = "manage-wallet",
+    UNLINK_PROVIDER = "unlink-provider",
+    SECURITY = "security",
+    KEYSARE_BACKUP = "keysare-backup",
+    KEYSHARE_RESTORE = "keyshare-restore",
+    CHAIN = "chain",
+    CHAIN_SWITCH_REQUEST = "chain-switch-request",
+    NICKNAME_SETTINGS = "nickname-settings",
+    DEVICES = "devices",
+    DEVICE_LINK = "device-link",
+    DEVICE_MANAGE = "device-manage",
+    DEVICE_RESTORE = "device-restore"
+}
+/** WIP: need to develop page options typeset, i.e options: AuthOpenOptions | BuyOpenOption etc  */
+interface PageOpenParams {
+    key: PageKey;
+    [option: string]: unknown;
+}
+
+/**
+ * Hook to programmatically open the dialogs
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isOpen, open, close } = useOpenPage();
+ *
+ *   return (
+ *     <button onClick={() => open(PageKey.BUY, { amount: 10 })}>
+ *       Buy CRYPTO
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useOpenPage(): {
+    readonly open: (passportPage: PageKey, params?: PageOpenParams) => void;
+    readonly close: () => void;
+    readonly isOpen: boolean;
+};
+
+type ColorMode = 'light' | 'dark';
+
+declare function useColorMode(): {
+    colorMode: ColorMode;
+    setColorMode: (mode: ColorMode) => void;
+};
+
+declare const buttonVariants: (props?: {
+    variant?: "default" | "outline" | "ghost";
+    size?: "small" | "large" | "medium" | "icon";
+} & class_variance_authority_types.ClassProp) => string;
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+
+/** EmbarkAI Color Mode Switcher */
+declare function ThemeToggle(props: ButtonProps): react_jsx_runtime.JSX.Element;
+
+/** EmbarkAI Language Switcher */
+declare function LangToggle(props: ButtonProps): react_jsx_runtime.JSX.Element;
+
+type ChainLike$2 = {
+    id: number;
+    blockExplorers?: {
+        default?: {
+            url: string;
+        };
+    };
+};
+type UserOpStatusProps = {
+    userOpHash: `0x${string}` | string;
+    chain?: ChainLike$2;
+    chainId?: number;
+    className?: string;
+    pollMs?: number;
+    maxPollTimeMs?: number;
+    externalState?: {
+        receipt?: any | null;
+        mempool?: any | null;
+        error?: string | null;
+        isPolling?: boolean;
+    };
+};
+declare const UserOpStatus: React$1.FC<UserOpStatusProps>;
+
+type ChainLike$1 = {
+    id: number;
+    blockExplorers?: {
+        default?: {
+            url: string;
+        };
+    };
+};
+type HashProps = {
+    hash?: `0x${string}` | string | null;
+    chain?: ChainLike$1;
+    className?: string;
+    truncate?: boolean;
+    showCopy?: boolean;
+    showExplorer?: boolean;
+    kind?: 'tx' | 'address' | 'block';
+    label?: string;
+};
+declare const Hash: React$1.FC<HashProps>;
+
+type ChainLike = {
+    id: number;
+    blockExplorers?: {
+        default?: {
+            url: string;
+        };
+    };
+};
+type AddressProps = {
+    address?: `0x${string}` | string | null;
+    chain?: ChainLike;
+    className?: string;
+    truncate?: boolean;
+    showCopy?: boolean;
+    showExplorer?: boolean;
+    label?: string;
+};
+declare const Address: React$1.FC<AddressProps>;
+
+interface TransactionsListProps {
+    address: string;
+    itemsCount?: number;
+}
+declare const TransactionsList: React__default.FC<TransactionsListProps>;
+
+declare function KeyshareBackupMenu(): react_jsx_runtime.JSX.Element;
+
+interface RecoveryStatsDeviceEntry {
+    deviceId: string;
+    name?: string;
+    count: number;
+    lastAt: string;
+    ip?: string;
+    ua?: string;
+    secChUa?: string;
+    browser?: string;
+}
+interface RecoveryStatsCreatedMeta {
+    at: string;
+    ip?: string;
+    ua?: string;
+    secChUa?: string;
+    browser?: string;
+    deviceId?: string;
+    deviceName?: string;
+    country?: string;
+    encryptionMethod?: 'passkey' | 'password';
+}
+interface RecoveryStats {
+    created: RecoveryStatsCreatedMeta;
+    devices: RecoveryStatsDeviceEntry[];
+}
+declare function getShareRecoveryStats(): Promise<RecoveryStats | null>;
+
+interface SendTransactionParams$1 {
+    to: `0x${string}`;
+    value: string;
+    data?: `0x${string}`;
+    assetType?: AssetType;
+    tokenAddress?: `0x${string}`;
+    tokenId?: string;
+    decimals?: number;
+}
+interface UseSendTransactionReturn {
+    sendTransaction: (params: SendTransactionParams$1) => Promise<string | null>;
+    isLoading: boolean;
+    error: string | null;
+    userOpHash: string | null;
+    reset: () => void;
+}
+declare function useSendTransaction(): UseSendTransactionReturn;
+
+interface UserOpMempool {
+    entryPoint: `0x${string}` | null;
+    sender: `0x${string}` | null;
+}
+type UserOpState = 'waiting' | 'pending' | 'included' | 'failed' | 'rejected' | 'timeout';
+interface UseUserOpStatusOptions {
+    userOpHash?: `0x${string}` | string | null;
+    pollMs?: number;
+    maxPollTimeMs?: number;
+    enabled?: boolean;
+    onStateChange?: (state: UserOpState) => void;
+    onReceipt?: (receipt: UserOperationReceipt) => void;
+    onTxHash?: (txHash: `0x${string}`) => void;
+}
+interface UseUserOpStatusReturn {
+    state: UserOpState;
+    receipt: UserOperationReceipt | null;
+    mempool: UserOpMempool | null;
+    txHash: `0x${string}` | null;
+    error: string | null;
+    isPolling: boolean;
+    refresh: () => Promise<void>;
+}
+declare function useUserOpStatus(options?: UseUserOpStatusOptions): UseUserOpStatusReturn;
+
+interface UseErc3643ComplianceOptions {
+    /** Token contract address */
+    tokenAddress: Address$1 | undefined;
+    /** Recipient address */
+    to: Address$1 | undefined;
+    /** Amount to transfer (as bigint) */
+    amount: bigint | undefined;
+    /** Whether to enable the query */
+    enabled?: boolean;
+    /** Chain ID to use for the query */
+    chainId?: number;
+}
+interface UseErc3643ComplianceResult {
+    /** Whether the transfer is allowed */
+    canTransfer: boolean | undefined;
+    /** Whether the query is loading */
+    isLoading: boolean;
+    /** Error message if compliance check failed */
+    error: string | null;
+    /** Refetch the compliance status */
+    refetch: () => void;
+}
+/**
+ * Hook to check ERC3643 (Security Token) transfer compliance.
+ *
+ * ERC3643 tokens have compliance requirements that must be met before transfers.
+ * This hook calls the `canTransfer` function on the token contract to verify
+ * if a transfer is allowed.
+ *
+ * @example
+ * ```tsx
+ * const { canTransfer, isLoading, error } = useErc3643Compliance({
+ *   tokenAddress: '0x...',
+ *   to: recipientAddress,
+ *   amount: parseUnits('100', 18),
+ *   enabled: selectedAsset?.type === 'erc3643'
+ * });
+ *
+ * if (!canTransfer) {
+ *   // Show compliance error
+ * }
+ * ```
+ */
+declare function useErc3643Compliance(options: UseErc3643ComplianceOptions): UseErc3643ComplianceResult;
+
+interface UseWalletModeReturn {
+    /** Currently configured mode from provider config */
+    configMode: WalletMode;
+    /** Currently active mode (relevant when configMode='both') */
+    activeMode: WalletMode;
+    /** Switch active mode (only works when configMode='both') */
+    switchMode: (mode: 'linked' | 'direct') => void;
+    /** Whether the current active mode uses direct EOA signing */
+    isDirect: boolean;
+}
+declare function useWalletMode(): UseWalletModeReturn;
+
+interface UseDirectWalletReturn {
+    /** Connected external wallet address */
+    address: `0x${string}` | null;
+    /** Chain ID the external wallet is on */
+    chainId: number | null;
+    /** Whether external wallet is connected */
+    isConnected: boolean;
+    /** Wallet connector name (e.g. 'MetaMask') */
+    connectorName: string | null;
+    /** Connect + link: opens RainbowKit modal, signs, calls linkWallet API */
+    connect: () => void;
+    /** Reconnect only: opens RainbowKit modal to restore wagmi session (no re-linking) */
+    reconnect: () => void;
+    /** Disconnect the external wallet */
+    disconnect: () => void;
+}
+declare function useDirectWallet(): UseDirectWalletReturn;
+
+interface DirectTransactionParams {
+    to: `0x${string}`;
+    /** Amount in human-readable native currency units (e.g. '1.5' for 1.5 ETH), not wei */
+    value: string;
+    data?: `0x${string}`;
+    chainId?: number;
+}
+interface UseSendDirectTransactionReturn {
+    sendTransaction: (params: DirectTransactionParams) => Promise<`0x${string}` | null>;
+    isPending: boolean;
+    error: string | null;
+    txHash: `0x${string}` | null;
+    reset: () => void;
+}
+declare function useSendDirectTransaction(): UseSendDirectTransactionReturn;
+
+interface TransferToLinkedParams {
+    /** Token contract address, or 'native' for native currency */
+    token: `0x${string}` | 'native';
+    /** Human-readable amount (e.g. '1.5', '1000') */
+    amount: string;
+    /** Chain ID — transfer only works within same chain */
+    chainId: number;
+    /** Token decimals (default: 18). Required for ERC20 tokens */
+    decimals?: number;
+    /** Target linked wallet address. If omitted, uses first linked wallet */
+    toAddress?: `0x${string}`;
+}
+interface UseTransferToLinkedReturn {
+    transfer: (params: TransferToLinkedParams) => Promise<string | null>;
+    isPending: boolean;
+    error: string | null;
+    userOpHash: string | null;
+    /** List of linked wallet addresses from profile */
+    linkedWallets: `0x${string}`[];
+    reset: () => void;
+}
+declare function useTransferToLinkedWallet(): UseTransferToLinkedReturn;
+
+interface AuthProviderMeta extends Record<string, unknown> {
+    walletName?: string;
+    walletType?: string;
+    chainId?: number;
+    email?: string;
+}
+interface AuthProvider {
+    provider: 'passkey' | 'email' | 'telegram' | 'google' | 'discord' | 'twitter' | 'wallet';
+    verified: boolean;
+    linkedAt: string;
+    lastUsedAt?: string;
+    externalId: string;
+    meta?: AuthProviderMeta;
+}
+
+declare function fetchProjectName(projectId: string): Promise<string>;
+
+declare function useNativeWalletSignature(): {
+    signMessage: wagmi.UseSignMessageReturnType<unknown>;
+    /** EIP-712 signature */
+    signTypedMessage: wagmi.UseSignTypedDataReturnType<unknown>;
+    fetchProjectNameById: typeof fetchProjectName;
+};
+
+interface UseLogoutReturn {
+    logout: () => Promise<void>;
+}
+/**
+ * Hook for logging out and disconnecting from EmbarkAI
+ * Clears session, tokens, and notifies callbacks
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { logout } = useLogout();
+ *
+ *   return (
+ *     <button onClick={logout}>
+ *       Disconnect
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useLogout(): UseLogoutReturn;
+
+/**
+ * Nickname fingerprint verification utilities
+ * Implements client-side verification per FRD spec
+ *
+ * IMPORTANT: Client MUST NOT trust server blindly.
+ * Always verify fingerprint locally before displaying to user.
+ */
+/**
+ * Generate fingerprint from owner address
+ * Must match backend algorithm exactly
+ *
+ * Algorithm:
+ * 1. Normalize address to checksum format
+ * 2. Compute keccak256 hash
+ * 3. Take first 5 bytes (40 bits)
+ * 4. Encode using Base32 alphabet
+ * 5. Format as XXXX-XXXX
+ *
+ * @param ownerAddress - The EOA owner address
+ * @returns Fingerprint in format "XXXX-XXXX"
+ */
+declare function generateFingerprint(ownerAddress: string): string;
+/**
+ * Verify that received fingerprint matches computed fingerprint
+ *
+ * @param ownerAddress - The owner address from API response
+ * @param receivedFingerprint - The fingerprint from API response
+ * @returns true if fingerprint is valid, false if verification failed
+ */
+declare function verifyFingerprint(ownerAddress: string, receivedFingerprint: string): boolean;
+/**
+ * Fingerprint verification result
+ */
+interface FingerprintVerificationResult {
+    isValid: boolean;
+    computedFingerprint: string | null;
+    receivedFingerprint: string | null;
+    error?: string;
+}
+/**
+ * Verify fingerprint with detailed result
+ * Use this for UI display of verification status
+ *
+ * @param ownerAddress - The owner address from API response
+ * @param receivedFingerprint - The fingerprint from API response
+ * @returns Detailed verification result
+ */
+declare function verifyFingerprintDetailed(ownerAddress: string | null, receivedFingerprint: string | null): FingerprintVerificationResult;
+
+/**
+ * Nickname API types
+ * Types for nickname-related API responses and requests
+ */
+/**
+ * Detailed nickname information
+ * Returned by GET /api/auth/nickname
+ */
+interface NicknameInfo {
+    handle: string;
+    displayHandle: string;
+    createdAt: string;
+    changedAt: string | null;
+    changeCount: number;
+    canChange: boolean;
+    cooldownEndsAt: string | null;
+}
+/**
+ * Result of changing nickname
+ * Returned by PUT /api/auth/nickname
+ */
+interface NicknameChangeResult {
+    handle: string;
+    displayHandle: string;
+    previousHandle: string;
+    isFirstChange: boolean;
+}
+/**
+ * Nickname availability check result
+ * Returned by GET /api/auth/nicknames/{handle}/check
+ */
+interface NicknameAvailability {
+    handle: string;
+    available: boolean;
+    reason?: NicknameUnavailableReason;
+}
+type NicknameUnavailableReason = 'TAKEN' | 'RESERVED' | 'TOO_SHORT' | 'TOO_LONG' | 'INVALID_CHARS' | 'INVALID_UNDERSCORE';
+/**
+ * Resolved target for a specific chain
+ */
+interface NicknameResolvedTarget {
+    chainId: number;
+    wallet: `0x${string}`;
+}
+/**
+ * Avatar information for nickname resolution
+ */
+interface NicknameAvatar {
+    type: 'deterministic-circles';
+    seed: string;
+}
+/**
+ * Nickname to wallet address resolution (v2)
+ * Returned by POST /api/auth/nicknames/resolve
+ */
+interface NicknameResolution {
+    handle: string;
+    requestedChainId: number;
+    resolvedTarget: NicknameResolvedTarget | null;
+    availableTargets: NicknameResolvedTarget[];
+    owner: `0x${string}` | null;
+    fingerprint: string | null;
+    avatar: NicknameAvatar | null;
+    avatarSvg: string | null;
+    isFrozen: boolean;
+}
+/**
+ * Request body for resolving nickname (v2)
+ */
+interface NicknameResolveRequest {
+    handle: string;
+    chainId: number;
+}
+/**
+ * Client-side nickname validation result
+ */
+interface NicknameValidationResult {
+    valid: boolean;
+    error?: NicknameValidationError;
+}
+type NicknameValidationError = 'TOO_SHORT' | 'TOO_LONG' | 'INVALID_CHARS' | 'INVALID_UNDERSCORE';
+
+/**
+ * useNicknameResolve hook
+ * Public hook for resolving nicknames to wallet addresses with verification
+ */
+
+interface UseNicknameResolveResult {
+    data: NicknameResolution | undefined;
+    isLoading: boolean;
+    isResolving: boolean;
+    isError: boolean;
+    isNotFound: boolean;
+    isWalletNotSetup: boolean;
+    isFrozen: boolean;
+    isFingerprintVerified: boolean;
+    fingerprintVerification: FingerprintVerificationResult | null;
+    error: Error | null;
+    resolvedAddress: string | null;
+}
+/**
+ * Detect if input looks like a nickname (vs an address)
+ * - Starts with @ or contains only lowercase a-z, 0-9, underscore
+ * - Does not start with 0x
+ */
+declare function looksLikeNickname(input: string): boolean;
+interface UseNicknameResolveOptions {
+    enabled?: boolean;
+    chainId: number;
+}
+/**
+ * Hook to resolve a nickname to a wallet address with verification
+ *
+ * - Debounces API calls by 300ms
+ * - Only resolves when input looks like a nickname
+ * - Verifies fingerprint locally before returning data (MANDATORY)
+ * - Returns resolved address when found and verified
+ *
+ * @param input - The recipient input (can be address or nickname)
+ * @param options - Resolution options including chainId (required) and enabled flag
+ * @returns Resolution data, loading states, error state, verification status, resolved address
+ */
+declare function useNicknameResolve(input: string, options: UseNicknameResolveOptions): UseNicknameResolveResult;
+
+/**
+ * Get UserOperation data by hash
+ */
+
+/**
+ * UserOperation data from bundler response
+ */
+interface UserOperationByHash {
+    /** EntryPoint address */
+    entryPoint: `0x${string}`;
+    /** User operation details */
+    userOperation: {
+        sender: `0x${string}`;
+        nonce: `0x${string}`;
+        callData: `0x${string}`;
+        callGasLimit: `0x${string}`;
+        verificationGasLimit: `0x${string}`;
+        preVerificationGas: `0x${string}`;
+        maxPriorityFeePerGas: `0x${string}`;
+        maxFeePerGas: `0x${string}`;
+        paymaster?: `0x${string}`;
+        paymasterVerificationGasLimit?: `0x${string}`;
+        paymasterPostOpGasLimit?: `0x${string}`;
+        paymasterData?: `0x${string}`;
+        signature: `0x${string}`;
+    };
+    /** Transaction hash (null if not yet included in block) */
+    transactionHash: `0x${string}` | null;
+    /** Block number (null if not yet included in block) */
+    blockNumber: `0x${string}` | null;
+    /** Block hash (null if not yet included in block) */
+    blockHash: `0x${string}` | null;
+}
+/**
+ * Get UserOperation data by hash
+ *
+ * Automatically uses active chain from UI unless chainId is specified.
+ * Returns null if UserOp is not found.
+ *
+ * @param userOpHash - UserOperation hash returned from sendUserOperation
+ * @param chainId - Optional chain ID (defaults to active chain)
+ * @returns UserOperation data if found, null if not found
+ * @throws {Error} If chain has no bundlerUrl configured
+ *
+ * @example
+ * ```typescript
+ * const hash = await sendUserOperation(session, { ... })
+ * const userOp = await getUserOperationByHash(hash)
+ * ```
+ */
+declare function getUserOperationByHash(userOpHash: Hash$1 | string, chainId?: number): Promise<UserOperationByHash | null>;
+
+/**
+ * Get UserOperation receipt by hash
+ */
+
+/**
+ * UserOperation receipt
+ *
+ * Contains execution details after UserOp is included in a block
+ */
+interface UserOperationReceipt {
+    /** UserOperation hash */
+    userOpHash: Hash$1;
+    /** EntryPoint address that processed this UserOp */
+    entryPoint: `0x${string}`;
+    /** Sender (smart account) address */
+    sender: `0x${string}`;
+    /** Nonce used for this UserOp */
+    nonce: `0x${string}`;
+    /** True if UserOp succeeded, false if reverted */
+    success: boolean;
+    /** Actual gas cost paid */
+    actualGasCost: `0x${string}`;
+    /** Actual gas used */
+    actualGasUsed: `0x${string}`;
+    /** Paymaster address (if used) */
+    paymaster?: `0x${string}`;
+    /** Transaction receipt */
+    receipt: {
+        transactionHash: Hash$1;
+        blockNumber: `0x${string}`;
+        blockHash: Hash$1;
+        [key: string]: any;
+    };
+    /** Logs emitted during execution */
+    logs?: any[];
+    /** Revert reason, if unsuccessful */
+    reason?: string;
+}
+/**
+ * Get UserOperation receipt by hash
+ *
+ * Automatically uses active chain from UI unless chainId is specified.
+ * Returns null if UserOp is still pending or not found.
+ *
+ * @param userOpHash - UserOperation hash returned from sendUserOperation
+ * @param chainId - Optional chain ID (defaults to active chain)
+ * @returns Receipt if found and mined, null if pending or not found
+ * @throws {Error} If chain has no bundlerUrl configured
+ *
+ * @example
+ * ```typescript
+ * const hash = await sendUserOperation(session, { ... })
+ * const receipt = await getUserOperationReceipt(hash)
+ * if (receipt?.success) {
+ *   console.log('Gas used:', receipt.actualGasUsed)
+ * }
+ * ```
+ */
+declare function getUserOperationReceipt(userOpHash: Hash$1 | string, chainId?: number): Promise<UserOperationReceipt | null>;
+
+/**
+ * Wait for UserOperation receipt with polling
+ */
+
+/**
+ * Options for waiting for UserOperation receipt
+ */
+interface WaitForReceiptOptions {
+    /**
+     * Polling interval in milliseconds
+     * @default 1000 (1 second)
+     */
+    pollIntervalMs?: number;
+    /**
+     * Maximum wait time in milliseconds
+     * @default 60000 (60 seconds)
+     */
+    maxPollTimeMs?: number;
+    /**
+     * Chain ID (optional)
+     * If not provided, uses activeChainId from UI state.
+     */
+    chainId?: number;
+}
+/**
+ * Thrown when waitForUserOperationReceipt exceeds maxPollTimeMs
+ */
+declare class UserOperationTimeoutError extends Error {
+    userOpHash: Hash$1;
+    chainId: number;
+    timeoutMs: number;
+    constructor(userOpHash: Hash$1, chainId: number, timeoutMs: number);
+}
+/**
+ * Wait for UserOperation receipt with automatic polling
+ *
+ * Polls bundler until receipt is available or timeout is reached.
+ * Automatically uses active chain from UI unless chainId is specified in options.
+ *
+ * @param userOpHash - UserOperation hash returned from sendUserOperation
+ * @param options - Polling configuration and optional chainId
+ * @returns Receipt once UserOp is mined
+ * @throws {UserOperationTimeoutError} If timeout is exceeded before receipt is available
+ * @throws {Error} If chain has no bundlerUrl configured
+ *
+ * @example
+ * ```typescript
+ * const hash = await sendUserOperation(session, { to, value, data })
+ * const receipt = await waitForUserOperationReceipt(hash)
+ * if (receipt.success) {
+ *   console.log('TxHash:', receipt.receipt.transactionHash)
+ * }
+ * ```
+ */
+declare function waitForUserOperationReceipt(userOpHash: Hash$1, options?: WaitForReceiptOptions): Promise<UserOperationReceipt>;
+
+declare global {
+    interface Window {
+        __EMBARK_CONDITIONAL_UI_ACTIVE__?: boolean;
+    }
+}
+
+/**
+ * Provider information in user profile
+ * Matches the structure returned by backend /api/auth/profile
+ */
+interface ProviderDetail {
+    id: string;
+    provider: string;
+    verified: boolean;
+    linkedAt: string;
+    lastUsedAt: string;
+    externalId: string;
+    meta?: Record<string, any>;
+}
+/**
+ * User profile information
+ * Extended to include nickname fields from backend
+ */
+interface UserProfile {
+    userId: string;
+    displayName?: string;
+    avatar?: string;
+    providers: ProviderDetail[];
+    createdAt: string;
+    updatedAt: string;
+    hasKeyshare: boolean;
+    kycDetails: {
+        provider: 'sumsub' | 'uaepass' | 'custom';
+        kycStatus: string;
+    } | null;
+    nickname: string | null;
+    nicknameDisplay: string | null;
+    nicknameCanChange: boolean;
+    nicknameCooldownEndsAt: string | null;
+}
+interface UpdateProfileRequest {
+    displayName?: string;
+}
+/**
+ * Get user profile with detailed provider information
+ *
+ * Backend /api/auth/profile now returns complete provider details including:
+ * - Provider type and identifier
+ * - Verification status
+ * - Linked and last used timestamps
+ * - Provider-specific metadata
+ */
+declare function getUserProfile(): Promise<UserProfile>;
+/**
+ * Update user profile
+ */
+declare function updateUserProfile(updates: UpdateProfileRequest): Promise<UserProfile>;
+
+interface ConnectedApp {
+    projectId: string;
+    name: string;
+    appUrl: string | null;
+    logo: string;
+    domains: unknown;
+    providers: unknown;
+    smartWalletAddress: string;
+    firstConnectedAt: string;
+    lastActiveAt: string;
+}
+
+declare function useConnectedApps(): _tanstack_react_query.UseQueryResult<ConnectedApp[], Error>;
+declare function useKeyshareRecoveryStats(): _tanstack_react_query.UseQueryResult<{
+    keyshareInfo: {
+        hasKeyshare: boolean;
+        ownerAddress?: `0x${string}`;
+        sessionId?: string;
+        keyshareSize?: number;
+    };
+    shareRecoveryStats: RecoveryStats;
+}, Error>;
+
+interface LinkedProfileDisplay extends AuthProvider {
+    displayName: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    color?: string;
+}
+declare function useLinkedProfiles(): {
+    profiles: LinkedProfileDisplay[];
+    avatar: string;
+    isLoading: boolean;
+    error: Error;
+    refresh: () => Promise<void>;
+};
+
+/**
+ * Custom error types for EmbarkAI operations
+ */
+/**
+ * Base error class for all EmbarkAI errors
+ * Local copy to avoid @embarkai/core dependency in iframe bundle
+ */
+declare class AccountAbstractionError extends Error {
+    /** Machine-readable error code for programmatic handling */
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * Error thrown when user rejects a transaction or signature request
+ */
+declare class UserRejectedError extends AccountAbstractionError {
+    static readonly CODE: "USER_REJECTED";
+    constructor(message?: string);
+}
+/**
+ * Error codes for EmbarkAI operations
+ */
+declare const ErrorCodes: {
+    readonly MPC_SIGNING_ERROR: "MPC_SIGNING_ERROR";
+    readonly USER_REJECTED: "USER_REJECTED";
+};
+/**
+ * Create appropriate error from error code
+ * Used to reconstruct errors from iframe postMessage
+ */
+declare function createAccountAbstractionError(params: {
+    message: string;
+    code?: string;
+}): Error;
+
+/**
+ * Wagmi config for RainbowKit and wallet connections.
+ * Note: Balance fetching uses dynamic publicClient from session store,
+ * so chains don't need to be listed here for balance queries.
+ */
+declare const wagmiConfig: wagmi.Config<readonly [viem.Chain, viem.Chain], {
+    [lumiaTestnetChain.id]: viem.HttpTransport<undefined, false> | viem.FallbackTransport<viem.HttpTransport<undefined, false>[]>;
+    [lumiaMainnetChain.id]: viem.HttpTransport<undefined, false> | viem.FallbackTransport<viem.HttpTransport<undefined, false>[]>;
+}, readonly wagmi.CreateConnectorFn[]>;
+
+declare function getExplorerUrl(): string;
+
+/**
+ * Hook for fetching all assets from Blockscout API
+ */
+
+interface UseBlockscoutAssetsOptions {
+    /** Wallet address to query */
+    address: Address$1 | undefined;
+    /** Whether to enable the query (default: true when address provided) */
+    enabled?: boolean;
+    /** Whether to detect ERC3643 security tokens (default: true) */
+    detectSecurityTokens?: boolean;
+}
+interface UseBlockscoutAssetsResult {
+    /** Native token balance (always available via RPC) */
+    nativeBalance: {
+        value: bigint;
+        formatted: string;
+        symbol: string;
+    } | null;
+    /** All discovered assets (native + tokens + NFTs) */
+    assets: Asset[];
+    /** Whether any data is currently loading */
+    isLoading: boolean;
+    /** Whether initial load is in progress */
+    isInitialLoading: boolean;
+    /** Error from Blockscout API (null if native balance available) */
+    error: AssetListError | null;
+    /** Whether Blockscout API is reachable */
+    isBlockscoutAvailable: boolean;
+    /** Manually refresh all balances */
+    refreshBalances: () => Promise<void>;
+    /** Get balance for a specific token by address */
+    getTokenBalance: (tokenAddress: Address$1) => Asset | null;
+    /** Timestamp of last successful fetch */
+    lastUpdated: number | null;
+}
+/**
+ * React hook for fetching all assets from Blockscout API
+ *
+ * @example
+ * ```tsx
+ * const { assets, isLoading, error, refreshBalances } = useBlockscoutAssets({
+ *   address: '0x...',
+ * });
+ * ```
+ */
+declare function useBlockscoutAssets(options: UseBlockscoutAssetsOptions): UseBlockscoutAssetsResult;
+
+interface Transaction {
+    hash: Hash$1;
+    from: string;
+    to: string | null;
+    value: string;
+    gasUsed: string;
+    gasPrice: string;
+    blockNumber: bigint;
+    timestamp: number;
+    status: 'success' | 'failed' | 'pending';
+}
+interface SendTransactionParams {
+    to: `0x${string}`;
+    value: string;
+    data?: `0x${string}`;
+}
+interface SendTransactionResult {
+    hash: Hash$1;
+    wait: () => Promise<TransactionReceipt>;
+}
+declare function useTransactions(): {
+    sendTransaction: (params: SendTransactionParams) => Promise<SendTransactionResult>;
+    getTransaction: (hash: Hash$1) => Promise<{
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        hash: Hash$1;
+        v: bigint;
+        r: viem.Hex;
+        type: "legacy";
+        to: viem.Address | null;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        blobVersionedHashes?: undefined;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        accessList?: undefined;
+        authorizationList?: undefined;
+        yParity?: undefined;
+        typeHex: viem.Hex | null;
+        chainId?: number;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        hash: Hash$1;
+        v: bigint;
+        r: viem.Hex;
+        type: "eip2930";
+        to: viem.Address | null;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        blobVersionedHashes?: undefined;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        yParity: number;
+        typeHex: viem.Hex | null;
+        chainId: number;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        hash: Hash$1;
+        v: bigint;
+        r: viem.Hex;
+        type: "eip1559";
+        to: viem.Address | null;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        blobVersionedHashes?: undefined;
+        gasPrice?: undefined;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        yParity: number;
+        typeHex: viem.Hex | null;
+        chainId: number;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        hash: Hash$1;
+        v: bigint;
+        r: viem.Hex;
+        type: "eip4844";
+        to: viem.Address | null;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        blobVersionedHashes: readonly viem.Hex[];
+        gasPrice?: undefined;
+        maxFeePerBlobGas: bigint;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        yParity: number;
+        typeHex: viem.Hex | null;
+        chainId: number;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        hash: Hash$1;
+        v: bigint;
+        r: viem.Hex;
+        type: "eip7702";
+        to: viem.Address | null;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        blobVersionedHashes?: undefined;
+        gasPrice?: undefined;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        accessList: viem.AccessList;
+        authorizationList: viem.SignedAuthorizationList;
+        yParity: number;
+        typeHex: viem.Hex | null;
+        chainId: number;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    }>;
+    getTransactionReceipt: (hash: Hash$1) => Promise<TransactionReceipt>;
+    getTransactionHistory: (address: `0x${string}`, limit?: number) => Promise<Transaction[]>;
+    address: `0x${string}`;
+    isConnected: boolean;
+};
+
+interface UserOperation {
+    hash: Hash$1;
+    sender: `0x${string}`;
+    nonce: bigint;
+    success: boolean;
+    actualGasCost: bigint;
+    blockNumber: bigint;
+    timestamp: number;
+    transactionHash: Hash$1;
+}
+declare function useSmartAccountTransactions(): {
+    getUserOperations: (address: `0x${string}`, fromBlock?: bigint | "earliest", toBlock?: bigint | "latest") => Promise<UserOperation[]>;
+    getRecentUserOperations: (address: `0x${string}`, limit?: number) => Promise<UserOperation[]>;
+    getTransactionDetails: (txHash: Hash$1) => Promise<{
+        transaction: {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            hash: Hash$1;
+            v: bigint;
+            r: viem.Hex;
+            type: "legacy";
+            to: viem.Address | null;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            blobVersionedHashes?: undefined;
+            gasPrice: bigint;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            accessList?: undefined;
+            authorizationList?: undefined;
+            yParity?: undefined;
+            typeHex: viem.Hex | null;
+            chainId?: number;
+            blockNumber: bigint;
+            blockHash: `0x${string}`;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            hash: Hash$1;
+            v: bigint;
+            r: viem.Hex;
+            type: "eip2930";
+            to: viem.Address | null;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            blobVersionedHashes?: undefined;
+            gasPrice: bigint;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            yParity: number;
+            typeHex: viem.Hex | null;
+            chainId: number;
+            blockNumber: bigint;
+            blockHash: `0x${string}`;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            hash: Hash$1;
+            v: bigint;
+            r: viem.Hex;
+            type: "eip1559";
+            to: viem.Address | null;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            blobVersionedHashes?: undefined;
+            gasPrice?: undefined;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            yParity: number;
+            typeHex: viem.Hex | null;
+            chainId: number;
+            blockNumber: bigint;
+            blockHash: `0x${string}`;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            hash: Hash$1;
+            v: bigint;
+            r: viem.Hex;
+            type: "eip4844";
+            to: viem.Address | null;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            blobVersionedHashes: readonly viem.Hex[];
+            gasPrice?: undefined;
+            maxFeePerBlobGas: bigint;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            yParity: number;
+            typeHex: viem.Hex | null;
+            chainId: number;
+            blockNumber: bigint;
+            blockHash: `0x${string}`;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            hash: Hash$1;
+            v: bigint;
+            r: viem.Hex;
+            type: "eip7702";
+            to: viem.Address | null;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            blobVersionedHashes?: undefined;
+            gasPrice?: undefined;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: viem.AccessList;
+            authorizationList: viem.SignedAuthorizationList;
+            yParity: number;
+            typeHex: viem.Hex | null;
+            chainId: number;
+            blockNumber: bigint;
+            blockHash: `0x${string}`;
+            transactionIndex: number;
+        };
+        receipt: viem.TransactionReceipt;
+    }>;
+};
+
+/**
+ * Passport translations object.
+ * Note: For use in combineI18NResources, translations are imported directly
+ * in utils.ts to avoid esbuild lazy initialization issues.
+ */
+declare const PASSPORT_TRANSLATIONS: {
+    en: {
+        passport: {
+            common: {
+                create: string;
+                add: string;
+                added: string;
+                edit: string;
+                confirm: string;
+                purchase: string;
+                buy: string;
+                save: string;
+                saved: string;
+                delete: string;
+                download: string;
+                cancel: string;
+                close: string;
+                copy: string;
+                back: string;
+                language: string;
+                account: string;
+                asset: string;
+                amount: string;
+                balance: string;
+                continue: string;
+                network: string;
+                fingerprint: string;
+                from: string;
+                to: string;
+                hide: string;
+                show: string;
+                received: string;
+                sent: string;
+                created: string;
+                settings: string;
+                password: string;
+                passkey: string;
+                standard: string;
+                advanced: string;
+                next: string;
+                prev: string;
+                errors: {
+                    oops: string;
+                };
+            };
+            auth: {
+                signin: string;
+                logout: string;
+                backToSignIn: string;
+                orSeparator: string;
+                email: {
+                    placeholder: string;
+                };
+                verification: {
+                    title: string;
+                    sentTo: string;
+                    codeExpires: string;
+                    didntReceive: string;
+                    resend: string;
+                };
+                social: {
+                    comingSoonMessage: string;
+                };
+                wallet: {
+                    label: string;
+                };
+                passkey: {
+                    label: string;
+                    title: string;
+                    signInExisting: string;
+                    dontHave: string;
+                    create: string;
+                };
+                terms: {
+                    text: string;
+                    action: string;
+                };
+            };
+            main: {
+                send: string;
+                receive: string;
+                buy: string;
+                assets: string;
+            };
+            sendMenu: {
+                title: string;
+                selectAsset: string;
+                confirmStep: string;
+                sendNft: string;
+                recipient: string;
+                pendingStep: string;
+                pendingStepMsg: string;
+            };
+            receiveMenu: {
+                title: string;
+                copyAddress: string;
+                warning: string;
+                share: string;
+            };
+            buyMenu: {
+                title: string;
+                provider: string;
+                selectProvider: string;
+                selectCrypto: string;
+                selectFiat: string;
+                selectPaymentMode: string;
+                enterAmount: string;
+                purchaseSummary: string;
+                summary: {
+                    youPay: string;
+                    youReceive: string;
+                    exchangeRate: string;
+                    networkFee: string;
+                    serviceFee: string;
+                    paymentMethod: string;
+                };
+                transactionHistory: {
+                    details: string;
+                };
+                noItems: {
+                    noTransactions: string;
+                    noPaymentModes: string;
+                    noCryptoForChain: string;
+                };
+                inputPlaceholder: {
+                    selectCurrencies: string;
+                    providerMin: string;
+                };
+            };
+            portfolioMenu: {
+                title: string;
+                noAssets: string;
+            };
+            transactionsMenu: {
+                title: string;
+                noTransactions: string;
+                internalTransactions: string;
+                comingSoon: string;
+            };
+            kycMenu: {
+                title: string;
+            };
+            nicknameMenu: {
+                title: string;
+                yourNickname: string;
+                cooldownMessage: string;
+                lastChanged: string;
+                timesChanged: string;
+                placeholder: string;
+                hint: string;
+                errors: {
+                    tooShort: string;
+                    tooLong: string;
+                    invalidChars: string;
+                    invalidUnderscore: string;
+                    invalidFormat: string;
+                    nicknameTaken: string;
+                    nicknameReserved: string;
+                    cooldownActive: string;
+                    nicknameNotFound: string;
+                    unknown: string;
+                };
+                availability: {
+                    alreadyYourNickname: string;
+                    checkingAvailability: string;
+                    nicknameAvailable: string;
+                    nicknameNotAvailable: string;
+                };
+            };
+            profilesMenu: {
+                title: string;
+                email: {
+                    placeholder: string;
+                    sentTo: string;
+                    warningTitle: string;
+                    warningMsg: string;
+                };
+                passkey: {
+                    message: string;
+                    message2: string;
+                    linking: string;
+                    createOnDevice: string;
+                    createOnSecurityKey: string;
+                };
+                unlinkTitle: string;
+                unlinkConfirm: string;
+                unlinkPlaceholder: string;
+            };
+            securityMenu: {
+                title: string;
+                connectedApps: {
+                    connectedApp: string;
+                    trustedApp: string;
+                    trustedAt: string;
+                    connectedAt: string;
+                    connectedApps: string;
+                    noConnectedApps: string;
+                    untrustApp: string;
+                    removalNoteTitle: string;
+                    removalNoteMsg1: string;
+                    removalNoteMsg2: string;
+                };
+                keyshareStatus: {
+                    title: string;
+                    serverReady: string;
+                    serverMissing: string;
+                    localReady: string;
+                    localMissing: string;
+                    valutBackupCreated: string;
+                    valutBackupMissing: string;
+                };
+                lastBackup: string;
+                lastBackupMeta: string;
+            };
+            backupMenu: {
+                title: string;
+                passwordMsg: string;
+                passkeyMsg: string;
+                passkeyCompleteMsg: string;
+                passkeyAccessMsg: string;
+                passkeyMemo0: string;
+                passkeyMemo1: string;
+                passkeyMemo2: string;
+                passkeyLearnMore: string;
+                vaultRecoveryStatus: string;
+                vaultCreate: string;
+                vaultRestore: string;
+                file: string;
+                fileCreate: string;
+                fileRestore: string;
+                cloud: string;
+            };
+            restoreMenu: {
+                title: string;
+                check: string;
+                noBackups: string;
+                noBackupsMsg1: string;
+                noBackupsMsg2: string;
+                uploadBackupFile: string;
+                restoreWithBackupFile: string;
+                tryAnotherAccount: string;
+            };
+            chainMenu: {
+                title: string;
+                chainSwitchRequest: {
+                    title: string;
+                    description: string;
+                    confirmButton: string;
+                    cancelButton: string;
+                };
+            };
+        };
+    };
+    zh: {
+        passport: {
+            common: {
+                create: string;
+                add: string;
+                added: string;
+                edit: string;
+                confirm: string;
+                purchase: string;
+                buy: string;
+                save: string;
+                saved: string;
+                delete: string;
+                download: string;
+                cancel: string;
+                close: string;
+                copy: string;
+                back: string;
+                language: string;
+                account: string;
+                asset: string;
+                amount: string;
+                balance: string;
+                continue: string;
+                network: string;
+                fingerprint: string;
+                from: string;
+                to: string;
+                hide: string;
+                show: string;
+                received: string;
+                sent: string;
+                created: string;
+                settings: string;
+                password: string;
+                passkey: string;
+                standard: string;
+                advanced: string;
+                next: string;
+                prev: string;
+                errors: {
+                    oops: string;
+                };
+            };
+            auth: {
+                signin: string;
+                logout: string;
+                backToSignIn: string;
+                orSeparator: string;
+                email: {
+                    placeholder: string;
+                };
+                verification: {
+                    title: string;
+                    sentTo: string;
+                    codeExpires: string;
+                    didntReceive: string;
+                    resend: string;
+                };
+                social: {
+                    comingSoonMessage: string;
+                };
+                wallet: {
+                    label: string;
+                };
+                passkey: {
+                    label: string;
+                    title: string;
+                    signInExisting: string;
+                    dontHave: string;
+                    create: string;
+                };
+                terms: {
+                    text: string;
+                    action: string;
+                };
+            };
+            main: {
+                send: string;
+                receive: string;
+                buy: string;
+                assets: string;
+            };
+            sendMenu: {
+                title: string;
+                selectAsset: string;
+                confirmStep: string;
+                sendNft: string;
+                recipient: string;
+                pendingStep: string;
+                pendingStepMsg: string;
+            };
+            receiveMenu: {
+                title: string;
+                copyAddress: string;
+                warning: string;
+                share: string;
+            };
+            buyMenu: {
+                title: any;
+                provider: any;
+                selectProvider: any;
+                selectCrypto: any;
+                selectFiat: any;
+                selectPaymentMode: any;
+                enterAmount: any;
+            };
+            portfolioMenu: {
+                title: string;
+                noAssets: string;
+            };
+            transactionsMenu: {
+                title: string;
+                noTransactions: string;
+                internalTransactions: string;
+                comingSoon: any;
+            };
+            kycMenu: {
+                title: string;
+            };
+            nicknameMenu: {
+                title: string;
+                yourNickname: string;
+                cooldownMessage: string;
+                lastChanged: string;
+                timesChanged: string;
+                placeholder: string;
+                hint: string;
+                errors: {
+                    tooShort: string;
+                    tooLong: string;
+                    invalidChars: string;
+                    invalidUnderscore: string;
+                    invalidFormat: string;
+                    nicknameTaken: string;
+                    nicknameReserved: string;
+                    cooldownActive: string;
+                    nicknameNotFound: string;
+                    unknown: string;
+                };
+                availability: {
+                    alreadyYourNickname: string;
+                    checkingAvailability: string;
+                    nicknameAvailable: string;
+                    nicknameNotAvailable: string;
+                };
+            };
+            profilesMenu: {
+                title: string;
+                email: {
+                    placeholder: string;
+                    sentTo: string;
+                    warningTitle: string;
+                    warningMsg: string;
+                };
+                passkey: {
+                    message: string;
+                    message2: string;
+                    linking: string;
+                    createOnDevice: string;
+                    createOnSecurityKey: string;
+                };
+                unlinkTitle: string;
+                unlinkConfirm: string;
+                unlinkPlaceholder: string;
+            };
+            securityMenu: {
+                title: string;
+                connectedApps: {
+                    connectedApp: string;
+                    trustedApp: string;
+                    trustedAt: string;
+                    connectedAt: string;
+                    connectedApps: string;
+                    noConnectedApps: string;
+                    untrustApp: string;
+                    removalNoteTitle: string;
+                    removalNoteMsg1: string;
+                    removalNoteMsg2: string;
+                };
+                keyshareStatus: {
+                    title: string;
+                    serverReady: string;
+                    serverMissing: string;
+                    localReady: string;
+                    localMissing: string;
+                    valutBackupCreated: string;
+                    valutBackupMissing: string;
+                };
+                lastBackup: string;
+                lastBackupMeta: string;
+            };
+            backupMenu: {
+                title: string;
+                passwordMsg: string;
+                passkeyMsg: string;
+                passkeyCompleteMsg: string;
+                passkeyAccessMsg: string;
+                passkeyMemo0: string;
+                passkeyMemo1: string;
+                passkeyMemo2: string;
+                passkeyLearnMore: string;
+                vaultRecoveryStatus: string;
+                vaultCreate: string;
+                vaultRestore: string;
+                file: string;
+                fileCreate: string;
+                fileRestore: string;
+                cloud: string;
+            };
+            restoreMenu: {
+                title: string;
+                check: string;
+                noBackups: string;
+                noBackupsMsg1: string;
+                noBackupsMsg2: string;
+                uploadBackupFile: string;
+                restoreWithBackupFile: string;
+                tryAnotherAccount: string;
+            };
+            chainMenu: {
+                title: string;
+                chainSwitchRequest: {
+                    title: any;
+                    description: any;
+                    confirmButton: any;
+                    cancelButton: any;
+                };
+            };
+        };
+    };
+    ru: {
+        passport: {
+            common: {
+                create: string;
+                add: string;
+                added: string;
+                edit: string;
+                confirm: string;
+                purchase: string;
+                buy: string;
+                save: string;
+                saved: string;
+                delete: string;
+                download: string;
+                cancel: string;
+                close: string;
+                copy: string;
+                back: string;
+                language: string;
+                account: string;
+                asset: string;
+                amount: string;
+                balance: string;
+                continue: string;
+                network: string;
+                fingerprint: string;
+                from: string;
+                to: string;
+                hide: string;
+                show: string;
+                received: string;
+                sent: string;
+                created: string;
+                settings: string;
+                password: string;
+                passkey: string;
+                standard: string;
+                advanced: string;
+                next: string;
+                prev: string;
+                errors: {
+                    oops: string;
+                };
+            };
+            auth: {
+                signin: string;
+                logout: string;
+                backToSignIn: string;
+                orSeparator: string;
+                email: {
+                    placeholder: string;
+                };
+                verification: {
+                    title: string;
+                    sentTo: string;
+                    codeExpires: string;
+                    didntReceive: string;
+                    resend: string;
+                };
+                social: {
+                    comingSoonMessage: string;
+                };
+                wallet: {
+                    label: string;
+                };
+                passkey: {
+                    label: string;
+                    title: string;
+                    signInExisting: string;
+                    dontHave: string;
+                    create: string;
+                };
+                terms: {
+                    text: string;
+                    action: string;
+                };
+            };
+            main: {
+                send: string;
+                receive: string;
+                buy: string;
+                assets: string;
+            };
+            sendMenu: {
+                title: string;
+                selectAsset: string;
+                confirmStep: string;
+                sendNft: string;
+                recipient: string;
+                pendingStep: string;
+                pendingStepMsg: string;
+            };
+            receiveMenu: {
+                title: string;
+                copyAddress: string;
+                warning: string;
+                share: string;
+            };
+            buyMenu: {
+                title: string;
+                provider: string;
+                selectProvider: string;
+                selectCrypto: string;
+                selectFiat: string;
+                selectPaymentMode: string;
+                enterAmount: string;
+                purchaseSummary: string;
+                summary: {
+                    youPay: string;
+                    youReceive: string;
+                    exchangeRate: string;
+                    networkFee: string;
+                    serviceFee: string;
+                    paymentMethod: string;
+                };
+                transactionHistory: {
+                    details: string;
+                };
+                noItems: {
+                    noTransactions: string;
+                    noPaymentModes: string;
+                    noCryptoForChain: string;
+                };
+                inputPlaceholder: {
+                    selectCurrencies: string;
+                    providerMin: string;
+                };
+            };
+            portfolioMenu: {
+                title: string;
+                noAssets: string;
+            };
+            transactionsMenu: {
+                title: string;
+                noTransactions: string;
+                internalTransactions: string;
+                comingSoon: string;
+            };
+            kycMenu: {
+                title: string;
+            };
+            nicknameMenu: {
+                title: string;
+                yourNickname: string;
+                cooldownMessage: string;
+                lastChanged: string;
+                timesChanged: string;
+                placeholder: string;
+                hint: string;
+                errors: {
+                    tooShort: string;
+                    tooLong: string;
+                    invalidChars: string;
+                    invalidUnderscore: string;
+                    invalidFormat: string;
+                    nicknameTaken: string;
+                    nicknameReserved: string;
+                    cooldownActive: string;
+                    nicknameNotFound: string;
+                    unknown: string;
+                };
+                availability: {
+                    alreadyYourNickname: string;
+                    checkingAvailability: string;
+                    nicknameAvailable: string;
+                    nicknameNotAvailable: string;
+                };
+            };
+            profilesMenu: {
+                title: string;
+                email: {
+                    placeholder: string;
+                    sentTo: string;
+                    warningTitle: string;
+                    warningMsg: string;
+                };
+                passkey: {
+                    message: string;
+                    message2: string;
+                    linking: string;
+                    createOnDevice: string;
+                    createOnSecurityKey: string;
+                };
+                unlinkTitle: string;
+                unlinkConfirm: string;
+                unlinkPlaceholder: string;
+            };
+            securityMenu: {
+                title: string;
+                connectedApps: {
+                    connectedApp: string;
+                    trustedApp: string;
+                    trustedAt: string;
+                    connectedAt: string;
+                    connectedApps: string;
+                    noConnectedApps: string;
+                    untrustApp: string;
+                    removalNoteTitle: string;
+                    removalNoteMsg1: string;
+                    removalNoteMsg2: string;
+                };
+                keyshareStatus: {
+                    title: string;
+                    serverReady: string;
+                    serverMissing: string;
+                    localReady: string;
+                    localMissing: string;
+                    valutBackupCreated: string;
+                    valutBackupMissing: string;
+                };
+                lastBackup: string;
+                lastBackupMeta: string;
+            };
+            backupMenu: {
+                title: string;
+                passwordMsg: string;
+                passkeyMsg: string;
+                passkeyCompleteMsg: string;
+                passkeyAccessMsg: string;
+                passkeyMemo0: string;
+                passkeyMemo1: string;
+                passkeyMemo2: string;
+                passkeyLearnMore: string;
+                vaultRecoveryStatus: string;
+                vaultCreate: string;
+                vaultRestore: string;
+                file: string;
+                fileCreate: string;
+                fileRestore: string;
+                cloud: string;
+            };
+            restoreMenu: {
+                title: string;
+                check: string;
+                noBackups: string;
+                noBackupsMsg1: string;
+                noBackupsMsg2: string;
+                uploadBackupFile: string;
+                restoreWithBackupFile: string;
+                tryAnotherAccount: string;
+            };
+            chainMenu: {
+                title: string;
+                chainSwitchRequest: {
+                    title: string;
+                    description: string;
+                    confirmButton: string;
+                    cancelButton: string;
+                };
+            };
+        };
+    };
+};
+declare const LOCAL_STORAGE_I18N_KEY = "passport-language";
+
+type TranslationResources = Record<string, Record<string, unknown>>;
+/**
+ * Combines project's translation resources with PASSPORT_TRANSLATIONS for i18n initialization
+ * @param resourses - translation resources to merge with PASSPORT_TRANSLATIONS
+ *
+ * resource object structure (passport namespace is MANDATORY):
+ *
+ * ```
+ * {
+ *  language1: {
+ *    passport: {...}
+ *    projectNamespace: {...}
+ *    ...
+ *  },
+ *  language2: {
+ *    passport: {...}
+ *    projectNamespace: {...}
+ *    ...
+ *  },
+ * }
+ * ```
+ */
+declare function combineI18NResources(...resourses: TranslationResources[]): TranslationResources;
+/**
+ * Get list of available language keys from provided translation resources & LP default langset,
+ * returns only languages with 'passport' namespace provided
+ * */
+declare function getAvailableLanguages(resourses: TranslationResources): string[];
+declare function getLanguageIcon(languageKey: string): string | null;
+
+declare const USER_PROFILE_QUERY_KEY: string;
+
+export { AccountAbstractionError, type AccountSession, Address, type AddressProps, type Asset, type CallbacksConfig, ConnectWalletButton, type ConnectWalletButtonProps, type DirectTransactionParams, ErrorCodes, type FingerprintVerificationResult, Hash, type HashProps, KeyshareBackupMenu as KeyshareBackup, LOCAL_STORAGE_I18N_KEY, LangToggle, type NicknameAvailability, type NicknameAvatar, type NicknameChangeResult, type NicknameInfo, type NicknameResolution, type NicknameResolveRequest, type NicknameResolvedTarget, type NicknameValidationResult, PASSPORT_TRANSLATIONS, PageKey, type PageOpenParams, Provider, type ProviderConfig, type ProviderDetail, type ProviderProps, type RegisterSmartAccountResult, type SendTransactionParams, type SendTransactionResult, type SignTypedDataParams, type SmartAccountEntry, ThemeToggle, type TokenBalance, type Transaction, TransactionsList, type TransferToLinkedParams, type TypedDataDomain, type TypedDataField, USER_PROFILE_QUERY_KEY, type UpdateProfileRequest, type UseDirectWalletReturn, type UseErc3643ComplianceOptions, type UseErc3643ComplianceResult, type UseLogoutReturn, type UseNicknameResolveOptions, type UseNicknameResolveResult, type UseSendDirectTransactionReturn, type UseSendTransactionReturn, type UseTransferToLinkedReturn, type UseUserOpStatusOptions, type UseUserOpStatusReturn, type UseWalletModeReturn, type UserOpMempool, type SendTransactionParams$1 as UserOpSendTransactionParams, type UserOpState, UserOpStatus, type UserOpStatusProps, type UserOperation, type UserOperationByHash, type UserOperationReceipt, UserOperationTimeoutError, type UserProfile, UserRejectedError, type WaitForReceiptOptions, type WalletMode, type WalletReadyStatus, type WatchToken, combineI18NResources, createAccountAbstractionError, deployAccount, destroyIframeManager, generateFingerprint, getAllSmartAccounts, getAvailableLanguages, getExplorerUrl, getIframeManager, getLanguageIcon, getShareRecoveryStats, getSmartAccountForChain, getUserOperationByHash, getUserOperationReceipt, getUserProfile, looksLikeNickname, prepareUserOperation, requireActiveChainId, sendUserOperation, signTypedData, updateUserProfile, useAccountSession, useActiveChainId, useAddress, useAssets, useBalance, useBlockscoutAssets, useColorMode, useConnectedApps, useDirectWallet, useErc3643Compliance, useError, useHasServerVault, useHydrated, useIFrameReady, useIsMobileView, useKeyshareRecoveryStats, useLinkedProfiles, useLoadingStatus, useLogout, useNativeWalletSignature, useNicknameResolve, useOpenPage, useProviderConfig, useRecoveryUserId, useSendDirectTransaction, useSendTransaction, useSession, useSmartAccountTransactions, useTokenBalance, useTokenInfo, useTransactions, useTransferToLinkedWallet, useUserOpStatus, useWalletMode, verifyFingerprint, verifyFingerprintDetailed, wagmiConfig, waitForStoreHydration, waitForUserOperationReceipt };