@embarkai/ui-kit 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,2719 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode, MutableRefObject, FC, HTMLAttributes, PropsWithChildren, ButtonHTMLAttributes } from 'react';
+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 { QueryClient } 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';
+export { JwtTokens, LoginResponse, VerifyResponse, getValidTokens, jwtTokenManager, logout } from '@embarkai/core/auth';
+import * as wagmi from 'wagmi';
+
+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;
+}
+/**
+ * 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;
+    /** 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>>;
+};
+
+/**
+ * LumiaPassport Configuration (library copy)
+ * Default config can be overridden via Provider initialConfig
+ */
+
+declare global {
+    interface Window {
+        __EMBARK_SERVICES__?: Partial<{
+            bundlerUrl: string;
+            tssUrl: string;
+            shareVaultUrl: 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;
+}
+/**
+ * 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;
+}
+interface LumiaPassportConfig {
+    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;
+    };
+    development: {
+        enabled: boolean;
+        showOnProduction: boolean;
+    };
+    preferedColorMode?: 'light' | 'dark';
+    projectAssets?: {
+        assets: ProjectAsset[];
+        showBalanceAs?: ProjectAsset['symbol'];
+    };
+    /**
+     * 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: {
+        bundlerUrl: string;
+        tssUrl: string;
+        shareVaultUrl: 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 LumiaPassportCallbacks {
+    onLumiaPassportConnecting?: (payload: {
+        method: 'passkey' | 'email' | 'social' | 'wallet';
+        provider?: string;
+    }) => void;
+    onLumiaPassportConnect?: (payload: {
+        address: `0x${string}`;
+        session: any;
+    }) => void;
+    onLumiaPassportAccount?: (payload: {
+        userId?: string | null;
+        address?: `0x${string}` | null;
+        session?: any;
+        hasKeyshare?: boolean;
+    }) => void;
+    onLumiaPassportUpdate?: (payload: {
+        providers?: Array<any>;
+    }) => void;
+    onLumiaPassportDisconnect?: (payload: {
+        address?: `0x${string}` | null;
+        userId?: string | null;
+    }) => void;
+    onLumiaPassportError?: (payload: {
+        error: Error;
+        code?: string;
+        message: string;
+    }) => void;
+    onLumiaPassportChainChange?: (payload: {
+        chainId: number;
+        previousChainId: number;
+    }) => void;
+    onWalletReady?: (status: WalletReadyStatus$1) => void;
+}
+interface LumiaPassportContextType {
+    config: MutableRefObject<LumiaPassportConfig>;
+    updateConfig: (updates: Partial<LumiaPassportConfig>) => void;
+    callbacks?: LumiaPassportCallbacks;
+}
+interface LumiaPassportProviderProps {
+    children: ReactNode;
+    projectId?: string;
+    initialConfig?: Partial<LumiaPassportConfig>;
+    callbacks?: LumiaPassportCallbacks;
+}
+/** NEVER EVER declare here any state (useState or whatever). This Provider should NEVER trigger self of child-app re-renders */
+declare function LumiaPassportProvider(props: LumiaPassportProviderProps): react_jsx_runtime.JSX.Element;
+declare const useLumiaPassportConfig: () => LumiaPassportContextType;
+
+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 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;
+    constructor(config: IframeManagerConfig);
+    setDebug(debug: boolean): void;
+    /**
+     * Initialize iframe and wait for it to be ready
+     */
+    initialize(): Promise<void>;
+    /**
+     * 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;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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;
+    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 useLumiaPassportSession is UNLIKELY to use outside Lumia Passport, as it is INTERNAL zustand session store!
+ *  Use it with caution, using zustand callback extraction. EX: const address = useLumiaPassportSession((st) => st.address)
+ *  @description refactor your app to NOT use this directly in your application, use set of new dedicated session hooks: useLumiaPassportAccountSession, useLumiaPassportAddress, etc.
+ */
+declare const useLumiaPassportSession: 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>>;
+    };
+}>;
+/**
+ * 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 function LumiaPassportSessionProvider({ children }: PropsWithChildren): react_jsx_runtime.JSX.Element;
+
+declare const useLumiaPassportIsMobileView: () => boolean;
+declare const useLumiaPassportBalance: () => {
+    walletBalance: {
+        decimals: number;
+        formatted: string;
+        symbol: string;
+        value: bigint;
+    };
+    fiatBalance: number;
+    cryptoRate: number;
+    fiatSymbol: string;
+    cryptoSymbol: string;
+};
+declare const useLumiaPassportIFrameReady: () => boolean;
+declare const useLumiaPassportAccountSession: () => AccountSession;
+declare const useLumiaPassportAddress: () => `0x${string}`;
+declare const useLumiaPassportError: () => string;
+declare const useLumiaPassportLoadingStatus: () => {
+    isSessionLoading: boolean;
+    sessionStatus: string;
+};
+declare const useLumiaPassportRecoveryUserId: () => string;
+declare const useLumiaPassportHasServerVault: () => boolean;
+declare const useLumiaPassportActiveChainId: () => number;
+
+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"
+}
+/** 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 LumiaPassport dialogs
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isOpen, open, close } = useLumiaPassportOpen();
+ *
+ *   return (
+ *     <button onClick={() => open(PageKey.BUY, { amount: 10 })}>
+ *       Buy LUMIA
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useLumiaPassportOpen(): {
+    readonly open: (passportPage: PageKey, params?: PageOpenParams) => void;
+    readonly close: () => void;
+    readonly isOpen: boolean;
+};
+
+type ColorMode = 'light' | 'dark';
+
+declare function useLumiaPassportColorMode(): {
+    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;
+}
+
+/** LumiaPassport Color Mode Switcher */
+declare function ThemeToggle(props: ButtonProps): react_jsx_runtime.JSX.Element;
+
+/** LumiaPassport Language Switcher */
+declare function LangToggle(props: ButtonProps): react_jsx_runtime.JSX.Element;
+
+interface LumiaWagmiProviderProps {
+    children: React__default.ReactNode;
+}
+declare const LumiaWagmiProvider: React__default.FC<LumiaWagmiProviderProps>;
+
+declare function LumiaRainbowKitProvider({ children }: PropsWithChildren): react_jsx_runtime.JSX.Element;
+
+interface LumiaLogoProps {
+    size?: number;
+    className?: string;
+}
+declare const LumiaLogo: React$1.ForwardRefExoticComponent<LumiaLogoProps & React$1.RefAttributes<SVGSVGElement>>;
+
+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 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 UseLogoutReturn {
+    logout: () => Promise<void>;
+}
+/**
+ * Hook for logging out and disconnecting from Lumia Passport
+ * 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;
+
+declare const lumiaBeamTestnet: Chain;
+declare const lumiaPrisma: Chain;
+
+/**
+ * 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;
+    }
+}
+
+interface AuthProvider {
+    provider: 'passkey' | 'email' | 'telegram' | 'google' | 'discord' | 'twitter' | 'wallet';
+    verified: boolean;
+    linkedAt: string;
+    lastUsedAt?: string;
+    externalId: string;
+}
+
+/**
+ * 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>;
+
+/**
+ * Custom error types for Lumia Passport operations
+ */
+/**
+ * Base error class for all Lumia Passport errors
+ * Local copy to avoid @embarkai/core dependency in iframe bundle
+ */
+declare class LumiaPassportError 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 LumiaPassportError {
+    static readonly CODE: "USER_REJECTED";
+    constructor(message?: string);
+}
+/**
+ * Error codes for Lumia Passport 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 createLumiaPassportError(params: {
+    message: string;
+    code?: string;
+}): Error;
+
+declare const queryClient: QueryClient;
+
+/**
+ * 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[]>;
+
+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;
+        type: "legacy";
+        yParity?: undefined;
+        from: viem.Address;
+        gas: bigint;
+        hash: Hash$1;
+        nonce: number;
+        r: viem.Hex;
+        to: viem.Address | null;
+        typeHex: viem.Hex | null;
+        v: bigint;
+        accessList?: undefined;
+        authorizationList?: undefined;
+        blobVersionedHashes?: undefined;
+        chainId?: number;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        type: "eip2930";
+        yParity: number;
+        from: viem.Address;
+        gas: bigint;
+        hash: Hash$1;
+        nonce: number;
+        r: viem.Hex;
+        to: viem.Address | null;
+        typeHex: viem.Hex | null;
+        v: bigint;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        blobVersionedHashes?: undefined;
+        chainId: number;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        type: "eip1559";
+        yParity: number;
+        from: viem.Address;
+        gas: bigint;
+        hash: Hash$1;
+        nonce: number;
+        r: viem.Hex;
+        to: viem.Address | null;
+        typeHex: viem.Hex | null;
+        v: bigint;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        blobVersionedHashes?: undefined;
+        chainId: number;
+        gasPrice?: undefined;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        type: "eip4844";
+        yParity: number;
+        from: viem.Address;
+        gas: bigint;
+        hash: Hash$1;
+        nonce: number;
+        r: viem.Hex;
+        to: viem.Address | null;
+        typeHex: viem.Hex | null;
+        v: bigint;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        blobVersionedHashes: readonly viem.Hex[];
+        chainId: number;
+        gasPrice?: undefined;
+        maxFeePerBlobGas: bigint;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        value: bigint;
+        type: "eip7702";
+        yParity: number;
+        from: viem.Address;
+        gas: bigint;
+        hash: Hash$1;
+        nonce: number;
+        r: viem.Hex;
+        to: viem.Address | null;
+        typeHex: viem.Hex | null;
+        v: bigint;
+        accessList: viem.AccessList;
+        authorizationList: viem.SignedAuthorizationList;
+        blobVersionedHashes?: undefined;
+        chainId: number;
+        gasPrice?: undefined;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        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;
+            type: "legacy";
+            yParity?: undefined;
+            from: viem.Address;
+            gas: bigint;
+            hash: Hash$1;
+            nonce: number;
+            r: viem.Hex;
+            to: viem.Address | null;
+            typeHex: viem.Hex | null;
+            v: bigint;
+            accessList?: undefined;
+            authorizationList?: undefined;
+            blobVersionedHashes?: undefined;
+            chainId?: number;
+            gasPrice: bigint;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            type: "eip2930";
+            yParity: number;
+            from: viem.Address;
+            gas: bigint;
+            hash: Hash$1;
+            nonce: number;
+            r: viem.Hex;
+            to: viem.Address | null;
+            typeHex: viem.Hex | null;
+            v: bigint;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            blobVersionedHashes?: undefined;
+            chainId: number;
+            gasPrice: bigint;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            type: "eip1559";
+            yParity: number;
+            from: viem.Address;
+            gas: bigint;
+            hash: Hash$1;
+            nonce: number;
+            r: viem.Hex;
+            to: viem.Address | null;
+            typeHex: viem.Hex | null;
+            v: bigint;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            blobVersionedHashes?: undefined;
+            chainId: number;
+            gasPrice?: undefined;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            type: "eip4844";
+            yParity: number;
+            from: viem.Address;
+            gas: bigint;
+            hash: Hash$1;
+            nonce: number;
+            r: viem.Hex;
+            to: viem.Address | null;
+            typeHex: viem.Hex | null;
+            v: bigint;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            blobVersionedHashes: readonly viem.Hex[];
+            chainId: number;
+            gasPrice?: undefined;
+            maxFeePerBlobGas: bigint;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            value: bigint;
+            type: "eip7702";
+            yParity: number;
+            from: viem.Address;
+            gas: bigint;
+            hash: Hash$1;
+            nonce: number;
+            r: viem.Hex;
+            to: viem.Address | null;
+            typeHex: viem.Hex | null;
+            v: bigint;
+            accessList: viem.AccessList;
+            authorizationList: viem.SignedAuthorizationList;
+            blobVersionedHashes?: undefined;
+            chainId: number;
+            gasPrice?: undefined;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        };
+        receipt: viem.TransactionReceipt;
+    }>;
+};
+
+interface LinkedProfileDisplay extends AuthProvider {
+    displayName: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    color?: string;
+}
+declare function useLumiaPassportLinkedProfiles(): {
+    profiles: LinkedProfileDisplay[];
+    avatar: string;
+    isLoading: boolean;
+    error: Error;
+    refresh: () => Promise<void>;
+};
+
+/**
+ * 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;
+                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;
+            };
+            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;
+            };
+            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;
+                trustedApps: {
+                    trustedApp: string;
+                    trustedApps: string;
+                    noTrustedApps: 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;
+                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;
+            };
+            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;
+            };
+            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;
+                trustedApps: {
+                    trustedApp: string;
+                    trustedApps: string;
+                    noTrustedApps: 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;
+                };
+            };
+        };
+    };
+    ru: {
+        passport: {
+            common: {
+                create: string;
+                add: string;
+                added: string;
+                edit: string;
+                confirm: 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;
+            };
+            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;
+            };
+            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;
+                trustedApps: {
+                    trustedApp: string;
+                    trustedApps: string;
+                    noTrustedApps: 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 = "lumia-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;
+
+export { type AccountSession, Address, type AddressProps, type Asset, ConnectWalletButton, type ConnectWalletButtonProps, ErrorCodes, type FingerprintVerificationResult, Hash, type HashProps, KeyshareBackupMenu as KeyshareBackup, LOCAL_STORAGE_I18N_KEY, LangToggle, LumiaLogo, type LumiaPassportCallbacks, type LumiaPassportConfig, LumiaPassportError, LumiaPassportProvider, type LumiaPassportProviderProps, LumiaPassportSessionProvider, LumiaRainbowKitProvider, LumiaWagmiProvider, type NicknameAvailability, type NicknameAvatar, type NicknameChangeResult, type NicknameInfo, type NicknameResolution, type NicknameResolveRequest, type NicknameResolvedTarget, type NicknameValidationResult, PASSPORT_TRANSLATIONS, PageKey, type PageOpenParams, type ProviderDetail, type RegisterSmartAccountResult, type SendTransactionParams, type SendTransactionResult, type SignTypedDataParams, type SmartAccountEntry, ThemeToggle, type TokenBalance, type Transaction, TransactionsList, type TypedDataDomain, type TypedDataField, type UpdateProfileRequest, type UseErc3643ComplianceOptions, type UseErc3643ComplianceResult, type UseLogoutReturn, type UseNicknameResolveOptions, type UseNicknameResolveResult, type UseSendTransactionReturn, type UseUserOpStatusOptions, type UseUserOpStatusReturn, 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 WalletReadyStatus, type WatchToken, combineI18NResources, createLumiaPassportError, deployAccount, destroyIframeManager, generateFingerprint, getAllSmartAccounts, getAvailableLanguages, getIframeManager, getLanguageIcon, getSmartAccountForChain, getUserOperationByHash, getUserOperationReceipt, getUserProfile, looksLikeNickname, lumiaBeamTestnet, lumiaPrisma, prepareUserOperation, queryClient, requireActiveChainId, sendUserOperation, signTypedData, updateUserProfile, useAssets, useErc3643Compliance, useLogout, useLumiaPassportAccountSession, useLumiaPassportActiveChainId, useLumiaPassportAddress, useLumiaPassportBalance, useLumiaPassportColorMode, useLumiaPassportConfig, useLumiaPassportError, useLumiaPassportHasServerVault, useLumiaPassportIFrameReady, useLumiaPassportIsMobileView, useLumiaPassportLinkedProfiles, useLumiaPassportLoadingStatus, useLumiaPassportOpen, useLumiaPassportRecoveryUserId, useLumiaPassportSession, useNicknameResolve, useSendTransaction, useSmartAccountTransactions, useTokenBalance, useTokenInfo, useTransactions, useUserOpStatus, verifyFingerprint, verifyFingerprintDetailed, wagmiConfig, waitForUserOperationReceipt };