/**
 * @file Optimistic Sync
 * @description Optimistic updates with automatic rollback, retry logic,
 * and state reconciliation for seamless user experience.
 *
 * Features:
 * - Optimistic state updates
 * - Automatic rollback on failure
 * - Retry with exponential backoff
 * - State snapshot management
 * - Pending changes tracking
 * - React integration hooks
 *
 * @example
 * ```typescript
 * import { useOptimisticSync } from '@/lib/data/sync';
 *
 * const { data, update, isPending, pendingChanges } = useOptimisticSync({
 *   key: 'user',
 *   fetcher: fetchUser,
 *   updater: updateUser,
 * });
 *
 * // Optimistic update
 * update({ name: 'New Name' });
 * ```
 */
/**
 * Optimistic update status
 */
export type OptimisticStatus = 'idle' | 'pending' | 'syncing' | 'success' | 'error' | 'rolled-back';
/**
 * Pending change record
 */
export interface PendingChange<T = unknown> {
    /** Unique ID for this change */
    id: string;
    /** Original data before change */
    snapshot: T;
    /** Optimistic data after change */
    optimisticData: T;
    /** Change payload */
    payload: Partial<T>;
    /** Change timestamp */
    timestamp: number;
    /** Current status */
    status: OptimisticStatus;
    /** Error message if failed */
    error?: string;
    /** Retry count */
    retryCount: number;
}
/**
 * Optimistic sync configuration
 */
export interface OptimisticSyncConfig<T> {
    /** Unique key for this sync */
    key: string;
    /** Initial data */
    initialData?: T;
    /** Fetch current data */
    fetcher?: () => Promise<T>;
    /** Persist changes to server */
    persister: (data: T, payload: Partial<T>) => Promise<T>;
    /** Merge function for optimistic updates */
    merger?: (current: T, payload: Partial<T>) => T;
    /** Rollback function */
    rollback?: (snapshot: T, error: Error) => T;
    /** Max retry attempts */
    maxRetries?: number;
    /** Retry delay base (ms) */
    retryDelay?: number;
    /** Debounce updates (ms) */
    debounceMs?: number;
    /** Batch updates within window (ms) */
    batchWindow?: number;
    /** Enable persistence queue */
    enableQueue?: boolean;
    /** On success callback */
    onSuccess?: (data: T, payload: Partial<T>) => void;
    /** On error callback */
    onError?: (error: Error, payload: Partial<T>, snapshot: T) => void;
    /** On rollback callback */
    onRollback?: (snapshot: T, error: Error) => void;
}
/**
 * Optimistic sync state
 */
export interface OptimisticSyncState<T> {
    /** Current data (may be optimistic) */
    data: T | undefined;
    /** Server-confirmed data */
    confirmedData: T | undefined;
    /** Whether any changes are pending */
    isPending: boolean;
    /** Whether currently syncing */
    isSyncing: boolean;
    /** Last error */
    error: Error | null;
    /** Status */
    status: OptimisticStatus;
    /** Pending changes */
    pendingChanges: PendingChange<T>[];
    /** Is data stale (has pending changes) */
    isStale: boolean;
}
/**
 * Optimistic sync actions
 */
export interface OptimisticSyncActions<T> {
    /** Apply optimistic update */
    update: (payload: Partial<T>) => Promise<T>;
    /** Refresh from server */
    refresh: () => Promise<T | undefined>;
    /** Rollback all pending changes */
    rollbackAll: () => void;
    /** Rollback specific change */
    rollbackChange: (changeId: string) => void;
    /** Retry failed changes */
    retryFailed: () => Promise<void>;
    /** Reset state */
    reset: (data?: T) => void;
}
/**
 * Optimistic sync return type
 */
export type OptimisticSyncReturn<T> = OptimisticSyncState<T> & OptimisticSyncActions<T>;
/**
 * React hook for optimistic updates
 */
export declare function useOptimisticSync<T>(config: OptimisticSyncConfig<T>): OptimisticSyncReturn<T>;
/**
 * Item with required ID
 */
export interface ListItem {
    id: string;
}
/**
 * Optimistic list configuration
 */
export interface OptimisticListConfig<T extends ListItem> {
    /** Unique key for this list */
    key: string;
    /** Initial items */
    initialItems?: T[];
    /** Fetch items */
    fetcher?: () => Promise<T[]>;
    /** Create item */
    createItem?: (item: Omit<T, 'id'>) => Promise<T>;
    /** Update item */
    updateItem?: (id: string, updates: Partial<T>) => Promise<T>;
    /** Delete item */
    deleteItem?: (id: string) => Promise<void>;
    /** Generate temporary ID for optimistic creates */
    generateId?: () => string;
    /** Max retries */
    maxRetries?: number;
    /** Callbacks */
    onCreateSuccess?: (item: T) => void;
    onUpdateSuccess?: (item: T) => void;
    onDeleteSuccess?: (id: string) => void;
    onError?: (error: Error, operation: string) => void;
}
/**
 * Pending list operation
 */
export interface PendingListOperation<T> {
    id: string;
    type: 'create' | 'update' | 'delete';
    itemId: string;
    data?: T | Partial<T>;
    timestamp: number;
    status: OptimisticStatus;
    retryCount: number;
}
/**
 * React hook for optimistic list operations
 */
export declare function useOptimisticList<T extends ListItem>(config: OptimisticListConfig<T>): {
    items: T[];
    isPending: boolean;
    error: Error | null;
    create: (item: Omit<T, 'id'>) => Promise<T>;
    update: (id: string, updates: Partial<T>) => Promise<T>;
    remove: (id: string) => Promise<void>;
    refresh: () => Promise<T[]>;
    reset: (newItems?: T[]) => void;
};