@lumiapassport/ui-kit 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,798 @@
+import * as React from 'react';
+import React__default from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as viem from 'viem';
+import { Chain, Hash as Hash$1, TransactionReceipt } from 'viem';
+import * as wagmi from 'wagmi';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient } from '@tanstack/react-query';
+
+/**
+ * LumiaPassport Configuration (library copy)
+ * Default config can be overridden via Provider initialConfig
+ */
+
+declare global {
+    interface Window {
+        __LUMIA_SERVICES__?: Partial<{
+            bundlerUrl: string;
+            tssUrl: string;
+            shareVaultUrl: string;
+            tssRequireWasm: boolean;
+            tssWasmDebug: boolean;
+        }>;
+        __LUMIA_PROJECT_ID__?: string;
+    }
+}
+interface SocialProvider {
+    id: string;
+    name: string;
+    enabled: boolean;
+    icon: React__default.ComponentType<{
+        className?: string;
+    }>;
+    comingSoon?: boolean;
+    meta?: Record<string, any>;
+}
+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[];
+        gridColumns: number;
+    };
+    wallet: {
+        enabled: boolean;
+        supportedChains?: number[];
+        requireSignature: boolean;
+        walletConnectProjectId?: string;
+    };
+    development: {
+        enabled: boolean;
+        showOnProduction: boolean;
+    };
+    ui: {
+        title: string;
+        subtitle?: string;
+        theme: 'light' | 'dark' | 'auto';
+        authOrder?: Array<'passkey' | 'email' | 'social'>;
+        authOpen?: boolean;
+        fonts?: {
+            base?: string;
+            heading?: string;
+        };
+        branding: {
+            logo?: React__default.ComponentType<{
+                size?: number;
+            }>;
+            tagline: string;
+            link?: {
+                text: string;
+                url: string;
+            };
+        };
+        modal: {
+            width: string;
+            borderRadius: string;
+        };
+    };
+    network: {
+        name: string;
+        symbol: string;
+        chainId: number;
+        rpcUrl: string;
+        explorerUrl?: string;
+        testnet?: 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;
+    };
+    warnings: {
+        backupWarning: boolean;
+        emailNotConnectedWarning: boolean;
+    };
+    kyc?: {
+        provider?: 'sumsub' | 'uaepass' | 'custom';
+        options?: Record<string, any>;
+    };
+}
+
+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;
+}
+interface LumiaPassportContextType {
+    config: LumiaPassportConfig;
+    updateConfig: (updates: Partial<LumiaPassportConfig>) => void;
+    callbacks?: LumiaPassportCallbacks;
+}
+interface LumiaPassportProviderProps {
+    children: React__default.ReactNode;
+    projectId?: string;
+    initialConfig?: Partial<LumiaPassportConfig>;
+    callbacks?: LumiaPassportCallbacks;
+}
+declare const LumiaPassportProvider: React__default.FC<LumiaPassportProviderProps>;
+declare const useLumiaPassportConfig: () => LumiaPassportContextType;
+
+interface AccountSession$1 {
+    ownerAddress: `0x${string}`;
+    smartAccountAddress: `0x${string}`;
+    factoryAddress: `0x${string}`;
+    ownerPrivateKey?: `0x${string}`;
+    mpcUserId?: string;
+    usePaymaster?: boolean;
+    kind: 'lumia';
+    address: `0x${string}`;
+}
+declare function sendUserOperation(session: AccountSession$1, callTarget: `0x${string}`, amountWei: string, innerData?: `0x${string}`, feeType?: 'economy' | 'standard' | 'fast', entryPointVersion?: 'v0.6' | 'v0.7'): Promise<`0x${string}`>;
+
+type AccountSession = AccountSession$1;
+interface SessionState {
+    session: AccountSession | null;
+    address: `0x${string}` | null;
+    status: string;
+    error: string | null;
+    setSession: (s: AccountSession | null) => void;
+    setAddress: (a: `0x${string}` | null) => void;
+    setStatus: (s: string) => void;
+    setError: (e: string | null) => void;
+}
+interface LumiaSessionProviderProps {
+    children: React__default.ReactNode;
+}
+declare const LumiaSessionProvider: React__default.FC<LumiaSessionProviderProps>;
+declare function useLumiaSession(): SessionState;
+
+interface LumiaWagmiProviderProps {
+    children: React__default.ReactNode;
+}
+declare const LumiaWagmiProvider: React__default.FC<LumiaWagmiProviderProps>;
+
+interface LumiaRainbowKitProviderProps {
+    children: React__default.ReactNode;
+}
+declare const LumiaRainbowKitProvider: React__default.FC<LumiaRainbowKitProviderProps>;
+
+interface ConnectWalletButtonProps {
+    className?: string;
+    label?: string;
+    usePaymaster?: boolean;
+    authOpen?: boolean;
+    mode?: 'default' | 'compact';
+    callbacks?: LumiaPassportCallbacks;
+    onConnected?: (params: {
+        address: `0x${string}`;
+        session: any;
+    }) => void;
+}
+declare const ConnectWalletButton: React__default.FC<ConnectWalletButtonProps>;
+
+/**
+ * Theme toggle component for testing dark/light/auto mode
+ * This is a demo component to showcase theme switching
+ */
+declare const ThemeToggle: React__default.FC;
+
+interface LumiaLogoProps {
+    size?: number;
+    className?: string;
+}
+declare const LumiaLogo: React__default.FC<LumiaLogoProps>;
+
+type Theme = 'light' | 'dark' | 'auto';
+/**
+ * Hook for managing theme detection and CSS classes
+ */
+declare function useTheme(configTheme: Theme): {
+    theme: "light" | "dark";
+    isDark: boolean;
+    classes: {
+        modalBg: string;
+        titleText: string;
+        bodyText: string;
+        mutedText: string;
+        linkText: string;
+        inputBg: string;
+        inputText: string;
+        primaryBtn: string;
+        secondaryBtn: string;
+        outlineBtn: string;
+        actionBtn: string;
+        divider: string;
+        errorText: string;
+        successText: string;
+        iconColor: string;
+    };
+};
+
+type ChainLike$2 = {
+    id: number;
+    blockExplorers?: {
+        default?: {
+            url: string;
+        };
+    };
+};
+type UserOpStatusProps = {
+    userOpHash: `0x${string}` | string;
+    chain?: ChainLike$2;
+    className?: string;
+    pollMs?: number;
+    maxPollTimeMs?: number;
+    externalState?: {
+        receipt?: any | null;
+        mempool?: any | null;
+        error?: string | null;
+        isPolling?: boolean;
+    };
+};
+declare const UserOpStatus: React.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.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.FC<AddressProps>;
+
+interface TransactionsListProps {
+    address: string;
+    itemsCount?: number;
+}
+declare const TransactionsList: React__default.FC<TransactionsListProps>;
+
+interface KeyshareBackupProps {
+    userId: string;
+    onClose?: () => void;
+    onBackupSuccess?: () => void;
+}
+declare function KeyshareBackup({ userId, onClose, onBackupSuccess }: KeyshareBackupProps): react_jsx_runtime.JSX.Element;
+
+interface SendTransactionParams$1 {
+    to: `0x${string}`;
+    value: string;
+    data?: `0x${string}`;
+}
+interface UseSendTransactionReturn {
+    sendTransaction: (params: SendTransactionParams$1) => Promise<string | null>;
+    isLoading: boolean;
+    error: string | null;
+    userOpHash: string | null;
+    reset: () => void;
+}
+declare function useSendTransaction(): UseSendTransactionReturn;
+
+interface UserOpReceipt {
+    userOpHash: `0x${string}`;
+    sender: `0x${string}`;
+    nonce: string;
+    actualGasUsed: string;
+    actualGasCost: string;
+    success: boolean;
+    receipt?: {
+        transactionHash: `0x${string}`;
+        blockNumber: string;
+        blockHash: string;
+        logs: any[];
+    };
+}
+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: UserOpReceipt) => void;
+    onTxHash?: (txHash: `0x${string}`) => void;
+}
+interface UseUserOpStatusReturn {
+    state: UserOpState;
+    receipt: UserOpReceipt | null;
+    mempool: UserOpMempool | null;
+    txHash: `0x${string}` | null;
+    error: string | null;
+    isPolling: boolean;
+    refresh: () => Promise<void>;
+}
+declare function useUserOpStatus(options?: UseUserOpStatusOptions): UseUserOpStatusReturn;
+
+declare const LUMIA_EXPLORER_URL: string;
+declare const lumiaBeam: Chain;
+
+interface UserProfile {
+    userId: string;
+    displayName?: string;
+    avatar?: string;
+    providers: Array<{
+        type: string;
+        identifier: string;
+        connectedAt: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+    hasKeyshare: boolean;
+}
+interface UpdateProfileRequest {
+    displayName?: string;
+}
+/**
+ * Get user profile
+ */
+declare function getUserProfile(): Promise<UserProfile>;
+/**
+ * Update user profile
+ */
+declare function updateUserProfile(updates: UpdateProfileRequest): Promise<UserProfile>;
+
+declare const queryClient: QueryClient;
+declare const wagmiConfig: wagmi.Config<readonly [viem.Chain], {
+    [lumiaBeam.id]: 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;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        to: viem.Address | null;
+        type: "legacy";
+        value: bigint;
+        r: viem.Hex;
+        v: bigint;
+        yParity?: undefined;
+        blobVersionedHashes?: undefined;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        chainId?: number;
+        accessList?: undefined;
+        authorizationList?: undefined;
+        hash: Hash$1;
+        typeHex: viem.Hex | null;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        to: viem.Address | null;
+        type: "eip2930";
+        value: bigint;
+        r: viem.Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes?: undefined;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        chainId: number;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        hash: Hash$1;
+        typeHex: viem.Hex | null;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        to: viem.Address | null;
+        type: "eip1559";
+        value: bigint;
+        r: viem.Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes?: undefined;
+        gasPrice?: undefined;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        chainId: number;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        hash: Hash$1;
+        typeHex: viem.Hex | null;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        to: viem.Address | null;
+        type: "eip4844";
+        value: bigint;
+        r: viem.Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes: readonly viem.Hex[];
+        gasPrice?: undefined;
+        maxFeePerBlobGas: bigint;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        chainId: number;
+        accessList: viem.AccessList;
+        authorizationList?: undefined;
+        hash: Hash$1;
+        typeHex: viem.Hex | null;
+        blockHash: `0x${string}`;
+        blockNumber: bigint;
+        transactionIndex: number;
+    } | {
+        input: viem.Hex;
+        s: viem.Hex;
+        from: viem.Address;
+        gas: bigint;
+        nonce: number;
+        to: viem.Address | null;
+        type: "eip7702";
+        value: bigint;
+        r: viem.Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes?: undefined;
+        gasPrice?: undefined;
+        maxFeePerBlobGas?: undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        chainId: number;
+        accessList: viem.AccessList;
+        authorizationList: viem.SignedAuthorizationList;
+        hash: Hash$1;
+        typeHex: viem.Hex | null;
+        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 TokenBalance {
+    address: `0x${string}`;
+    name: string;
+    symbol: string;
+    decimals: number;
+    balance: string;
+    formattedBalance: string;
+    logo?: string;
+}
+interface Asset {
+    type: 'native' | 'erc20' | 'erc721' | 'erc1155';
+    address?: `0x${string}`;
+    name: string;
+    symbol: string;
+    balance: string;
+    formattedBalance: string;
+    decimals?: number;
+    tokenId?: string;
+    logo?: string;
+}
+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>>;
+};
+
+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;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            to: viem.Address | null;
+            type: "legacy";
+            value: bigint;
+            r: viem.Hex;
+            v: bigint;
+            yParity?: undefined;
+            blobVersionedHashes?: undefined;
+            gasPrice: bigint;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            chainId?: number;
+            accessList?: undefined;
+            authorizationList?: undefined;
+            hash: Hash$1;
+            typeHex: viem.Hex | null;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            to: viem.Address | null;
+            type: "eip2930";
+            value: bigint;
+            r: viem.Hex;
+            v: bigint;
+            yParity: number;
+            blobVersionedHashes?: undefined;
+            gasPrice: bigint;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            chainId: number;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            hash: Hash$1;
+            typeHex: viem.Hex | null;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            to: viem.Address | null;
+            type: "eip1559";
+            value: bigint;
+            r: viem.Hex;
+            v: bigint;
+            yParity: number;
+            blobVersionedHashes?: undefined;
+            gasPrice?: undefined;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            chainId: number;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            hash: Hash$1;
+            typeHex: viem.Hex | null;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            to: viem.Address | null;
+            type: "eip4844";
+            value: bigint;
+            r: viem.Hex;
+            v: bigint;
+            yParity: number;
+            blobVersionedHashes: readonly viem.Hex[];
+            gasPrice?: undefined;
+            maxFeePerBlobGas: bigint;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            chainId: number;
+            accessList: viem.AccessList;
+            authorizationList?: undefined;
+            hash: Hash$1;
+            typeHex: viem.Hex | null;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        } | {
+            input: viem.Hex;
+            s: viem.Hex;
+            from: viem.Address;
+            gas: bigint;
+            nonce: number;
+            to: viem.Address | null;
+            type: "eip7702";
+            value: bigint;
+            r: viem.Hex;
+            v: bigint;
+            yParity: number;
+            blobVersionedHashes?: undefined;
+            gasPrice?: undefined;
+            maxFeePerBlobGas?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            chainId: number;
+            accessList: viem.AccessList;
+            authorizationList: viem.SignedAuthorizationList;
+            hash: Hash$1;
+            typeHex: viem.Hex | null;
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            transactionIndex: number;
+        };
+        receipt: viem.TransactionReceipt;
+    }>;
+};
+
+interface AuthProvider {
+    provider: 'passkey' | 'email' | 'telegram' | 'google' | 'discord' | 'twitter' | 'wallet';
+    verified: boolean;
+    linkedAt: string;
+    lastUsedAt?: string;
+    externalId: string;
+}
+
+interface LinkedProfileDisplay extends AuthProvider {
+    displayName: string;
+    icon?: string;
+    color?: string;
+}
+declare function useLumiaPassportLinkedProfiles(): {
+    readonly profiles: LinkedProfileDisplay[];
+    readonly avatar: string;
+    readonly isLoading: boolean;
+    readonly error: string;
+    readonly refresh: () => Promise<void>;
+};
+
+export { type AccountSession$1 as AccountSession, Address, type AddressProps, type Asset, ConnectWalletButton, type ConnectWalletButtonProps, Hash, type HashProps, KeyshareBackup, LUMIA_EXPLORER_URL, LumiaLogo, type LumiaPassportCallbacks, type LumiaPassportConfig, LumiaPassportProvider, type LumiaPassportProviderProps, LumiaRainbowKitProvider, type LumiaRainbowKitProviderProps, LumiaSessionProvider, type LumiaSessionProviderProps, LumiaWagmiProvider, type SendTransactionParams, type SendTransactionResult, type Theme, ThemeToggle, type TokenBalance, type Transaction, TransactionsList, type UpdateProfileRequest, type UseSendTransactionReturn, type UseUserOpStatusOptions, type UseUserOpStatusReturn, type UserOpMempool, type UserOpReceipt, type SendTransactionParams$1 as UserOpSendTransactionParams, type UserOpState, UserOpStatus, type UserOpStatusProps, type UserOperation, type UserProfile, getUserProfile, lumiaBeam, queryClient, sendUserOperation, updateUserProfile, useAssets, useLumiaPassportConfig, useLumiaPassportLinkedProfiles, useLumiaSession, useSendTransaction, useSmartAccountTransactions, useTheme, useTokenBalance, useTokenInfo, useTransactions, useUserOpStatus, wagmiConfig };