/**
 * @file Optimistic UI Updates
 * @description Optimistic update utilities for React applications.
 * Provides patterns for immediate UI feedback with automatic rollback.
 *
 * Features:
 * - Optimistic state management
 * - Automatic rollback on error
 * - Pending state tracking
 * - Conflict resolution
 * - Retry mechanisms
 * - Undo support
 */
/**
 * Optimistic update status
 */
export type OptimisticStatus = 'pending' | 'confirmed' | 'failed' | 'rolled-back';
/**
 * Optimistic update entry
 */
export interface OptimisticUpdate<T = unknown> {
    id: string;
    previousValue: T;
    optimisticValue: T;
    status: OptimisticStatus;
    timestamp: number;
    retryCount: number;
    error?: Error;
}
/**
 * Optimistic update result
 */
export interface OptimisticResult<T> {
    value: T;
    pending: boolean;
    error: Error | null;
    retry: () => Promise<void>;
    rollback: () => void;
}
/**
 * Optimistic manager configuration
 */
export interface OptimisticConfig {
    /** Maximum retry attempts */
    maxRetries: number;
    /** Retry delay in ms */
    retryDelay: number;
    /** Retry backoff multiplier */
    retryBackoff: number;
    /** Enable automatic retry on failure */
    autoRetry: boolean;
    /** Timeout for optimistic updates in ms */
    timeout: number;
    /** Keep history for undo */
    keepHistory: boolean;
    /** Maximum history size */
    maxHistorySize: number;
    /** Debug mode */
    debug: boolean;
}
/**
 * Mutation function type
 */
export type MutationFn<T, TArgs extends unknown[] = unknown[]> = (...args: TArgs) => Promise<T>;
/**
 * Optimistic value updater
 */
export type OptimisticUpdater<T> = (currentValue: T) => T;
/**
 * Conflict resolver
 */
export type ConflictResolver<T> = (localValue: T, serverValue: T, baseValue: T) => T;
/**
 * Update listener
 */
export type UpdateListener<T> = (update: OptimisticUpdate<T>) => void;
/**
 * Manages optimistic updates with rollback support
 */
export declare class OptimisticUpdateManager<T> {
    private config;
    private currentValue;
    private updates;
    private history;
    private listeners;
    private idCounter;
    constructor(initialValue: T, config?: Partial<OptimisticConfig>);
    /**
     * Get the current value (with pending optimistic updates applied)
     */
    getValue(): T;
    /**
     * Get the confirmed value (without pending updates)
     */
    getConfirmedValue(): T;
    /**
     * Apply an optimistic update
     */
    applyUpdate<TArgs extends unknown[]>(updater: OptimisticUpdater<T>, mutation: MutationFn<T, TArgs>, ...args: TArgs): Promise<OptimisticResult<T>>;
    /**
     * Retry a failed update
     */
    retryUpdate<TArgs extends unknown[]>(id: string, mutation: MutationFn<T, TArgs>, ...args: TArgs): Promise<void>;
    /**
     * Rollback an update
     */
    rollbackUpdate(id: string): void;
    /**
     * Get pending updates
     */
    getPendingUpdates(): OptimisticUpdate<T>[];
    /**
     * Get failed updates
     */
    getFailedUpdates(): OptimisticUpdate<T>[];
    /**
     * Check if there are pending updates
     */
    hasPendingUpdates(): boolean;
    /**
     * Undo the last confirmed update
     */
    undo(): T | null;
    /**
     * Subscribe to update changes
     */
    subscribe(listener: UpdateListener<T>): () => void;
    /**
     * Clear all updates
     */
    clear(): void;
    /**
     * Get update statistics
     */
    getStats(): {
        pending: number;
        confirmed: number;
        failed: number;
        rolledBack: number;
        historySize: number;
    };
    private executeWithTimeout;
    private calculateRetryDelay;
    private addToHistory;
    private notifyListeners;
    private generateId;
    private sleep;
    private log;
}
/**
 * Specialized manager for list operations
 */
export declare class OptimisticListManager<T extends {
    id: string;
}> {
    private manager;
    constructor(initialItems: T[], config?: Partial<OptimisticConfig>);
    /**
     * Get current items
     */
    getItems(): T[];
    /**
     * Optimistically add an item
     */
    addItem(item: T, mutation: MutationFn<T[]>): Promise<OptimisticResult<T[]>>;
    /**
     * Optimistically remove an item
     */
    removeItem(id: string, mutation: MutationFn<T[]>): Promise<OptimisticResult<T[]>>;
    /**
     * Optimistically update an item
     */
    updateItem(id: string, updates: Partial<T>, mutation: MutationFn<T[]>): Promise<OptimisticResult<T[]>>;
    /**
     * Optimistically reorder items
     */
    reorderItems(fromIndex: number, toIndex: number, mutation: MutationFn<T[]>): Promise<OptimisticResult<T[]>>;
    /**
     * Get pending items (items being added)
     */
    getPendingItems(): T[];
    /**
     * Check if an item has pending changes
     */
    hasItemPending(id: string): boolean;
    /**
     * Subscribe to changes
     */
    subscribe(listener: UpdateListener<T[]>): () => void;
    /**
     * Check if there are pending updates
     */
    hasPendingUpdates(): boolean;
    /**
     * Undo last change
     */
    undo(): T[] | null;
}
/**
 * Create an optimistic update manager
 */
export declare function createOptimisticManager<T>(initialValue: T, config?: Partial<OptimisticConfig>): OptimisticUpdateManager<T>;
/**
 * Create an optimistic list manager
 */
export declare function createOptimisticListManager<T extends {
    id: string;
}>(initialItems: T[], config?: Partial<OptimisticConfig>): OptimisticListManager<T>;
/**
 * Apply optimistic update to a value
 */
export declare function applyOptimistic<T, TArgs extends unknown[]>(currentValue: T, updater: OptimisticUpdater<T>, mutation: MutationFn<T, TArgs>, ...args: TArgs): Promise<{
    value: T;
    confirmed: boolean;
    error: Error | null;
}>;
/**
 * Merge server and local values with conflict resolution
 */
export declare function mergeWithConflictResolution<T>(localValue: T, serverValue: T, baseValue: T, resolver: ConflictResolver<T>): T;
/**
 * Default conflict resolver (server wins)
 */
export declare function serverWinsResolver<T>(_localValue: T, serverValue: T, _baseValue: T): T;
/**
 * Client wins conflict resolver
 */
export declare function clientWinsResolver<T>(localValue: T, _serverValue: T, _baseValue: T): T;
/**
 * Last write wins resolver (based on timestamp)
 */
export declare function lastWriteWinsResolver<T extends {
    updatedAt?: number | string;
}>(localValue: T, serverValue: T, _baseValue: T): T;