cilantro-react 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -1,18 +1,86 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React$1 from 'react';
-import { ReactNode } from 'react';
-import { WalletControllerFindAllResult, WalletControllerListSignersResult, WalletControllerSubmitTransactionResult } from 'cilantro-sdk/wallet';
+import { ReactNode, Component, ErrorInfo } from 'react';
+import { WalletControllerFindAllResult, WalletControllerCreateResult, WalletControllerSubmitTransactionResult } from 'cilantro-sdk/wallet';
 export { WalletControllerFindAllResult, WalletControllerFindOneResult, WalletControllerListSignersResult, WalletControllerSubmitTransactionResult } from 'cilantro-sdk/wallet';
-import { SignerInfo } from 'cilantro-sdk/helpers';
-import { DelegatedKeyControllerFindAllResult } from 'cilantro-sdk/delegated-keys';
-export { DelegatedKeyControllerFindAllResult } from 'cilantro-sdk/delegated-keys';
-import { Transaction, PublicKey } from '@solana/web3.js';
+import { createIndexedDBAdapter, SignerInfo } from 'cilantro-sdk/helpers';
+export { createIndexedDBAdapter, createLocalStorageAdapter, createMemoryAdapter } from 'cilantro-sdk/helpers';
+import { PublicKey, Transaction, Connection } from '@solana/web3.js';
 export { AuthControllerLogin200Data } from 'cilantro-sdk/auth';
 export { TransactionControllerSendRawPasskeyTransactionResult } from 'cilantro-sdk/transactions';
 
+type DeviceKeyStorage = ReturnType<typeof createIndexedDBAdapter>;
+
+/** Minimal user view; populated from SDK login result data.user when available. */
+interface User {
+    username?: string;
+    email?: string;
+    userType?: string;
+}
+/** SDK wallet list item type. */
+type WalletDataDto$1 = WalletControllerFindAllResult["data"] extends readonly (infer E)[] ? E : WalletControllerFindAllResult["data"] extends (infer E)[] ? E : never;
+/** Wallet with backward-compat aliases (id, address, active). */
+type WalletData = WalletDataDto$1 & {
+    id?: string;
+    address?: string;
+    active?: boolean;
+};
+interface CilantroConfig {
+    apiKey?: string;
+    baseURL: string;
+    jwt?: string | null;
+}
+interface CilantroContextValue {
+    config: CilantroConfig;
+    storage: DeviceKeyStorage | null;
+    user: User | null;
+    jwt: string | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    login: (params: {
+        usernameOrEmail: string;
+        password: string;
+    }) => Promise<void>;
+    logout: () => void;
+    register: (username: string, email: string, password: string, isActive?: boolean) => Promise<void>;
+    clearSessionDueToAuthError: () => void;
+    wallet: WalletData | null;
+    wallets: WalletData[];
+    createWallet: (params: {
+        name: string;
+        userId?: string;
+    }) => Promise<WalletControllerCreateResult>;
+    selectWallet: (walletId: string) => void;
+    refreshWallets: () => Promise<void>;
+    walletError: string | null;
+    walletsLoading: boolean;
+}
+interface CilantroContextProviderProps {
+    children: ReactNode;
+    apiKey?: string;
+    baseURL?: string;
+    storageAdapter?: DeviceKeyStorage | null;
+    jwtStorageKey?: string;
+    walletStorageKey?: string;
+    onLoginSuccess?: () => void;
+    onLogout?: () => void;
+    onRegisterSuccess?: () => void;
+    onSessionExpired?: () => void;
+}
+declare function CilantroContextProvider({ children, apiKey, baseURL, storageAdapter, jwtStorageKey, walletStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, onSessionExpired, }: CilantroContextProviderProps): react_jsx_runtime.JSX.Element;
+declare function useCilantroContext(): CilantroContextValue;
+
 interface CilantroProviderProps {
     children: ReactNode;
-    platformApiKey: string;
+    /** Platform API key (guide: apiKey). Either apiKey or jwt via login is required for authenticated requests. */
+    apiKey?: string;
+    /** API base URL (guide: baseURL). Default: https://api.cilantro.gg */
+    baseURL?: string;
+    /** Storage for device keys - email/phone signers (guide: storageAdapter). Default: IndexedDB in browser. */
+    storageAdapter?: DeviceKeyStorage | null;
+    /** @deprecated Use apiKey instead. */
+    platformApiKey?: string;
+    /** @deprecated Use baseURL instead. */
     apiUrl?: string;
     /** localStorage key for JWT (default: cilantro_jwt) */
     jwtStorageKey?: string;
@@ -21,15 +89,10 @@ interface CilantroProviderProps {
     onLoginSuccess?: () => void;
     onLogout?: () => void;
     onRegisterSuccess?: () => void;
+    onSessionExpired?: () => void;
 }
-declare function CilantroProvider({ children, platformApiKey, apiUrl, jwtStorageKey, walletStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, }: CilantroProviderProps): react_jsx_runtime.JSX.Element;
+declare function CilantroProvider({ children, apiKey: apiKeyProp, baseURL, storageAdapter, platformApiKey, apiUrl, jwtStorageKey, walletStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, onSessionExpired, }: CilantroProviderProps): react_jsx_runtime.JSX.Element;
 
-/** Minimal user view; populated from SDK login result data.user when available. */
-interface User {
-    username?: string;
-    email?: string;
-    userType?: string;
-}
 interface CilantroAuthContextType {
     user: User | null;
     token: string | null;
@@ -37,60 +100,53 @@ interface CilantroAuthContextType {
     login: (usernameOrEmail: string, password: string) => Promise<void>;
     register: (username: string, email: string, password: string, isActive?: boolean) => Promise<void>;
     logout: () => void;
+    clearSessionDueToAuthError: () => void;
     isLoading: boolean;
 }
-interface CilantroAuthProviderProps {
-    children: ReactNode;
-    platformApiKey: string;
-    apiUrl?: string;
-    jwtStorageKey?: string;
-    onLoginSuccess?: () => void;
-    onLogout?: () => void;
-    onRegisterSuccess?: () => void;
-}
-declare function CilantroAuthProvider({ children, platformApiKey, apiUrl, jwtStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, }: CilantroAuthProviderProps): react_jsx_runtime.JSX.Element;
 declare function useCilantroAuth(): CilantroAuthContextType;
 
-/** SDK wallet list item type (element of WalletsListResponseDto.data). */
-type WalletDataDto = WalletControllerFindAllResult["data"] extends readonly (infer E)[] ? E : WalletControllerFindAllResult["data"] extends (infer E)[] ? E : never;
-/** WalletDataDto with backward-compat aliases (id, address, active) for existing UI. */
-type WalletData = WalletDataDto & {
-    id?: string;
-    address?: string;
-    active?: boolean;
-};
 interface WalletContextType {
     selectedWallet: WalletData | null;
     wallets: WalletData[];
     selectWallet: (walletId: string) => void;
     refreshWallets: () => Promise<void>;
     isLoading: boolean;
+    error: string | null;
 }
-interface WalletProviderProps {
-    children: ReactNode;
-    storageKey?: string;
-}
-declare function WalletProvider({ children, storageKey }: WalletProviderProps): react_jsx_runtime.JSX.Element;
 declare function useWallets(): WalletContextType;
 
-interface UseSelectedWalletResult {
-    selectedWallet: WalletData | null;
+type WalletDataDto = WalletData;
+
+interface UseCilantroConfigResult {
+    config: CilantroConfig;
+    storage: DeviceKeyStorage | null;
+}
+declare function useCilantroConfig(): UseCilantroConfigResult;
+
+interface UseAuthResult {
+    user: User | null;
+    jwt: string | null;
     isLoading: boolean;
-    refreshWallets: () => Promise<void>;
+    isAuthenticated: boolean;
+    login: (params: {
+        usernameOrEmail: string;
+        password: string;
+    }) => Promise<void>;
+    logout: () => void;
 }
-/**
- * Returns the currently selected wallet, loading state, and refresh.
- * Use when you only need the current wallet, not the full wallet list.
- * Must be used inside CilantroProvider (WalletProvider).
- */
-declare function useSelectedWallet(): UseSelectedWalletResult;
+declare function useAuth(): UseAuthResult;
 
-/**
- * Returns the address of the currently selected wallet.
- * Handles both `address` and `walletAddress` on WalletData.
- * Must be used inside CilantroProvider (WalletProvider).
- */
-declare function useWalletAddress(): string | null;
+interface UseWalletResult {
+    wallet: WalletData | null;
+    wallets: WalletData[];
+    createWallet: (params: {
+        name: string;
+        userId?: string;
+    }) => Promise<WalletControllerCreateResult>;
+    selectWallet: (walletId: string) => void;
+    isLoading: boolean;
+}
+declare function useWallet(_walletId?: string): UseWalletResult;
 
 /**
  * Normalized signer shape aligned with SDK SignerDataDto / WalletSignerDataDto.
@@ -112,6 +168,11 @@ interface SignerData extends Omit<SignerInfo, "signerId"> {
     signerCategory?: "onchain" | "authenticationsigner";
     [key: string]: unknown;
 }
+/**
+ * Normalize a raw signer DTO to SignerData (id, signerId, signerPubkey/publicKey, etc.).
+ * Use at API boundaries when ingesting signer data from the SDK.
+ */
+declare function normalizeSigner(signer: Record<string, unknown>, category: "onchain" | "authenticationsigner"): SignerData;
 
 interface UseSignersOptions {
     /** Wallet ID to load signers for. If not provided, uses selectedWallet?.id from context (call useWallets() in same component). */
@@ -122,393 +183,82 @@ interface UseSignersResult {
     isLoading: boolean;
     error: string | null;
     refresh: () => Promise<void>;
-}
-declare function useSigners(options?: UseSignersOptions): UseSignersResult;
-
-type SignersListResponseDto = WalletControllerListSignersResult;
-interface UseSignersRawOptions {
-    /** Wallet ID to load signers for. When null/undefined, response is null. */
-    walletId?: string | null;
-}
-interface UseSignersRawResult {
-    /** Exact SDK response from listSigners (success, data: { authenticationSigners, onChainSigners }). */
-    signersRaw: SignersListResponseDto | null;
-    isLoading: boolean;
-    error: string | null;
-    refresh: () => Promise<void>;
-}
-/**
- * Load signers for a wallet and return the exact SDK shape (SignersListResponseDto).
- * Use when you need SDK-exact output; for a normalized list use useSigners instead.
- * Must be used inside CilantroProvider (auth required).
- */
-declare function useSignersRaw(options?: UseSignersRawOptions): UseSignersRawResult;
-
-interface UseSignersForSelectedWalletOptions {
-    /** Override wallet ID; when omitted, uses the selected wallet from context. */
-    walletId?: string | null;
-}
-/**
- * Returns signers for the currently selected wallet (or the given walletId override).
- * Composes useWallets + useSigners so you don't have to pass walletId yourself.
- * Must be used inside CilantroProvider.
- */
-declare function useSignersForSelectedWallet(options?: UseSignersForSelectedWalletOptions): UseSignersResult;
-
-/** SDK delegated key type (element of DelegatedKeysListResponseDto.data). Canonical id is delegatedKeyId. */
-type DelegatedKeyDataDto = DelegatedKeyControllerFindAllResult["data"] extends readonly (infer E)[] ? E : DelegatedKeyControllerFindAllResult["data"] extends (infer E)[] ? E : never;
-/** DelegatedKeyDataDto with backward-compat id alias (id = delegatedKeyId) for existing UI. */
-type DelegatedKeyData = DelegatedKeyDataDto & {
-    id?: string;
-};
-interface UseDelegatedKeysOptions {
-    /** Wallet ID to load delegated keys for. When null/undefined, keys are empty. */
-    walletId?: string | null;
-    /** When true (default), filter to active keys and non-expired only. */
-    filterActive?: boolean;
-}
-interface UseDelegatedKeysResult {
-    keys: DelegatedKeyData[];
+    createEmailSigner: (params: {
+        email: string;
+    }) => Promise<SignerInfo>;
+    createPhoneSigner: (params: {
+        phone: string;
+    }) => Promise<SignerInfo>;
+    revokeSigner: (signerId: string) => Promise<void>;
+}
+declare function useSigners(walletIdOrOptions?: string | null | UseSignersOptions): UseSignersResult;
+
+interface UsePasskeyResult {
+    isSupported: boolean;
+    register: () => Promise<{
+        signerId: string;
+        isNew: boolean;
+        credentialId?: string;
+    }>;
+    authenticate: (signerId?: string) => Promise<{
+        signature: string;
+        signerId: string;
+    }>;
     isLoading: boolean;
-    error: string | null;
-    refresh: () => Promise<void>;
 }
-/**
- * Load delegated keys for a wallet. Use for custom delegated-key UI or logic.
- * Must be used inside CilantroProvider (auth required).
- */
-declare function useDelegatedKeys(options?: UseDelegatedKeysOptions): UseDelegatedKeysResult;
-
-type SigningMethod = "wallet-adapter" | "sdk-signer";
-interface UseSignerSelectionOptions {
-    /** Override wallet ID; if not set, uses selected wallet from WalletProvider */
-    walletId?: string | null;
-    /** Current signing method */
-    signingMethod?: SigningMethod | null;
-}
-interface UseSignerSelectionResult {
-    selectedWalletId: string;
-    setSelectedWalletId: (id: string) => void;
-    availableSigners: SignerData[];
-    selectedSigner: SignerData | null;
-    setSelectedSigner: (signer: SignerData | null) => void;
-    isLoadingSigners: boolean;
-    reset: () => void;
-}
-declare function useSignerSelection(options?: UseSignerSelectionOptions): UseSignerSelectionResult;
-
-interface UseCanSignOptions {
-    /** Override signing method; when omitted, uses default "sdk-signer". */
-    signingMethod?: SigningMethod | null;
-    /** When true (default for sdk-signer), require a selected signer. When false, only wallet is required. */
-    requireSigner?: boolean;
-    /** When using wallet-adapter, pass true when the adapter is connected. Omit if not using wallet-adapter. */
-    walletAdapterConnected?: boolean;
-}
-interface UseCanSignResult {
-    /** True when the user has a valid token. */
-    hasToken: boolean;
-    /** True when a wallet is selected. */
-    hasWallet: boolean;
-    /** True when a signer is selected (sdk-signer) or wallet-adapter is connected (when walletAdapterConnected is passed). */
-    hasSigner: boolean;
-    /** True when ready to sign a message (hasToken + hasWallet + hasSigner for current method). */
-    canSignMessage: boolean;
-    /** True when ready to sign/send a transaction (same as canSignMessage; connection is required for send). */
-    canSignTransaction: boolean;
-}
-/**
- * Derived "is the user ready to sign?" for disabling sign buttons or showing prompts.
- * For wallet-adapter, pass walletAdapterConnected when your adapter is connected so canSign reflects it.
- * Must be used inside CilantroProvider.
- */
-declare function useCanSign(options?: UseCanSignOptions): UseCanSignResult;
-
-/**
- * Type Utilities - common types and utilities for SDK interactions
- */
-type ActionState<T = unknown> = {
-    status: "idle" | "loading" | "success" | "error";
-    message?: string;
-    detail?: T;
-};
-interface ErrorResponse {
-    message?: string;
-    error?: string;
-    code?: string | number;
-    status?: number;
-    statusText?: string;
-    data?: unknown;
-    stack?: string;
-    type?: string;
-}
-type ApiResponse<T> = T | {
-    data: T;
-} | {
-    success: boolean;
-    data: T;
-};
-declare function extractResponseData<T>(response: unknown): T | null;
+declare function usePasskey(walletId: string | undefined): UsePasskeyResult;
 
-interface UseMessageSigningOptions {
-    token: string | null;
-    signingMethod: SigningMethod | null;
-    selectedSigner: SignerData | null;
-    selectedWalletId: string;
-    /** Optional: callback when using wallet-adapter; signMessage(encodedMessage) => signature bytes */
-    walletAdapterSignMessage?: (message: Uint8Array) => Promise<Uint8Array>;
-    /** Optional: public key when using wallet-adapter (for result) */
-    walletAdapterPublicKey?: string | null;
-}
-interface UseMessageSigningResult {
-    messageText: string;
-    setMessageText: (text: string) => void;
-    signResultState: ActionState;
-    isSigning: boolean;
-    handleSign: () => Promise<void>;
-    reset: () => void;
-}
-declare function useMessageSigning(options: UseMessageSigningOptions): UseMessageSigningResult;
-
-interface UseTransactionSigningOptions {
-    token: string | null;
-    signingMethod: SigningMethod | null;
-    selectedSigner: SignerData | null;
-    selectedWalletId: string;
-    /** Optional: wallet-adapter signTransaction(transaction) => signed transaction */
-    walletAdapterSignTransaction?: (transaction: Transaction) => Promise<Transaction>;
-    /** Optional: wallet-adapter public key (for building/sending) */
-    walletAdapterPublicKey?: string | null;
-    /** Optional: connection for sending (e.g. from @solana/web3.js). Used for wallet-adapter send. */
-    connection?: {
-        sendRawTransaction: (buf: Buffer) => Promise<string>;
-        getLatestBlockhash: () => Promise<{
-            blockhash: string;
-            lastValidBlockHeight: number;
-        }>;
-        confirmTransaction: (opts: {
-            signature: string;
-            blockhash: string;
-            lastValidBlockHeight: number;
-        }) => Promise<void>;
+/** Minimal Solana wallet interface (Phantom, Solflare, etc.) */
+interface SolanaWallet {
+    name: string;
+    publicKey: {
+        toString: () => string;
     } | null;
+    connect: () => Promise<{
+        publicKey: {
+            toString: () => string;
+        };
+    }>;
+    disconnect: () => Promise<void>;
+}
+declare global {
+    interface Window {
+        solana?: SolanaWallet & {
+            isPhantom?: boolean;
+        };
+        solflare?: SolanaWallet;
+    }
+}
+interface UseExternalWalletResult {
+    wallets: SolanaWallet[];
+    connectedWallet: SolanaWallet | null;
+    connect: (wallet: SolanaWallet) => Promise<string>;
+    disconnect: () => Promise<void>;
+}
+declare function useExternalWallet(): UseExternalWalletResult;
+
+type SignerType$2 = "email" | "phone" | "passkey" | "external";
+interface SubmitTransactionResult {
+    success: boolean;
+    data: {
+        signature?: string;
+        [key: string]: unknown;
+    };
 }
-interface UseTransactionSigningResult {
-    transactionResultState: ActionState;
-    isSigningTransaction: boolean;
-    isSendingTransaction: boolean;
-    signTransaction: (transaction: Transaction) => Promise<void>;
-    signAndSendTransaction: (transaction: Transaction) => Promise<void>;
-    reset: () => void;
-}
-declare function useTransactionSigning(options: UseTransactionSigningOptions): UseTransactionSigningResult;
-
-interface WalletSelectorClassNames {
-    root?: string;
-    trigger?: string;
-    content?: string;
-    item?: string;
-    skeleton?: string;
-    loading?: string;
-}
-interface WalletSelectorProps {
-    value?: string;
-    onWalletChange?: (walletId: string, wallet: WalletData | null) => void;
-    className?: string;
-    classNames?: WalletSelectorClassNames;
-    /** When true (default), show skeleton in trigger while loading; when false, show "Loading..." text. */
-    useSkeleton?: boolean;
-    placeholder?: string;
-    renderTrigger?: (props: {
-        selectedWallet: WalletData | null;
-        wallets: WalletData[];
-        isLoading: boolean;
-        open: boolean;
-        setOpen: (open: boolean) => void;
-    }) => React.ReactNode;
-    renderList?: (props: {
-        wallets: WalletData[];
-        selectedWallet: WalletData | null;
-        onSelect: (wallet: WalletData) => void;
-        isLoading: boolean;
-    }) => React.ReactNode;
-    children?: (props: {
-        wallets: WalletData[];
-        selectedWallet: WalletData | null;
-        selectWallet: (walletId: string) => void;
-        isLoading: boolean;
-        refreshWallets: () => Promise<void>;
-    }) => React.ReactNode;
-}
-declare function WalletSelector(props: WalletSelectorProps): react_jsx_runtime.JSX.Element;
-
-interface SignerSelectorClassNames {
-    root?: string;
-    list?: string;
-    item?: string;
-    message?: string;
-    skeleton?: string;
-    loading?: string;
-}
-interface SignerSelectorProps {
-    /** Wallet ID (signers are loaded for this wallet when used with useSigners) */
-    selectedWalletId?: string;
-    /** Available signers (from useSigners or useSignerSelection) */
-    availableSigners: SignerData[];
-    /** Currently selected signer */
-    selectedSigner: SignerData | null;
-    /** Loading state */
-    isLoadingSigners?: boolean;
-    /** Callback when user selects a signer */
-    onSignerSelect: (signer: SignerData) => void;
-    /** Root class */
-    className?: string;
-    /** Override class names for sub-elements */
-    classNames?: SignerSelectorClassNames;
-    /** When true (default), show skeleton rows while loading; when false, show "Loading signers..." text. */
-    useSkeleton?: boolean;
-    /** Custom list render (headless) */
-    renderList?: (props: {
-        signers: SignerData[];
-        selectedSigner: SignerData | null;
-        onSelect: (signer: SignerData) => void;
-        isLoading: boolean;
-        getSignerDisplayName: (s: SignerData) => string;
-        getSignerTypeLabel: (type: string) => string;
-        getSignerUniqueId: (s: SignerData) => string;
-    }) => React.ReactNode;
-    /** Children render props */
-    children?: (props: {
-        signers: SignerData[];
-        selectedSigner: SignerData | null;
-        onSignerSelect: (signer: SignerData) => void;
-        isLoading: boolean;
-    }) => React.ReactNode;
-}
-declare function SignerSelector({ selectedWalletId, availableSigners, selectedSigner, isLoadingSigners, onSignerSelect, className, classNames, useSkeleton, renderList, children, }: SignerSelectorProps): react_jsx_runtime.JSX.Element | null;
-
-interface DelegatedKeySelectorClassNames {
-    root?: string;
-    trigger?: string;
-    content?: string;
-    item?: string;
-    message?: string;
-    skeleton?: string;
-    loading?: string;
-}
-interface DelegatedKeySelectorProps {
-    walletId: string;
-    value?: string;
-    onChange?: (delegatedKeyId: string, key: DelegatedKeyData | null) => void;
-    filterActive?: boolean;
-    className?: string;
-    classNames?: DelegatedKeySelectorClassNames;
-    /** When true (default), show skeleton trigger while loading; when false, show "Loading delegated keys..." text. */
-    useSkeleton?: boolean;
-    placeholder?: string;
-    children?: (props: {
-        keys: DelegatedKeyData[];
-        selectedKeyId: string | undefined;
-        onSelect: (key: DelegatedKeyData) => void;
-        isLoading: boolean;
-        error: string | null;
-        refresh: () => Promise<void>;
-    }) => React.ReactNode;
-}
-declare function DelegatedKeySelector(props: DelegatedKeySelectorProps): react_jsx_runtime.JSX.Element;
-
-interface MessageSigningFormClassNames {
-    root?: string;
-    header?: string;
-    title?: string;
-    description?: string;
-    context?: string;
-    label?: string;
-    textarea?: string;
-    charCount?: string;
-    button?: string;
-    resetButton?: string;
-    result?: string;
-    resultSuccess?: string;
-    resultError?: string;
-    resultPre?: string;
-}
-interface MessageSigningFormProps {
-    /** Optional: override token (default: from useCilantroAuth) */
-    token?: string | null;
-    /** Optional: override wallet/signer (default: from useSignerSelection) */
-    selectedWalletId?: string;
-    selectedSigner?: SignerData | null;
-    signingMethod?: SigningMethod | null;
-    /** Optional: wallet-adapter sign message (when signingMethod === "wallet-adapter") */
-    walletAdapterSignMessage?: (message: Uint8Array) => Promise<Uint8Array>;
-    walletAdapterPublicKey?: string | null;
-    /** Root class */
-    className?: string;
-    /** Override class names for sub-elements */
-    classNames?: MessageSigningFormClassNames;
-    /** Show wallet/signer context above the form (default: true when wallet/signer selected) */
-    showContext?: boolean;
-    /** Show character count below textarea (default: false) */
-    showCharCount?: boolean;
-    /** Headless: render form content */
-    children?: (props: {
-        messageText: string;
-        setMessageText: (text: string) => void;
-        signResultState: ActionState;
-        isSigning: boolean;
-        handleSign: () => Promise<void>;
-        reset: () => void;
-    }) => React.ReactNode;
-}
-declare function MessageSigningForm({ token: tokenOverride, selectedWalletId: walletIdOverride, selectedSigner: signerOverride, signingMethod: methodOverride, walletAdapterSignMessage, walletAdapterPublicKey, className, classNames, showContext, showCharCount, children, }: MessageSigningFormProps): react_jsx_runtime.JSX.Element;
-
-interface TransactionSigningFormClassNames {
-    root?: string;
-    header?: string;
-    title?: string;
-    description?: string;
-    context?: string;
-    button?: string;
-    result?: string;
-    resultSuccess?: string;
-    resultError?: string;
-    resultPre?: string;
-}
-interface TransactionSigningFormProps {
-    token?: string | null;
-    selectedWalletId?: string;
-    selectedSigner?: SignerData | null;
-    signingMethod?: SigningMethod | null;
-    walletAdapterSignTransaction?: (tx: Transaction) => Promise<Transaction>;
-    walletAdapterPublicKey?: string | null;
-    connection?: {
-        sendRawTransaction: (buf: Buffer) => Promise<string>;
-        getLatestBlockhash: () => Promise<{
-            blockhash: string;
-            lastValidBlockHeight: number;
-        }>;
-        confirmTransaction: (opts: {
-            signature: string;
-            blockhash: string;
-            lastValidBlockHeight: number;
-        }) => Promise<void>;
-    } | null;
-    className?: string;
-    classNames?: TransactionSigningFormClassNames;
-    /** Show wallet/signer context above the form (default: true when wallet/signer selected) */
-    showContext?: boolean;
-    /** Headless: render content; consumer builds transaction and calls signTransaction(tx) / signAndSendTransaction(tx) */
-    children?: (props: {
-        transactionResultState: ActionState;
-        isSigningTransaction: boolean;
-        isSendingTransaction: boolean;
-        signTransaction: (transaction: Transaction) => Promise<void>;
-        signAndSendTransaction: (transaction: Transaction) => Promise<void>;
-        reset: () => void;
-    }) => React.ReactNode;
+interface UseSendTransactionResult {
+    sendSOL: (params: {
+        recipientAddress: string;
+        amountLamports: number;
+    }) => Promise<SubmitTransactionResult>;
+    sendSPL: (params: {
+        mintAddress: string;
+        recipientAddress: string;
+        amount: number;
+    }) => Promise<SubmitTransactionResult>;
+    isPending: boolean;
+    error: string | null;
 }
-declare function TransactionSigningForm({ token: tokenOverride, selectedWalletId: walletIdOverride, selectedSigner: signerOverride, signingMethod: methodOverride, walletAdapterSignTransaction, walletAdapterPublicKey, connection, className, classNames, showContext, children, }: TransactionSigningFormProps): react_jsx_runtime.JSX.Element;
+declare function useSendTransaction(walletId: string | undefined, _signerId?: string, _signerType?: SignerType$2): UseSendTransactionResult;
 
 interface LoginFormClassNames {
     root?: string;
@@ -524,8 +274,10 @@ interface LoginFormClassNames {
 interface LoginFormProps {
     className?: string;
     classNames?: LoginFormClassNames;
+    style?: React.CSSProperties;
     onSuccess?: () => void;
-    onError?: (error: string) => void;
+    onError?: (error: Error) => void;
+    rememberMe?: boolean;
     /** Override submit button label */
     submitLabel?: string;
     /** Override title */
@@ -535,78 +287,15 @@ interface LoginFormProps {
     /** Render "Create account" link (e.g. to switch to register). Shown below submit. */
     renderSwitchToRegister?: () => React.ReactNode;
 }
-declare function LoginForm({ className, classNames, onSuccess, onError, submitLabel, title, description, renderSwitchToRegister, }: LoginFormProps): react_jsx_runtime.JSX.Element;
+declare function LoginForm({ className, classNames, style, onSuccess, onError, submitLabel, title, description, renderSwitchToRegister, }: LoginFormProps): react_jsx_runtime.JSX.Element;
 
-interface RegisterFormClassNames {
-    root?: string;
-    header?: string;
-    title?: string;
-    description?: string;
-    form?: string;
-    label?: string;
-    input?: string;
-    submitButton?: string;
-    error?: string;
-}
-interface RegisterFormProps {
+interface LogoutButtonProps {
+    onLogout?: () => void;
+    confirmBeforeLogout?: boolean;
     className?: string;
-    classNames?: RegisterFormClassNames;
-    onSuccess?: () => void;
-    onError?: (error: string) => void;
-    /** Override submit button label */
-    submitLabel?: string;
-    /** Override title */
-    title?: string;
-    /** Override description */
-    description?: string;
-    /** Default is true (user is active after registration) */
-    isActive?: boolean;
-    /** Render "Already have an account? Sign in" link. Shown below submit. */
-    renderSwitchToLogin?: () => React.ReactNode;
-}
-declare function RegisterForm({ className, classNames, onSuccess, onError, submitLabel, title, description, isActive, renderSwitchToLogin, }: RegisterFormProps): react_jsx_runtime.JSX.Element;
-
-type AuthFormMode = "login" | "register";
-interface AuthFormClassNames {
-    root?: string;
-    header?: string;
-    title?: string;
-    description?: string;
-    form?: string;
-    label?: string;
-    input?: string;
-    submitButton?: string;
-    toggle?: string;
-    toggleLink?: string;
-    error?: string;
+    children?: ReactNode;
 }
-interface AuthFormProps {
-    /** Initial mode: login or register */
-    defaultMode?: AuthFormMode;
-    className?: string;
-    classNames?: AuthFormClassNames;
-    onSuccess?: () => void;
-    onError?: (error: string) => void;
-    /** Login: submit button label */
-    loginSubmitLabel?: string;
-    /** Register: submit button label */
-    registerSubmitLabel?: string;
-    /** Login: title */
-    loginTitle?: string;
-    /** Register: title */
-    registerTitle?: string;
-    /** Login: description */
-    loginDescription?: string;
-    /** Register: description */
-    registerDescription?: string;
-    /** Text for "switch to register" link */
-    switchToRegisterText?: string;
-    /** Text for "switch to login" link */
-    switchToLoginText?: string;
-    /** Default is true (user is active after registration) */
-    isActive?: boolean;
-}
-declare function AuthForm({ defaultMode, className, classNames, onSuccess, onError, loginSubmitLabel, registerSubmitLabel, loginTitle, registerTitle, loginDescription, registerDescription, switchToRegisterText, switchToLoginText, isActive, }: AuthFormProps): react_jsx_runtime.JSX.Element;
+declare function LogoutButton({ onLogout, confirmBeforeLogout, className, children, }: LogoutButtonProps): react_jsx_runtime.JSX.Element;
 
 interface AuthGuardClassNames {
     root?: string;
@@ -618,6 +307,8 @@ interface AuthGuardProps {
     children: ReactNode;
     /** Shown when not authenticated. Default: <LoginForm /> */
     fallback?: ReactNode;
+    /** If using a router, redirect to this path when not authenticated (consumer can pass fallback={<Navigate to={redirectTo} />}) */
+    redirectTo?: string;
     /** Root class when showing fallback */
     className?: string;
     classNames?: AuthGuardClassNames;
@@ -628,34 +319,34 @@ interface AuthGuardProps {
 }
 /**
  * Wraps content and shows fallback (e.g. LoginForm) when the user is not authenticated.
- * Use inside CilantroAuthProvider.
+ * Use inside CilantroProvider.
  */
-declare function AuthGuard({ children, fallback, className, classNames, showFallback, useSkeleton, }: AuthGuardProps): react_jsx_runtime.JSX.Element | null;
+declare function AuthGuard({ children, fallback, redirectTo, className, classNames, showFallback, useSkeleton, }: AuthGuardProps): react_jsx_runtime.JSX.Element | null;
 
-type AddSignerType = "email" | "phone" | "passkey" | "external";
-interface AddSignerFormClassNames {
-    root?: string;
-    dialog?: string;
-    form?: string;
-    label?: string;
-    input?: string;
-    submitButton?: string;
-    cancelButton?: string;
-    error?: string;
+interface CreateEmailSignerFormProps {
+    walletId: string;
+    onCreated?: (signer: SignerInfo) => void;
+    onError?: (error: Error) => void;
+    className?: string;
 }
-interface AddSignerFormProps {
+declare function CreateEmailSignerForm({ walletId, onCreated, onError, className, }: CreateEmailSignerFormProps): react_jsx_runtime.JSX.Element;
+
+interface CreatePhoneSignerFormProps {
     walletId: string;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    onSuccess?: () => void;
-    onCancel?: () => void;
-    onError?: (error: string) => void;
+    onCreated?: (signer: SignerInfo) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function CreatePhoneSignerForm({ walletId, onCreated, onError, className, }: CreatePhoneSignerFormProps): react_jsx_runtime.JSX.Element;
+
+interface AddPasskeyButtonProps {
+    walletId: string;
+    onRegistered?: (signer: SignerInfo) => void;
+    onError?: (error: Error) => void;
     className?: string;
-    classNames?: AddSignerFormClassNames;
-    /** When true, render as a dialog. When false, render inline. */
-    asDialog?: boolean;
+    children?: ReactNode;
 }
-declare function AddSignerForm({ walletId, open, onOpenChange, onSuccess, onCancel, onError, className, classNames, asDialog, }: AddSignerFormProps): react_jsx_runtime.JSX.Element;
+declare function AddPasskeyButton({ walletId, onRegistered, onError, className, children, }: AddPasskeyButtonProps): react_jsx_runtime.JSX.Element | null;
 
 interface SignerListClassNames {
     root?: string;
@@ -669,13 +360,11 @@ interface SignerListClassNames {
 }
 interface SignerListProps {
     walletId: string;
+    onRevoke?: (signerId: string) => void;
     className?: string;
     classNames?: SignerListClassNames;
-    /** Callback when a signer is added (e.g. to refresh parent state) */
     onSignerAdded?: () => void;
-    /** When true (default), show skeleton rows while loading; when false, show "Loading signers..." text. */
     useSkeleton?: boolean;
-    /** Custom render for the list of signers */
     children?: (props: {
         signers: SignerData[];
         isLoading: boolean;
@@ -684,30 +373,7 @@ interface SignerListProps {
         openAddSigner: () => void;
     }) => React.ReactNode;
 }
-declare function SignerList({ walletId, className, classNames, onSignerAdded, useSkeleton, children, }: SignerListProps): react_jsx_runtime.JSX.Element;
-
-interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement> {
-}
-declare const Skeleton: React$1.ForwardRefExoticComponent<SkeletonProps & React$1.RefAttributes<HTMLDivElement>>;
-
-type Theme = "light" | "dark" | "system";
-type ResolvedTheme = "light" | "dark";
-interface ThemeProviderProps {
-    /** Current theme: "light", "dark", or "system" (follows prefers-color-scheme). */
-    theme?: Theme;
-    /** Default theme when theme is "system" or for initial render. */
-    defaultTheme?: ResolvedTheme;
-    /** Optional localStorage key for persisting theme when using "system". */
-    storageKey?: string;
-    /** Optional class for the wrapper div. */
-    className?: string;
-    children: React$1.ReactNode;
-    /** When true, inject the default theme CSS variables (light/dark). Your app must still use Tailwind. */
-    injectStyles?: boolean;
-}
-declare function ThemeProvider({ theme, defaultTheme, storageKey, className, children, injectStyles, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
-
-declare function extractErrorMessage(error: unknown): string;
+declare function SignerList({ walletId, onRevoke, className, classNames, onSignerAdded, useSkeleton, children, }: SignerListProps): react_jsx_runtime.JSX.Element;
 
 declare function getSignerPublicKey(walletId: string, signer: SignerData, signerType: string, signerId: string): Promise<PublicKey>;
 
@@ -761,6 +427,293 @@ declare const SIGNER_TYPES: {
     readonly EXTERNAL: "external";
     readonly API_KEY: "apiKey";
 };
-type SignerType = (typeof SIGNER_TYPES)[keyof typeof SIGNER_TYPES];
+type SignerType$1 = (typeof SIGNER_TYPES)[keyof typeof SIGNER_TYPES];
+
+interface SignerSelectorClassNames {
+    root?: string;
+    list?: string;
+    item?: string;
+    message?: string;
+    skeleton?: string;
+    loading?: string;
+}
+/** Guide API: walletId + value + onChange(signerId, signerType) */
+interface SignerSelectorProps {
+    walletId: string;
+    value?: string;
+    onChange: (signerId: string, signerType: SignerType$1) => void;
+    className?: string;
+    classNames?: SignerSelectorClassNames;
+    useSkeleton?: boolean;
+    /** Legacy: when provided with availableSigners/selectedSigner/onSignerSelect, use legacy API */
+    selectedWalletId?: string;
+    availableSigners?: SignerData[];
+    selectedSigner?: SignerData | null;
+    isLoadingSigners?: boolean;
+    onSignerSelect?: (signer: SignerData) => void;
+    renderList?: (props: {
+        signers: SignerData[];
+        selectedSigner: SignerData | null;
+        onSelect: (signer: SignerData) => void;
+        isLoading: boolean;
+        getSignerDisplayName: (s: SignerData) => string;
+        getSignerTypeLabel: (type: string) => string;
+        getSignerUniqueId: (s: SignerData) => string;
+    }) => React.ReactNode;
+    children?: (props: {
+        signers: SignerData[];
+        selectedSigner: SignerData | null;
+        onSignerSelect: (signer: SignerData) => void;
+        isLoading: boolean;
+    }) => React.ReactNode;
+}
+declare function SignerSelector({ walletId, value, onChange, className, classNames, useSkeleton, selectedWalletId, availableSigners: availableSignersProp, selectedSigner: selectedSignerProp, isLoadingSigners: isLoadingSignersProp, onSignerSelect, renderList, children, }: SignerSelectorProps): react_jsx_runtime.JSX.Element | null;
+
+interface ConnectWalletButtonProps {
+    onConnect?: (publicKey: string, wallet: SolanaWallet) => void;
+    onDisconnect?: () => void;
+    className?: string;
+    children?: ReactNode;
+}
+declare function ConnectWalletButton({ onConnect, onDisconnect, className, children, }: ConnectWalletButtonProps): react_jsx_runtime.JSX.Element;
+
+interface CreateWalletFormProps {
+    userId?: string;
+    onCreated?: (wallet: WalletControllerCreateResult) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function CreateWalletForm({ userId, onCreated, onError, className, }: CreateWalletFormProps): react_jsx_runtime.JSX.Element;
+
+interface WalletSelectorClassNames {
+    root?: string;
+    trigger?: string;
+    content?: string;
+    item?: string;
+    skeleton?: string;
+    loading?: string;
+}
+interface WalletSelectorProps {
+    value?: string;
+    onChange?: (walletId: string) => void;
+    onWalletChange?: (walletId: string, wallet: WalletData | null) => void;
+    className?: string;
+    classNames?: WalletSelectorClassNames;
+    useSkeleton?: boolean;
+    placeholder?: string;
+    renderTrigger?: (props: {
+        selectedWallet: WalletData | null;
+        wallets: WalletData[];
+        isLoading: boolean;
+        open: boolean;
+        setOpen: (open: boolean) => void;
+    }) => React.ReactNode;
+    renderList?: (props: {
+        wallets: WalletData[];
+        selectedWallet: WalletData | null;
+        onSelect: (wallet: WalletData) => void;
+        isLoading: boolean;
+    }) => React.ReactNode;
+    children?: (props: {
+        wallets: WalletData[];
+        selectedWallet: WalletData | null;
+        selectWallet: (walletId: string) => void;
+        isLoading: boolean;
+        refreshWallets: () => Promise<void>;
+    }) => React.ReactNode;
+}
+declare function WalletSelector(props: WalletSelectorProps): react_jsx_runtime.JSX.Element;
+
+interface WalletAddressProps {
+    address: string;
+    short?: boolean;
+    copyable?: boolean;
+    className?: string;
+}
+declare function WalletAddress({ address, short, copyable, className, }: WalletAddressProps): react_jsx_runtime.JSX.Element;
+
+interface WalletBalanceProps {
+    walletId: string;
+    showTokens?: boolean;
+    className?: string;
+}
+declare function WalletBalance({ walletId, showTokens, className, }: WalletBalanceProps): react_jsx_runtime.JSX.Element;
+
+type SignerType = "email" | "phone" | "passkey" | "external";
+interface SendSOLFormProps {
+    walletId: string;
+    signerId?: string;
+    signerType?: SignerType;
+    onSuccess?: (result: SubmitTransactionResult) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function SendSOLForm({ walletId, signerId, signerType, onSuccess, onError, className, }: SendSOLFormProps): react_jsx_runtime.JSX.Element;
+
+interface SendSPLFormProps {
+    walletId: string;
+    signerId?: string;
+    signerType?: SignerType$2;
+    mintAddress?: string;
+    onSuccess?: (result: SubmitTransactionResult) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function SendSPLForm({ walletId, signerId, signerType, mintAddress: initialMint, onSuccess, onError, className, }: SendSPLFormProps): react_jsx_runtime.JSX.Element;
+
+interface TransactionStatusProps {
+    signature: string;
+    cluster?: "mainnet-beta" | "devnet" | "testnet";
+    className?: string;
+}
+declare function TransactionStatus({ signature, cluster, className, }: TransactionStatusProps): react_jsx_runtime.JSX.Element;
+
+interface TransactionHistoryProps {
+    walletId: string;
+    pageSize?: number;
+    className?: string;
+}
+declare function TransactionHistory({ walletId, pageSize, className, }: TransactionHistoryProps): react_jsx_runtime.JSX.Element;
+
+interface WalletInfo extends WalletData {
+}
+interface CilantroConnectProps {
+    onConnect?: (wallet: WalletInfo, signers: SignerInfo[]) => void;
+    onDisconnect?: () => void;
+    className?: string;
+}
+declare function CilantroConnect({ onConnect, onDisconnect, className, }: CilantroConnectProps): react_jsx_runtime.JSX.Element;
+
+interface LoadingOverlayProps {
+    isLoading: boolean;
+    message?: string;
+    children: ReactNode;
+    className?: string;
+}
+declare function LoadingOverlay({ isLoading, message, children, className, }: LoadingOverlayProps): react_jsx_runtime.JSX.Element;
+
+interface ErrorBoundaryProps {
+    fallback?: ReactNode;
+    onRetry?: () => void;
+    children: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleRetry: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+}
+
+interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const Skeleton: React$1.ForwardRefExoticComponent<SkeletonProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type Theme = "light" | "dark" | "system";
+type ResolvedTheme = "light" | "dark";
+interface ThemeProviderProps {
+    /** Current theme: "light", "dark", or "system" (follows prefers-color-scheme). */
+    theme?: Theme;
+    /** Default theme when theme is "system" or for initial render. */
+    defaultTheme?: ResolvedTheme;
+    /** Optional localStorage key for persisting theme when using "system". */
+    storageKey?: string;
+    /** Optional class for the wrapper div. */
+    className?: string;
+    children: React$1.ReactNode;
+    /** When true, inject the default theme CSS variables (light/dark). Your app must still use Tailwind. */
+    injectStyles?: boolean;
+}
+declare function ThemeProvider({ theme, defaultTheme, storageKey, className, children, injectStyles, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Type Utilities - common types and utilities for SDK interactions
+ */
+type ActionState<T = unknown> = {
+    status: "idle" | "loading" | "success" | "error";
+    message?: string;
+    detail?: T;
+};
+interface ErrorResponse {
+    message?: string;
+    error?: string;
+    code?: string | number;
+    status?: number;
+    statusText?: string;
+    data?: unknown;
+    stack?: string;
+    type?: string;
+}
+type ApiResponse<T> = T | {
+    data: T;
+} | {
+    success: boolean;
+    data: T;
+};
+declare function extractResponseData<T>(response: unknown): T | null;
+
+/**
+ * Normalization at the boundary: map SDK DTOs to a consistent shape with id/address (and aliases).
+ * Use these when ingesting wallet/signer data from the SDK so consumers can rely on id and address.
+ */
+/** Normalized wallet shape: always has id and address. */
+interface NormalizedWallet {
+    id: string;
+    address: string;
+    active?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Normalize a wallet DTO so that id and address are always present.
+ * Use at the boundary when loading wallets from the SDK.
+ * Accepts any object with optional walletId/id, walletAddress/address, isActive.
+ */
+declare function normalizeWallet(dto: Record<string, unknown>): NormalizedWallet;
+
+declare function extractErrorMessage(error: unknown): string;
+declare function isAuthError(error: unknown): boolean;
+
+/**
+ * Check if a JWT is expired using the payload `exp` claim.
+ * @param token - JWT string (assumes 3 segments separated by dots).
+ * @param bufferSeconds - Optional buffer in seconds; if exp is within this many seconds of now, treat as expired (default 60).
+ * @returns true if token is expired or invalid/not a JWT.
+ */
+declare function isJwtExpired(token: string, bufferSeconds?: number): boolean;
+
+/**
+ * Adapter to use @solana/web3.js Connection for sign-and-send (advanced usage).
+ * Pass the result as the connection prop so you don't need type assertions.
+ */
+
+/** Connection shape expected for sign-and-send (advanced usage). */
+interface SignAndSendConnectionAdapter {
+    sendRawTransaction: (buf: Buffer) => Promise<string>;
+    getLatestBlockhash: () => Promise<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>;
+    confirmTransaction: (opts: {
+        signature: string;
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }) => Promise<void>;
+}
+/**
+ * Wrap a @solana/web3.js Connection for sign-and-send (advanced usage).
+ * Use when you have a Solana Connection and need the adapter shape without type assertions.
+ *
+ * @example
+ * import { Connection } from '@solana/web3.js';
+ * import { adaptSolanaConnection } from 'cilantro-react';
+ *
+ * const connection = new Connection(rpcUrl);
+ * const adapter = adaptSolanaConnection(connection);
+ */
+declare function adaptSolanaConnection(connection: Connection): SignAndSendConnectionAdapter;
 
-export { type ActionState, AddSignerForm, type AddSignerFormClassNames, type AddSignerFormProps, type AddSignerType, type ApiResponse, AuthForm, type AuthFormClassNames, type AuthFormMode, type AuthFormProps, AuthGuard, type AuthGuardClassNames, type AuthGuardProps, type CilantroAuthContextType, CilantroAuthProvider, type CilantroAuthProviderProps, CilantroProvider, type DelegatedKeyData, type DelegatedKeyDataDto, DelegatedKeySelector, type DelegatedKeySelectorClassNames, type DelegatedKeySelectorProps, type ErrorResponse, LoginForm, type LoginFormClassNames, type LoginFormProps, MessageSigningForm, type MessageSigningFormClassNames, type MessageSigningFormProps, RegisterForm, type RegisterFormClassNames, type RegisterFormProps, type ResolvedTheme, SIGNER_TYPES, type SignAndSendConnection, type SignAndSendResult, type SignMessageResult, type SignerData, SignerList, type SignerListClassNames, type SignerListProps, SignerSelector, type SignerSelectorClassNames, type SignerSelectorProps, type SignerType, type SignersListResponseDto, type SigningMethod, Skeleton, type SubmitTransactionDataDto, type Theme, ThemeProvider, type ThemeProviderProps, TransactionSigningForm, type TransactionSigningFormClassNames, type TransactionSigningFormProps, type UseCanSignOptions, type UseCanSignResult, type UseDelegatedKeysOptions, type UseDelegatedKeysResult, type UseMessageSigningOptions, type UseMessageSigningResult, type UseSelectedWalletResult, type UseSignerSelectionOptions, type UseSignerSelectionResult, type UseSignersForSelectedWalletOptions, type UseSignersOptions, type UseSignersRawOptions, type UseSignersRawResult, type UseSignersResult, type UseTransactionSigningOptions, type UseTransactionSigningResult, type User, type WalletContextType, type WalletData, type WalletDataDto, WalletProvider, type WalletProviderProps, WalletSelector, type WalletSelectorClassNames, type WalletSelectorProps, extractErrorMessage, extractResponseData, getSignerPublicKey, getWalletData, signAndSendTransactionWithSigner, signMessageWithSigner, signTransactionWithSigner, useCanSign, useCilantroAuth, useDelegatedKeys, useMessageSigning, useSelectedWallet, useSignerSelection, useSigners, useSignersForSelectedWallet, useSignersRaw, useTransactionSigning, useWalletAddress, useWallets };
+export { type ActionState, AddPasskeyButton, type AddPasskeyButtonProps, type ApiResponse, AuthGuard, type AuthGuardClassNames, type AuthGuardProps, type CilantroAuthContextType, type CilantroConfig, CilantroConnect, type CilantroConnectProps, CilantroContextProvider, type CilantroContextValue, CilantroProvider, type CilantroProviderProps, ConnectWalletButton, type ConnectWalletButtonProps, CreateEmailSignerForm, type CreateEmailSignerFormProps, CreatePhoneSignerForm, type CreatePhoneSignerFormProps, CreateWalletForm, type CreateWalletFormProps, type DeviceKeyStorage, ErrorBoundary, type ErrorBoundaryProps, type ErrorResponse, LoadingOverlay, type LoadingOverlayProps, LoginForm, type LoginFormClassNames, type LoginFormProps, LogoutButton, type LogoutButtonProps, type NormalizedWallet, type ResolvedTheme, SIGNER_TYPES, SendSOLForm, type SendSOLFormProps, type SignerType as SendSOLSignerType, SendSPLForm, type SendSPLFormProps, type SignerType$2 as SendTransactionSignerType, type SignAndSendConnection, type SignAndSendConnectionAdapter, type SignAndSendResult, type SignMessageResult, type SignerData, SignerList, type SignerListClassNames, type SignerListProps, SignerSelector, type SignerSelectorClassNames, type SignerSelectorProps, type SignerType$1 as SignerType, Skeleton, type SolanaWallet, type SubmitTransactionDataDto, type SubmitTransactionResult, type Theme, ThemeProvider, type ThemeProviderProps, TransactionHistory, type TransactionHistoryProps, TransactionStatus, type TransactionStatusProps, type UseAuthResult, type UseCilantroConfigResult, type UseExternalWalletResult, type UsePasskeyResult, type UseSendTransactionResult, type UseSignersOptions, type UseSignersResult, type UseWalletResult, type User, WalletAddress, type WalletAddressProps, WalletBalance, type WalletBalanceProps, type WalletContextType, type WalletData, type WalletDataDto$1 as WalletDataDto, type WalletDataDto as WalletDataDtoFromHook, type WalletData as WalletDataFromHook, type WalletInfo, WalletSelector, type WalletSelectorClassNames, type WalletSelectorProps, adaptSolanaConnection, extractErrorMessage, extractResponseData, getSignerPublicKey, getWalletData, isAuthError, isJwtExpired, normalizeSigner, normalizeWallet, signAndSendTransactionWithSigner, signMessageWithSigner, signTransactionWithSigner, useAuth, useCilantroAuth, useCilantroConfig, useCilantroContext, useExternalWallet, usePasskey, useSendTransaction, useSigners, useWallet, useWallets };