import { StorageManager } from './storage';
/**
 * Persistence configuration
 */
export interface PersistConfig<T> {
    /** Storage key */
    key: string;
    /** Storage manager to use */
    storage?: StorageManager;
    /** Version for migrations */
    version?: number;
    /** Time-to-live in milliseconds */
    ttl?: number;
    /** State transformer before persisting */
    serialize?: (state: T) => unknown;
    /** State transformer after loading */
    deserialize?: (persisted: unknown) => T;
    /** Whitelist of keys to persist (if not provided, persist all) */
    whitelist?: Array<keyof T>;
    /** Blacklist of keys to exclude from persistence */
    blacklist?: Array<keyof T>;
    /** Migration functions by version */
    migrations?: Record<number, (state: unknown) => unknown>;
    /** Whether state contains PHI (will skip persistence) */
    containsPHI?: boolean;
    /** Merge strategy for hydration */
    merge?: 'shallow' | 'deep' | 'replace';
    /** Throttle persistence writes (ms) */
    throttle?: number;
    /** Debug mode */
    debug?: boolean;
}
/**
 * Rehydrate result
 */
export interface RehydrateResult<T> {
    state: T | null;
    error: Error | null;
    migrated: boolean;
    fromVersion: number | null;
}
/**
 * State persistence manager
 */
export declare class StatePersister<T extends object> {
    private config;
    private lastPersistTime;
    private pendingPersist;
    constructor(config: PersistConfig<T>);
    /**
     * Persist state to storage
     */
    persist(state: T): Promise<void>;
    /**
     * Rehydrate state from storage
     */
    rehydrate(): Promise<RehydrateResult<Partial<T>>>;
    /**
     * Merge persisted state with initial state
     */
    mergeStates(initial: T, persisted: Partial<T> | null): T;
    /**
     * Clear persisted state
     */
    clear(): void;
    /**
     * Force immediate persistence
     */
    flush(state: T): Promise<void>;
    /**
     * Filter state based on whitelist/blacklist
     */
    private filterState;
    /**
     * Persist state immediately
     */
    private persistImmediate;
    /**
     * Run migrations
     */
    private runMigrations;
}
/**
 * Zustand persist middleware options
 */
export interface ZustandPersistOptions<T> extends Omit<PersistConfig<T>, 'key'> {
    name: string;
}
/**
 * Create Zustand persist middleware
 */
export declare function createZustandPersist<T extends object>(options: ZustandPersistOptions<T>): {
    persist: StatePersister<T>;
    onFinishHydration: (fn: () => void) => () => void;
    hasHydrated: () => boolean;
    rehydrate: () => Promise<void>;
    onHydrate: (listener: () => void) => () => void;
    clearStorage: () => void;
    getPersister: () => StatePersister<T>;
};
/**
 * Redux persist storage adapter
 */
export declare function createReduxPersistStorage(storage?: StorageManager): {
    getItem: (key: string) => Promise<string | null>;
    setItem: (key: string, value: string) => Promise<void>;
    removeItem: (key: string) => void;
};
/**
 * Create PHI-safe transform for redux-persist
 */
export declare function createPHISafeTransform(phiKeys: string[]): {
    in: (state: Record<string, unknown>, key: string) => Record<string, unknown> | undefined;
    out: (state: Record<string, unknown>) => Record<string, unknown>;
};
/**
 * Session-scoped state that clears on tab close
 */
export declare class SessionStatePersister<T extends object> extends StatePersister<T> {
    constructor(config: Omit<PersistConfig<T>, 'storage'>);
}
/**
 * State snapshot for undo/redo or debugging
 */
export interface StateSnapshot<T> {
    id: string;
    state: T;
    timestamp: number;
    label?: string;
}
/**
 * State snapshot manager for undo/redo functionality
 */
export declare class StateSnapshotManager<T extends object> {
    private snapshots;
    private currentIndex;
    private readonly maxSnapshots;
    private readonly persister;
    constructor(key: string, options?: {
        maxSnapshots?: number;
        persist?: boolean;
    });
    /**
     * Take a snapshot
     */
    snapshot(state: T, label?: string): void;
    /**
     * Undo to previous snapshot
     */
    undo(): T | null;
    /**
     * Redo to next snapshot
     */
    redo(): T | null;
    /**
     * Check if can undo
     */
    canUndo(): boolean;
    /**
     * Check if can redo
     */
    canRedo(): boolean;
    /**
     * Get current snapshot
     */
    getCurrent(): StateSnapshot<T> | null;
    /**
     * Get all snapshots
     */
    getSnapshots(): StateSnapshot<T>[];
    /**
     * Clear all snapshots
     */
    clear(): void;
    /**
     * Restore from storage
     */
    restore(): Promise<void>;
}
/**
 * Create a state persister
 */
export declare function createStatePersister<T extends object>(config: PersistConfig<T>): StatePersister<T>;
/**
 * Create a session state persister
 */
export declare function createSessionPersister<T extends object>(config: Omit<PersistConfig<T>, 'storage'>): SessionStatePersister<T>;
/**
 * Create a snapshot manager
 */
export declare function createSnapshotManager<T extends object>(key: string, options?: {
    maxSnapshots?: number;
    persist?: boolean;
}): StateSnapshotManager<T>;