/**
 * SDK State Stores (Zustand)
 *
 * Provides reactive state management for the SDK.
 * Each store is created via a factory function to support multi-instance SDKs.
 */
import type { TokenBalance, PendingTransaction, TokenMetadata } from '../types';
interface SDKState {
    initialized: boolean;
    chainId: number | null;
    setInitialized: (initialized: boolean) => void;
    setChainId: (chainId: number) => void;
    reset: () => void;
}
export declare function createSDKStore(): import("zustand").UseBoundStore<import("zustand").StoreApi<SDKState>>;
interface WalletState {
    isConnected: boolean;
    isAuthenticated: boolean;
    address: string | null;
    privacyAddress: string | null;
    mpk: string | null;
    setConnected: (connected: boolean, address?: string) => void;
    setAuthenticated: (authenticated: boolean, privacyAddress?: string, mpk?: string) => void;
    setAddress: (address: string | null) => void;
    reset: () => void;
}
export declare function createWalletStore(): import("zustand").UseBoundStore<import("zustand").StoreApi<WalletState>>;
interface BalanceState {
    balances: Map<string, TokenBalance>;
    loading: boolean;
    lastSynced: number | null;
    setBalance: (tokenAddress: string, balance: TokenBalance) => void;
    setBalances: (balances: TokenBalance[]) => void;
    setLoading: (loading: boolean) => void;
    getBalance: (tokenAddress: string) => TokenBalance | undefined;
    reset: () => void;
}
export declare function createBalanceStore(): import("zustand").UseBoundStore<import("zustand").StoreApi<BalanceState>>;
interface TransactionState {
    transactions: PendingTransaction[];
    pending: PendingTransaction[];
    loading: boolean;
    addTransaction: (tx: PendingTransaction) => void;
    updateTransaction: (txHash: string, update: Partial<PendingTransaction>, newHash?: string) => void;
    setTransactions: (transactions: PendingTransaction[]) => void;
    mergeTransactions: (fetchedTransactions: PendingTransaction[]) => void;
    getTransaction: (txHash: string) => PendingTransaction | undefined;
    getPending: () => PendingTransaction[];
    reset: () => void;
}
export declare function createTransactionStore(): import("zustand").UseBoundStore<import("zustand").StoreApi<TransactionState>>;
interface TokenState {
    tokens: Map<string, TokenMetadata>;
    setToken: (token: TokenMetadata) => void;
    getToken: (address: string) => TokenMetadata | undefined;
    reset: () => void;
}
export declare function createTokenStore(): import("zustand").UseBoundStore<import("zustand").StoreApi<TokenState>>;
type StoreOverrides = {
    sdk?: ReturnType<typeof createSDKStore>;
    wallet?: ReturnType<typeof createWalletStore>;
    balance?: ReturnType<typeof createBalanceStore>;
    transaction?: ReturnType<typeof createTransactionStore>;
    token?: ReturnType<typeof createTokenStore>;
};
/**
 * Bundle of all stores for a single SDK instance.
 * Enables multi-instance SDK usage where each instance has independent state.
 */
export declare class SDKStores {
    readonly sdk: ReturnType<typeof createSDKStore>;
    readonly wallet: ReturnType<typeof createWalletStore>;
    readonly balance: ReturnType<typeof createBalanceStore>;
    readonly transaction: ReturnType<typeof createTransactionStore>;
    readonly token: ReturnType<typeof createTokenStore>;
    private readonly owned;
    constructor(overrides?: StoreOverrides);
    /** Reset all stores to initial state */
    resetAll(): void;
}
export {};
//# sourceMappingURL=stores.d.ts.map