@solana/connector 0.1.2 → 0.1.4

package/dist/react.d.ts

@@ -1,12 +1,16 @@
-import { h as UnifiedConfig, d as ConnectorConfig, M as MobileWalletAdapterConfig, i as ClusterType, A as AccountInfo, N as ClipboardResult } from './wallet-standard-shim-C1tisl9S.js';
-export { b as ConnectorErrorBoundary, C as ConnectorProvider, c as ConnectorSnapshot, e as ConnectorState, D as DefaultConfigOptions, E as ExtendedConnectorConfig, U as UnifiedConfigOptions, W as WalletInfo, g as WalletStandardAccount, f as WalletStandardWallet, u as useConnector, a as useConnectorClient, w as withErrorBoundary } from './wallet-standard-shim-C1tisl9S.js';
+import { h as UnifiedConfig, d as ConnectorConfig, M as MobileWalletAdapterConfig, i as ClusterType, A as AccountInfo, V as ClipboardResult, Q as SolanaClient } from './wallet-standard-shim-DC_Z7DS-.js';
+export { b as ConnectorErrorBoundary, C as ConnectorProvider, c as ConnectorSnapshot, e as ConnectorState, D as DefaultConfigOptions, E as ExtendedConnectorConfig, U as UnifiedConfigOptions, W as WalletInfo, g as WalletStandardAccount, f as WalletStandardWallet, u as useConnector, a as useConnectorClient, w as withErrorBoundary } from './wallet-standard-shim-DC_Z7DS-.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, ComponentType, PropsWithChildren } from 'react';
 import { SolanaCluster, SolanaClusterId } from '@wallet-ui/core';
 export { SolanaCluster, SolanaClusterId } from '@wallet-ui/core';
-import { j as TransactionSigner, b as TransactionSignerCapabilities } from './transaction-signer-D3csM_Mf.js';
-import { TransactionModifyingSigner, SolanaClient, CompilableTransactionMessage, TransactionMessageWithBlockhashLifetime } from 'gill';
+import { j as TransactionSigner, b as TransactionSignerCapabilities } from './transaction-signer-D9d8nxwb.js';
+import { TransactionModifyingSigner } from '@solana/signers';
+import { TransactionMessage, TransactionMessageWithFeePayer, TransactionMessageWithBlockhashLifetime } from '@solana/kit';
 export { Wallet, WalletAccount } from '@wallet-standard/base';
+import '@solana/addresses';
+import '@solana/keys';
+import '@solana/transaction-messages';
 import '@solana/web3.js';
 
 interface UnifiedProviderProps {
@@ -186,19 +190,19 @@ interface UseTransactionSignerReturn {
 declare function useTransactionSigner(): UseTransactionSignerReturn;
 
 /**
- * @solana/connector - useGillTransactionSigner hook
+ * @solana/connector - useKitTransactionSigner hook
  *
- * React hook for gill-compatible transaction signing
- * Use this when working with modern Solana libraries (@solana/kit, gill)
+ * React hook for kit-compatible transaction signing
+ * Use this when working with modern Solana libraries (@solana/kit)
  */
 
 /**
- * Return value from useGillTransactionSigner hook
+ * Return value from useKitTransactionSigner hook
  */
-interface UseGillTransactionSignerReturn {
+interface UseKitTransactionSignerReturn {
     /**
-     * Gill-compatible TransactionModifyingSigner instance (null if not connected)
-     * Use this with modern Solana libraries (@solana/kit, gill)
+     * Kit-compatible TransactionModifyingSigner instance (null if not connected)
+     * Use this with modern Solana libraries (@solana/kit)
      */
     signer: TransactionModifyingSigner | null;
     /**
@@ -208,27 +212,31 @@ interface UseGillTransactionSignerReturn {
     ready: boolean;
 }
 /**
- * Hook for gill-compatible transaction signing
+ * @deprecated Use `UseKitTransactionSignerReturn` instead
+ */
+type UseGillTransactionSignerReturn = UseKitTransactionSignerReturn;
+/**
+ * Hook for kit-compatible transaction signing
  *
- * Creates a TransactionPartialSigner that's compatible with @solana/kit and gill,
+ * Creates a TransactionPartialSigner that's compatible with @solana/kit,
  * enabling seamless integration with modern Solana development patterns.
  *
- * This hook wraps the standard useTransactionSigner and adapts it to gill's
+ * This hook wraps the standard useTransactionSigner and adapts it to kit's
  * interface, allowing you to use modern libraries without type incompatibilities.
  *
  * @example
  * ```tsx
- * import { useGillTransactionSigner } from '@solana/connector';
- * import { getTransferSolInstruction } from 'gill/programs';
- * import { address, pipe, createTransactionMessage } from 'gill';
+ * import { useKitTransactionSigner } from '@solana/connector';
+ * import { getTransferSolInstruction } from '@solana-program/system';
+ * import { address, pipe, createTransactionMessage } from '@solana/kit';
  *
  * function ModernTransfer() {
- *   const { signer, ready } = useGillTransactionSigner();
+ *   const { signer, ready } = useKitTransactionSigner();
  *
  *   const handleTransfer = async (recipient: string, amount: number) => {
  *     if (!signer) return;
  *
- *     // Fully type-safe with gill!
+ *     // Fully type-safe with @solana/kit!
  *     const instruction = getTransferSolInstruction({
  *       source: signer, // No type errors
  *       destination: address(recipient),
@@ -244,7 +252,7 @@ interface UseGillTransactionSignerReturn {
  *
  *   return (
  *     <button onClick={handleTransfer} disabled={!ready}>
- *       Send with Gill
+ *       Send with Kit
  *     </button>
  *   );
  * }
@@ -261,22 +269,26 @@ interface UseGillTransactionSignerReturn {
  * }
  * ```
  */
-declare function useGillTransactionSigner(): UseGillTransactionSignerReturn;
+declare function useKitTransactionSigner(): UseKitTransactionSignerReturn;
+/**
+ * @deprecated Use `useKitTransactionSigner` instead. This alias is provided for backward compatibility.
+ */
+declare const useGillTransactionSigner: typeof useKitTransactionSigner;
 
 /**
- * @solana/connector - useGillSolanaClient hook
+ * @solana/connector - useSolanaClient hook
  *
- * React hook for Gill's SolanaClient with built-in RPC and WebSocket subscriptions
- * Provides rpc, rpcSubscriptions, sendAndConfirmTransaction, and simulateTransaction
+ * React hook for Kit's SolanaClient with built-in RPC and WebSocket subscriptions
+ * Provides rpc and rpcSubscriptions
  */
 
 /**
- * Return value from useGillSolanaClient hook
+ * Return value from useSolanaClient hook
  */
-interface UseGillSolanaClientReturn {
+interface UseSolanaClientReturn {
     /**
-     * Gill SolanaClient instance with RPC and subscriptions (null if not available)
-     * Includes: rpc, rpcSubscriptions, sendAndConfirmTransaction, simulateTransaction
+     * Kit SolanaClient instance with RPC and subscriptions (null if not available)
+     * Includes: rpc, rpcSubscriptions
      */
     client: SolanaClient | null;
     /**
@@ -289,24 +301,26 @@ interface UseGillSolanaClientReturn {
     clusterType: ClusterType | null;
 }
 /**
- * Hook for Gill's SolanaClient with automatic RPC and WebSocket subscription management
+ * @deprecated Use `UseSolanaClientReturn` instead
+ */
+type UseGillSolanaClientReturn = UseSolanaClientReturn;
+/**
+ * Hook for Kit's SolanaClient with automatic RPC and WebSocket subscription management
  *
  * Creates a fully configured SolanaClient based on the current cluster, providing:
  * - Type-safe RPC client
  * - WebSocket subscription client
- * - Built-in sendAndConfirmTransaction helper
- * - Built-in simulateTransaction helper
  *
  * The client is automatically recreated when the cluster changes.
  *
  * @example
  * ```tsx
- * import { useGillSolanaClient, useGillTransactionSigner } from '@solana/connector';
- * import { signTransactionMessageWithSigners } from 'gill';
+ * import { useSolanaClient, useKitTransactionSigner } from '@solana/connector';
+ * import { signTransactionMessageWithSigners } from '@solana/kit';
  *
  * function SendTransaction() {
- *   const { client, ready } = useGillSolanaClient();
- *   const { signer } = useGillTransactionSigner();
+ *   const { client, ready } = useSolanaClient();
+ *   const { signer } = useKitTransactionSigner();
  *
  *   const handleSend = async (transaction) => {
  *     if (!client || !signer) return;
@@ -314,10 +328,8 @@ interface UseGillSolanaClientReturn {
  *     // Sign the transaction
  *     const signed = await signTransactionMessageWithSigners(transaction);
  *
- *     // Send and confirm using Gill's built-in helper
- *     await client.sendAndConfirmTransaction(signed, {
- *       commitment: 'confirmed'
- *     });
+ *     // Send using RPC client
+ *     const signature = await client.rpc.sendTransaction(signed).send();
  *   };
  *
  *   return (
@@ -330,28 +342,9 @@ interface UseGillSolanaClientReturn {
  *
  * @example
  * ```tsx
- * // Simulating a transaction
- * function SimulateTransaction() {
- *   const { client } = useGillSolanaClient();
- *
- *   const handleSimulate = async (transaction) => {
- *     if (!client) return;
- *
- *     const simulation = await client.simulateTransaction(transaction, {
- *       sigVerify: false,
- *       commitment: 'processed'
- *     });
- *
- *     console.log('Simulation result:', simulation);
- *   };
- * }
- * ```
- *
- * @example
- * ```tsx
  * // Direct RPC access
  * function GetBalance() {
- *   const { client } = useGillSolanaClient();
+ *   const { client } = useSolanaClient();
  *
  *   const fetchBalance = async (address: Address) => {
  *     if (!client) return;
@@ -362,7 +355,11 @@ interface UseGillSolanaClientReturn {
  * }
  * ```
  */
-declare function useGillSolanaClient(): UseGillSolanaClientReturn;
+declare function useSolanaClient(): UseSolanaClientReturn;
+/**
+ * @deprecated Use `useSolanaClient` instead. This alias is provided for backward compatibility.
+ */
+declare const useGillSolanaClient: typeof useSolanaClient;
 
 /**
  * @solana/connector - useTransactionPreparer hook
@@ -371,6 +368,11 @@ declare function useGillSolanaClient(): UseGillSolanaClientReturn;
  * Handles blockhash fetching, compute unit limits, and transaction simulation
  */
 
+/**
+ * A transaction message that can be compiled for signing.
+ * Replaces the deprecated CompilableTransactionMessage type.
+ */
+type CompilableTransactionMessage = TransactionMessage & TransactionMessageWithFeePayer;
 /**
  * Options for transaction preparation
  */
@@ -416,7 +418,7 @@ interface UseTransactionPreparerReturn {
 /**
  * Hook for preparing transactions with automatic optimization
  *
- * Uses Gill's prepareTransaction utility to:
+ * Uses kit's prepareTransaction utility to:
  * 1. Simulate the transaction to determine optimal compute units
  * 2. Set compute unit limit (with configurable multiplier for safety margin)
  * 3. Fetch and set the latest blockhash (if not already present)
@@ -426,14 +428,14 @@ interface UseTransactionPreparerReturn {
  *
  * @example
  * ```tsx
- * import { useTransactionPreparer, useGillTransactionSigner } from '@solana/connector';
- * import { pipe, createTransactionMessage, appendTransactionMessageInstructions } from 'gill';
- * import { getTransferSolInstruction } from 'gill/programs';
+ * import { useTransactionPreparer, useKitTransactionSigner } from '@solana/connector';
+ * import { pipe, createTransactionMessage, appendTransactionMessageInstructions } from '@solana/kit';
+ * import { getTransferSolInstruction } from '@solana-program/system';
  *
  * function SendOptimizedTransaction() {
  *   const { prepare, ready } = useTransactionPreparer();
- *   const { signer } = useGillTransactionSigner();
- *   const { client } = useGillSolanaClient();
+ *   const { signer } = useKitTransactionSigner();
+ *   const { client } = useSolanaClient();
  *
  *   const handleSend = async (recipient: string, amount: bigint) => {
  *     if (!ready || !signer || !client) return;
@@ -493,4 +495,642 @@ interface UseTransactionPreparerReturn {
  */
 declare function useTransactionPreparer(): UseTransactionPreparerReturn;
 
-export { AccountInfo, UnifiedProvider as AppProvider, ClusterType, ConnectorConfig, MobileWalletAdapterConfig, type TransactionPrepareOptions, UnifiedConfig, UnifiedProvider, type UnifiedProviderProps, type UseAccountReturn, type UseClusterReturn, type UseGillSolanaClientReturn, type UseGillTransactionSignerReturn, type UseTransactionPreparerReturn, type UseTransactionSignerReturn, type UseWalletInfoReturn, useAccount, useCluster, useGillSolanaClient, useGillTransactionSigner, useTransactionPreparer, useTransactionSigner, useWalletInfo };
+interface TokenBalance {
+    /** Token mint address */
+    mint: string;
+    /** Token balance (in smallest unit) */
+    amount: bigint;
+    /** Token decimals */
+    decimals: number;
+    /** Formatted balance (human readable) */
+    formatted: string;
+    /** Token symbol if known */
+    symbol?: string;
+    /** Token name if known */
+    name?: string;
+    /** Token logo URL if known */
+    logo?: string;
+}
+interface UseBalanceReturn {
+    /** SOL balance in SOL (not lamports) */
+    solBalance: number;
+    /** SOL balance in lamports */
+    lamports: bigint;
+    /** Formatted SOL balance string */
+    formattedSol: string;
+    /** Token balances */
+    tokens: TokenBalance[];
+    /** Whether balance is loading */
+    isLoading: boolean;
+    /** Error if balance fetch failed */
+    error: Error | null;
+    /** Refetch balance */
+    refetch: () => Promise<void>;
+    /** Last updated timestamp */
+    lastUpdated: Date | null;
+}
+/**
+ * Hook for fetching wallet balance (SOL and tokens).
+ *
+ * @example Basic usage
+ * ```tsx
+ * function Balance() {
+ *   const { solBalance, formattedSol, isLoading } = useBalance();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   return <div>{formattedSol}</div>;
+ * }
+ * ```
+ *
+ * @example With token balances
+ * ```tsx
+ * function TokenBalances() {
+ *   const { tokens, isLoading } = useBalance();
+ *
+ *   return (
+ *     <div>
+ *       {tokens.map(token => (
+ *         <div key={token.mint}>
+ *           {token.symbol}: {token.formatted}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useBalance(): UseBalanceReturn;
+
+interface TransactionInfo {
+    /** Transaction signature */
+    signature: string;
+    /** Block time (unix timestamp) */
+    blockTime: number | null;
+    /** Slot number */
+    slot: number;
+    /** Transaction status */
+    status: 'success' | 'failed';
+    /** Error message if failed */
+    error?: string;
+    /** Transaction type (if detected) */
+    type: 'sent' | 'received' | 'swap' | 'nft' | 'stake' | 'program' | 'unknown';
+    /** Direction for transfers */
+    direction?: 'in' | 'out';
+    /** Amount in SOL (for transfers) */
+    amount?: number;
+    /** Formatted amount string */
+    formattedAmount?: string;
+    /** Token mint address (for token transfers) */
+    tokenMint?: string;
+    /** Token symbol (if known) */
+    tokenSymbol?: string;
+    /** Token icon URL (if known) */
+    tokenIcon?: string;
+    /** Counterparty address (who you sent to or received from) */
+    counterparty?: string;
+    /** Formatted date string */
+    formattedDate: string;
+    /** Formatted time string */
+    formattedTime: string;
+    /** Explorer URL */
+    explorerUrl: string;
+}
+interface UseTransactionsOptions {
+    /** Number of transactions to fetch */
+    limit?: number;
+    /** Whether to auto-refresh */
+    autoRefresh?: boolean;
+    /** Refresh interval in milliseconds */
+    refreshInterval?: number;
+    /** Fetch full transaction details (slower but more info) */
+    fetchDetails?: boolean;
+}
+interface UseTransactionsReturn {
+    /** List of transactions */
+    transactions: TransactionInfo[];
+    /** Whether transactions are loading */
+    isLoading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+    /** Whether there are more transactions to load */
+    hasMore: boolean;
+    /** Load more transactions */
+    loadMore: () => Promise<void>;
+    /** Refetch transactions */
+    refetch: () => Promise<void>;
+    /** Last updated timestamp */
+    lastUpdated: Date | null;
+}
+/**
+ * Hook for fetching wallet transaction history.
+ * Parses transactions to detect type (sent/received/swap) and amounts.
+ *
+ * @example Basic usage
+ * ```tsx
+ * function TransactionList() {
+ *   const { transactions, isLoading } = useTransactions({ limit: 10 });
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {transactions.map(tx => (
+ *         <div key={tx.signature}>
+ *           {tx.type} {tx.formattedAmount} - {tx.formattedDate}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useTransactions(options?: UseTransactionsOptions): UseTransactionsReturn;
+
+interface Token {
+    /** Token mint address */
+    mint: string;
+    /** Token account address */
+    tokenAccount: string;
+    /** Token balance (in smallest unit) */
+    amount: bigint;
+    /** Token decimals */
+    decimals: number;
+    /** Formatted balance (human readable) */
+    formatted: string;
+    /** Token symbol if known */
+    symbol?: string;
+    /** Token name if known */
+    name?: string;
+    /** Token logo URL if known */
+    logo?: string;
+    /** USD price if available */
+    usdPrice?: number;
+    /** Formatted USD value */
+    formattedUsd?: string;
+    /** Whether token is frozen */
+    isFrozen: boolean;
+    /** Owner address */
+    owner: string;
+}
+interface UseTokensOptions {
+    /** Whether to include zero balance tokens */
+    includeZeroBalance?: boolean;
+    /** Whether to auto-refresh */
+    autoRefresh?: boolean;
+    /** Refresh interval in milliseconds */
+    refreshInterval?: number;
+    /** Fetch metadata (name, symbol, logo) from Jupiter */
+    fetchMetadata?: boolean;
+    /** Include native SOL balance */
+    includeNativeSol?: boolean;
+}
+interface UseTokensReturn {
+    /** List of tokens */
+    tokens: Token[];
+    /** Whether tokens are loading */
+    isLoading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+    /** Refetch tokens */
+    refetch: () => Promise<void>;
+    /** Last updated timestamp */
+    lastUpdated: Date | null;
+    /** Total number of token accounts */
+    totalAccounts: number;
+}
+/**
+ * Hook for fetching wallet token holdings.
+ * Fetches metadata (name, symbol, icon, USD price) from Jupiter's API.
+ *
+ * @example Basic usage
+ * ```tsx
+ * function TokenList() {
+ *   const { tokens, isLoading } = useTokens();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {tokens.map(token => (
+ *         <div key={token.mint}>
+ *           <img src={token.logo} />
+ *           {token.symbol}: {token.formatted}
+ *           {token.formattedUsd && <span>({token.formattedUsd})</span>}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useTokens(options?: UseTokensOptions): UseTokensReturn;
+
+interface DisconnectElementProps {
+    /** Display variant */
+    variant?: 'button' | 'menuitem' | 'link';
+    /** Custom className */
+    className?: string;
+    /** Custom label */
+    label?: string;
+    /** Custom icon (render function) */
+    icon?: ReactNode;
+    /** Show icon */
+    showIcon?: boolean;
+    /** Callback after disconnect */
+    onDisconnect?: () => void;
+    /** Custom render function for full control */
+    render?: (props: {
+        disconnect: () => Promise<void>;
+        disconnecting: boolean;
+    }) => ReactNode;
+}
+/**
+ * Element for disconnecting the current wallet.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <DisconnectElement />
+ * ```
+ *
+ * @example Button variant
+ * ```tsx
+ * <DisconnectElement variant="button" />
+ * ```
+ *
+ * @example Custom render
+ * ```tsx
+ * <DisconnectElement
+ *   render={({ disconnect }) => (
+ *     <DropdownMenuItem onClick={disconnect}>
+ *       <LogOut className="mr-2 h-4 w-4" />
+ *       Sign Out
+ *     </DropdownMenuItem>
+ *   )}
+ * />
+ * ```
+ */
+declare function DisconnectElement({ variant, className, label, icon, showIcon, onDisconnect, render, }: DisconnectElementProps): react_jsx_runtime.JSX.Element;
+declare namespace DisconnectElement {
+    var displayName: string;
+}
+
+interface AccountElementRenderProps {
+    address: string | null;
+    formatted: string;
+    walletName: string | null;
+    walletIcon: string | null;
+    copy: () => Promise<{
+        success: boolean;
+    }>;
+    copied: boolean;
+}
+interface AccountElementProps {
+    /** Show wallet avatar/icon */
+    showAvatar?: boolean;
+    /** Show copy button */
+    showCopy?: boolean;
+    /** Show full address instead of truncated */
+    showFullAddress?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Custom avatar size (in pixels) */
+    avatarSize?: number;
+    /** Layout variant */
+    variant?: 'compact' | 'expanded' | 'inline';
+    /** Custom render function for full control */
+    render?: (props: AccountElementRenderProps) => ReactNode;
+}
+/**
+ * Element for displaying connected account information.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <AccountElement />
+ * ```
+ *
+ * @example With full address
+ * ```tsx
+ * <AccountElement showFullAddress />
+ * ```
+ *
+ * @example Custom render
+ * ```tsx
+ * <AccountElement
+ *   render={({ formatted, walletIcon, copy, copied }) => (
+ *     <DropdownMenuLabel>
+ *       <img src={walletIcon} className="w-5 h-5" />
+ *       <button onClick={copy}>
+ *         {copied ? 'Copied!' : formatted}
+ *       </button>
+ *     </DropdownMenuLabel>
+ *   )}
+ * />
+ * ```
+ */
+declare function AccountElement({ showAvatar, showCopy, showFullAddress, className, avatarSize, variant, render, }: AccountElementProps): react_jsx_runtime.JSX.Element | null;
+declare namespace AccountElement {
+    var displayName: string;
+}
+
+interface ClusterElementRenderProps {
+    cluster: SolanaCluster | null;
+    clusters: SolanaCluster[];
+    setCluster: (id: SolanaClusterId) => Promise<void>;
+    isMainnet: boolean;
+    isDevnet: boolean;
+    isTestnet: boolean;
+    isLocal: boolean;
+}
+interface ClusterElementProps {
+    /** Display variant */
+    variant?: 'badge' | 'select' | 'menuitem';
+    /** Custom className */
+    className?: string;
+    /** Whether the cluster can be changed */
+    allowChange?: boolean;
+    /** Show cluster icon/indicator */
+    showIndicator?: boolean;
+    /** Custom cluster labels */
+    labels?: Partial<Record<string, string>>;
+    /** Custom render function for full control */
+    render?: (props: ClusterElementRenderProps) => ReactNode;
+}
+/**
+ * Element for displaying and optionally changing the current cluster/network.
+ *
+ * @example Badge (read-only)
+ * ```tsx
+ * <ClusterElement variant="badge" />
+ * ```
+ *
+ * @example Select (changeable)
+ * ```tsx
+ * <ClusterElement variant="select" allowChange />
+ * ```
+ *
+ * @example Custom render
+ * ```tsx
+ * <ClusterElement
+ *   render={({ cluster, clusters, setCluster }) => (
+ *     <Select value={cluster?.id} onValueChange={setCluster}>
+ *       {clusters.map(c => (
+ *         <SelectItem key={c.id} value={c.id}>
+ *           {c.label}
+ *         </SelectItem>
+ *       ))}
+ *     </Select>
+ *   )}
+ * />
+ * ```
+ */
+declare function ClusterElement({ variant, className, allowChange, showIndicator, labels, render, }: ClusterElementProps): react_jsx_runtime.JSX.Element | null;
+declare namespace ClusterElement {
+    var displayName: string;
+}
+
+interface WalletListElementRenderProps {
+    wallets: WalletDisplayInfo[];
+    installedWallets: WalletDisplayInfo[];
+    select: (walletName: string) => Promise<void>;
+    connecting: boolean;
+}
+interface WalletListElementWalletProps {
+    wallet: WalletDisplayInfo;
+    select: () => Promise<void>;
+    connecting: boolean;
+}
+interface WalletListElementProps {
+    /** Filter to only show installed wallets */
+    installedOnly?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Layout variant */
+    variant?: 'list' | 'grid' | 'compact';
+    /** Show wallet status badge */
+    showStatus?: boolean;
+    /** Callback when a wallet is selected */
+    onSelect?: (walletName: string) => void;
+    /** Custom render function for full control */
+    render?: (props: WalletListElementRenderProps) => ReactNode;
+    /** Custom render function for individual wallet items */
+    renderWallet?: (props: WalletListElementWalletProps) => ReactNode;
+}
+/**
+ * Element for displaying available wallets and selecting one to connect.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <WalletListElement />
+ * ```
+ *
+ * @example Installed wallets only (most common)
+ * ```tsx
+ * <WalletListElement installedOnly />
+ * ```
+ *
+ * @example Grid layout
+ * ```tsx
+ * <WalletListElement variant="grid" installedOnly />
+ * ```
+ *
+ * @example With custom wallet render
+ * ```tsx
+ * <WalletListElement
+ *   installedOnly
+ *   renderWallet={({ wallet, select }) => (
+ *     <Button key={wallet.name} onClick={select}>
+ *       <img src={wallet.icon} alt={wallet.name} />
+ *       {wallet.name}
+ *     </Button>
+ *   )}
+ * />
+ * ```
+ *
+ * @example Full custom render
+ * ```tsx
+ * <WalletListElement
+ *   render={({ installedWallets, select, connecting }) => (
+ *     <div className="grid grid-cols-2 gap-2">
+ *       {installedWallets.map(w => (
+ *         <button key={w.name} onClick={() => select(w.name)} disabled={connecting}>
+ *           {w.name}
+ *         </button>
+ *       ))}
+ *     </div>
+ *   )}
+ * />
+ * ```
+ */
+declare function WalletListElement({ installedOnly, className, variant, showStatus, onSelect, render, renderWallet, }: WalletListElementProps): react_jsx_runtime.JSX.Element;
+declare namespace WalletListElement {
+    var displayName: string;
+}
+
+interface BalanceElementRenderProps {
+    solBalance: number;
+    formattedSol: string;
+    tokens: TokenBalance[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface BalanceElementProps {
+    /** Show SOL balance */
+    showSol?: boolean;
+    /** Show token balances */
+    showTokens?: boolean;
+    /** Maximum number of tokens to display */
+    tokenCount?: number;
+    /** Custom className */
+    className?: string;
+    /** Display variant */
+    variant?: 'compact' | 'expanded' | 'inline';
+    /** Show refresh button */
+    showRefresh?: boolean;
+    /** Show loading skeleton */
+    showSkeleton?: boolean;
+    /** Custom render function for full control */
+    render?: (props: BalanceElementRenderProps) => ReactNode;
+}
+/**
+ * Element for displaying wallet balance (SOL and tokens).
+ *
+ * @example Basic usage
+ * ```tsx
+ * <BalanceElement />
+ * ```
+ *
+ * @example With tokens
+ * ```tsx
+ * <BalanceElement showTokens tokenCount={5} />
+ * ```
+ *
+ * @example Custom render
+ * ```tsx
+ * <BalanceElement
+ *   render={({ formattedSol, isLoading }) => (
+ *     <div className="text-2xl font-bold">
+ *       {isLoading ? 'Loading...' : formattedSol}
+ *     </div>
+ *   )}
+ * />
+ * ```
+ */
+declare function BalanceElement({ showSol, showTokens, tokenCount, className, variant, showRefresh, showSkeleton, render, }: BalanceElementProps): react_jsx_runtime.JSX.Element;
+declare namespace BalanceElement {
+    var displayName: string;
+}
+
+interface TransactionHistoryElementRenderProps {
+    transactions: TransactionInfo[];
+    isLoading: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    loadMore: () => Promise<void>;
+    refetch: () => Promise<void>;
+}
+interface TransactionHistoryElementProps {
+    /** Number of transactions to display */
+    limit?: number;
+    /** Show transaction status */
+    showStatus?: boolean;
+    /** Show transaction time */
+    showTime?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Display variant */
+    variant?: 'compact' | 'expanded' | 'list';
+    /** Show load more button */
+    showLoadMore?: boolean;
+    /** Show skeleton while loading */
+    showSkeleton?: boolean;
+    /** Custom render function for full control */
+    render?: (props: TransactionHistoryElementRenderProps) => ReactNode;
+    /** Custom render for individual transaction item */
+    renderItem?: (transaction: TransactionInfo) => ReactNode;
+}
+/**
+ * Element for displaying recent transaction history.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <TransactionHistoryElement limit={5} />
+ * ```
+ *
+ * @example With load more
+ * ```tsx
+ * <TransactionHistoryElement limit={10} showLoadMore />
+ * ```
+ *
+ * @example Custom item render
+ * ```tsx
+ * <TransactionHistoryElement
+ *   renderItem={(tx) => (
+ *     <a href={tx.explorerUrl} target="_blank">
+ *       {tx.signature.slice(0, 8)}... - {tx.status}
+ *     </a>
+ *   )}
+ * />
+ * ```
+ */
+declare function TransactionHistoryElement({ limit, showStatus, showTime, className, variant, showLoadMore, showSkeleton, render, renderItem, }: TransactionHistoryElementProps): react_jsx_runtime.JSX.Element;
+declare namespace TransactionHistoryElement {
+    var displayName: string;
+}
+
+interface TokenListElementRenderProps {
+    tokens: Token[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    totalAccounts: number;
+}
+interface TokenListElementProps {
+    /** Maximum number of tokens to display */
+    limit?: number;
+    /** Show USD value (requires price API integration) */
+    showValue?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Display variant */
+    variant?: 'compact' | 'expanded' | 'grid';
+    /** Show refresh button */
+    showRefresh?: boolean;
+    /** Show skeleton while loading */
+    showSkeleton?: boolean;
+    /** Custom render function for full control */
+    render?: (props: TokenListElementRenderProps) => ReactNode;
+    /** Custom render for individual token item */
+    renderItem?: (token: Token) => ReactNode;
+}
+/**
+ * Element for displaying token holdings.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <TokenListElement limit={10} />
+ * ```
+ *
+ * @example Grid layout
+ * ```tsx
+ * <TokenListElement variant="grid" limit={6} />
+ * ```
+ *
+ * @example Custom item render
+ * ```tsx
+ * <TokenListElement
+ *   renderItem={(token) => (
+ *     <div className="token-card">
+ *       <img src={token.logo} alt={token.symbol} />
+ *       <span>{token.formatted}</span>
+ *     </div>
+ *   )}
+ * />
+ * ```
+ */
+declare function TokenListElement({ limit, showValue, className, variant, showRefresh, showSkeleton, render, renderItem, }: TokenListElementProps): react_jsx_runtime.JSX.Element;
+declare namespace TokenListElement {
+    var displayName: string;
+}
+
+export { AccountElement, type AccountElementProps, type AccountElementRenderProps, AccountInfo, UnifiedProvider as AppProvider, BalanceElement, type BalanceElementProps, type BalanceElementRenderProps, ClusterElement, type ClusterElementProps, type ClusterElementRenderProps, ClusterType, ConnectorConfig, DisconnectElement, type DisconnectElementProps, MobileWalletAdapterConfig, type Token, type TokenBalance, TokenListElement, type TokenListElementProps, type TokenListElementRenderProps, TransactionHistoryElement, type TransactionHistoryElementProps, type TransactionHistoryElementRenderProps, type TransactionInfo, type TransactionPrepareOptions, UnifiedConfig, UnifiedProvider, type UnifiedProviderProps, type UseAccountReturn, type UseBalanceReturn, type UseClusterReturn, type UseGillSolanaClientReturn, type UseGillTransactionSignerReturn, type UseKitTransactionSignerReturn, type UseSolanaClientReturn, type UseTokensOptions, type UseTokensReturn, type UseTransactionPreparerReturn, type UseTransactionSignerReturn, type UseTransactionsOptions, type UseTransactionsReturn, type UseWalletInfoReturn, WalletListElement, type WalletListElementProps, type WalletListElementRenderProps, type WalletListElementWalletProps, useAccount, useBalance, useCluster, useGillSolanaClient, useGillTransactionSigner, useKitTransactionSigner, useSolanaClient, useTokens, useTransactionPreparer, useTransactionSigner, useTransactions, useWalletInfo };