import { StateCreator } from 'zustand';
import { EnhancedStore } from './types';
/**
 * Global registry for feature stores
 * Enables debugging and cross-feature communication
 */
declare class FeatureStoreRegistryImpl {
    private stores;
    private metadata;
    /**
     * Register a feature store
     */
    register<T>(name: string, store: T, version?: number): void;
    /**
     * Unregister a feature store
     */
    unregister(name: string): boolean;
    /**
     * Get a registered store
     */
    getStore<T>(name: string): T | undefined;
    /**
     * Check if a store is registered
     */
    has(name: string): boolean;
    /**
     * Get all registered store names
     */
    getNames(): string[];
    /**
     * Get metadata for a store
     */
    getMetadata(name: string): {
        version?: number;
        registeredAt: number;
    } | undefined;
    /**
     * Reset all feature stores (call their _reset if available)
     */
    resetAll(): void;
    /**
     * Clear the registry (does not reset stores)
     */
    clear(): void;
}
/** Global feature store registry instance */
export declare const featureStoreRegistry: FeatureStoreRegistryImpl;
/**
 * Feature store configuration options
 */
export interface CreateFeatureStoreConfig<TState> {
    /** Feature name (used in DevTools and registry) */
    name: string;
    /** Persist to storage */
    persist?: {
        /** Storage key (defaults to `feature-${name}`) */
        key?: string;
        /** State to persist (whitelist) */
        partialize?: (state: TState) => Partial<TState>;
        /** Storage version for migrations */
        version?: number;
    };
    /** Register with global store registry (default: true) */
    register?: boolean;
    /** Enable DevTools (default: development only) */
    devtools?: boolean;
}
/**
 * Create a feature-scoped store
 *
 * Features:
 * - Immer for immutable updates
 * - DevTools integration with feature namespace
 * - Optional persistence with versioning
 * - Auto-registration with global registry
 *
 * @example
 * ```typescript
 * interface TasksState {
 *   tasks: Task[];
 *   selectedId: string | null;
 * }
 *
 * interface TasksActions {
 *   addTask: (task: Task) => void;
 *   selectTask: (id: string | null) => void;
 * }
 *
 * export const useTasksStore = createFeatureStore<TasksState & TasksActions>(
 *   (set) => ({
 *     tasks: [],
 *     selectedId: null,
 *     addTask: (task) => {
 *       set((state) => { state.tasks.push(task) }, false, { type: 'tasks/addTask' });
 *     },
 *     selectTask: (id) => {
 *       set((state) => { state.selectedId = id }, false, { type: 'tasks/selectTask' });
 *     },
 *   }),
 *   { name: 'tasks', persist: { partialize: (s) => ({ tasks: s.tasks }) } }
 * );
 * ```
 */
export declare function createFeatureStore<TState extends object>(initializer: StateCreator<TState, [
    ['zustand/immer', never],
    ['zustand/devtools', never]
], [
], TState>, config: CreateFeatureStoreConfig<TState>): EnhancedStore<TState>;
/**
 * Lazy feature store handle
 */
export interface LazyFeatureStore<TState extends object> {
    /** Get or create the store */
    getStore: () => EnhancedStore<TState>;
    /** Check if store is initialized */
    isInitialized: () => boolean;
    /** Destroy the store and clean up */
    destroy: () => void;
    /** Feature name */
    featureName: string;
}
/**
 * Create a lazy feature store (only created when first accessed)
 *
 * Use this for code-split features where you don't want to create
 * the store until the feature is actually used.
 *
 * @example
 * ```typescript
 * export const tasksStoreLazy = createLazyFeatureStore<TasksState & TasksActions>(
 *   (set) => ({
 *     tasks: [],
 *     addTask: (task) => set((state) => { state.tasks.push(task) }, false, { type: 'tasks/add' }),
 *   }),
 *   { name: 'tasks' }
 * );
 *
 * // Later, when feature is needed:
 * const store = tasksStoreLazy.getStore();
 * const tasks = store((s) => s.tasks);
 * ```
 */
export declare function createLazyFeatureStore<TState extends object>(initializer: StateCreator<TState, [
    ['zustand/immer', never],
    ['zustand/devtools', never]
], [
], TState>, config: CreateFeatureStoreConfig<TState>): LazyFeatureStore<TState>;
/**
 * Hook factory for feature store with proper typing
 *
 * @example
 * ```typescript
 * const { useStore, useSelector, useActions } = createFeatureStoreHooks(useTasksStore);
 *
 * // In component:
 * const tasks = useSelector((s) => s.tasks);
 * const { addTask } = useActions();
 * ```
 */
export declare function createFeatureStoreHooks<TState extends object>(useStore: EnhancedStore<TState>): {
    useStore: EnhancedStore<TState>;
    useSelector: <T>(selector: (state: TState) => T) => T;
    useActions: <TActions extends Record<string, (...args: never[]) => unknown>>() => TActions;
};
/**
 * Subscribe to a feature store outside of React
 *
 * @example
 * ```typescript
 * const unsubscribe = subscribeToFeatureStore(
 *   useTasksStore,
 *   (s) => s.tasks.length,
 *   (count) => console.log(`Task count: ${count}`)
 * );
 * ```
 */
export declare function subscribeToFeatureStore<TState extends object, TSlice>(store: EnhancedStore<TState>, selector: (state: TState) => TSlice, callback: (value: TSlice, prevValue: TSlice) => void): () => void;
export {};