import { create } from 'zustand';
import { UISlice } from './slices/uiSlice';
import { SessionSlice } from './slices/sessionSlice';
import { SettingsSlice } from './slices/settingsSlice';
/**
 * Combined store state type
 */
export type StoreState = UISlice & SessionSlice & SettingsSlice & HydrationState;
/**
 * Hydration state for SSR compatibility
 */
interface HydrationState {
    _hasHydrated: boolean;
    _setHasHydrated: (hydrated: boolean) => void;
}
/**
 * Store selector type helper
 */
export type StoreSelector<T> = (state: StoreState) => T;
/**
 * Global store instance
 *
 * The middleware stack (applied inside-out):
 * 1. immer: Enables writing "mutating" logic in reducers
 * 2. devtools: Connects to Redux DevTools for debugging
 * 3. subscribeWithSelector: Enables selector-based subscriptions
 * 4. persist: Persists state to localStorage with migrations
 */
export declare const useStore: import('zustand').UseBoundStore<Omit<Omit<Omit<Omit<import('zustand').StoreApi<StoreState>, "setState"> & {
    setState(nextStateOrUpdater: StoreState | Partial<StoreState> | ((state: import('immer').WritableDraft<StoreState>) => void), shouldReplace?: false): void;
    setState(nextStateOrUpdater: StoreState | ((state: import('immer').WritableDraft<StoreState>) => void), shouldReplace: true): void;
}, "setState" | "devtools"> & {
    setState(nextStateOrUpdater: StoreState | Partial<StoreState> | ((state: import('immer').WritableDraft<StoreState>) => void), shouldReplace?: false | undefined, action?: (string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }) | undefined): void;
    setState(nextStateOrUpdater: StoreState | ((state: import('immer').WritableDraft<StoreState>) => void), shouldReplace: true, action?: (string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }) | undefined): void;
    devtools: {
        cleanup: () => void;
    };
}, "subscribe"> & {
    subscribe: {
        (listener: (selectedState: StoreState, previousSelectedState: StoreState) => void): () => void;
        <U>(selector: (state: StoreState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
            equalityFn?: ((a: U, b: U) => boolean) | undefined;
            fireImmediately?: boolean;
        } | undefined): () => void;
    };
}, "setState" | "persist"> & {
    setState(nextStateOrUpdater: StoreState | Partial<StoreState> | ((state: import('immer').WritableDraft<StoreState>) => void), shouldReplace?: false | undefined, action?: (string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }) | undefined): unknown;
    setState(nextStateOrUpdater: StoreState | ((state: import('immer').WritableDraft<StoreState>) => void), shouldReplace: true, action?: (string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }) | undefined): unknown;
    persist: {
        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<StoreState, Partial<StoreState>, unknown>>) => void;
        clearStorage: () => void;
        rehydrate: () => Promise<void> | void;
        hasHydrated: () => boolean;
        onHydrate: (fn: (state: StoreState) => void) => () => void;
        onFinishHydration: (fn: (state: StoreState) => void) => () => void;
        getOptions: () => Partial<import('zustand/middleware').PersistOptions<StoreState, Partial<StoreState>, unknown>>;
    };
}>;
/**
 * Get a snapshot of the current store state (for use outside React)
 *
 * @example
 * ```typescript
 * const currentLocale = getStoreState().locale;
 * ```
 */
export declare function getStoreState(): StoreState;
/**
 * Subscribe to store changes with selector (for use outside React)
 *
 * @example
 * ```typescript
 * const unsubscribe = subscribeToStore(
 *   (state) => state.locale,
 *   (newLocale, prevLocale) => {
 *     console.log('Locale changed:', prevLocale, '->', newLocale);
 *   }
 * );
 * ```
 */
export declare function subscribeToStore<T>(selector: StoreSelector<T>, callback: (value: T, prevValue: T) => void): () => void;
/**
 * Check if store has hydrated from persistence
 */
export declare function hasStoreHydrated(): boolean;
/**
 * Wait for store hydration to complete
 *
 * @param timeoutMs - Maximum time to wait for hydration (default: 5000ms)
 * @returns true if hydration completed, false if timeout occurred
 *
 * @example
 * ```typescript
 * const hydrated = await waitForHydration();
 * if (hydrated) {
 *   // Store is now hydrated, safe to read persisted values
 * } else {
 *   // Timeout occurred, handle gracefully
 * }
 * ```
 */
export declare function waitForHydration(timeoutMs?: number): Promise<boolean>;
/**
 * Reset store to initial state (useful for logout)
 *
 * This will:
 * - End the session
 * - Close all modals
 * - Clear toasts
 * - Stop any loading states
 *
 * Note: Settings are preserved by default (user preferences)
 *
 * @param clearSettings - Also reset settings to defaults
 */
export declare function resetStore(clearSettings?: boolean): void;
/**
 * Clear persisted store data from localStorage
 *
 * Use with caution - this removes all persisted state
 */
export declare function clearPersistedStore(): void;
type FeatureStore = ReturnType<typeof create>;
/**
 * Register a feature store with the global registry
 *
 * @example
 * ```typescript
 * const useReportsStore = createFeatureStore(...);
 * registerFeatureStore('reports', useReportsStore);
 * ```
 */
export declare function registerFeatureStore(name: string, store: FeatureStore): void;
/**
 * Unregister a feature store from the global registry
 */
export declare function unregisterFeatureStore(name: string): void;
/**
 * Get a feature store by name
 */
export declare function getFeatureStore<T>(name: string): T | undefined;
/**
 * Get all registered feature store names
 */
export declare function getFeatureStoreNames(): string[];
/**
 * Reset all feature stores that have a reset method
 *
 * @param clearRegistry - Also clear the feature store registry (default: true)
 *                       Set to false if you want to keep stores registered but reset
 */
export declare function resetAllFeatureStores(clearRegistry?: boolean): void;
export {};