/**
 * Optimistic Updates Store
 *
 * Manages optimistic mutations with rollback capability.
 * Tracks applied mutations until server confirmation.
 */
import type { BaseRecord, AppliedMutation, OptimisticState } from '../types';
/**
 * Options for creating an optimistic store
 */
export interface OptimisticStoreOptions {
    collectionId: string;
}
/**
 * OptimisticStore - Manages optimistic state for a collection
 */
export declare class OptimisticStore<T extends BaseRecord> {
    private collectionId;
    private state;
    private subscribers;
    private rollbackHandlers;
    private mergedStates;
    constructor(options: OptimisticStoreOptions);
    /**
     * Apply an optimistic mutation
     */
    applyOptimistic(type: 'insert' | 'update' | 'delete', recordId: string | number, data: Partial<T>, previousData?: T): string;
    /**
     * Confirm a mutation was successfully persisted
     */
    confirmMutation(mutationId: string): void;
    /**
     * Rollback a specific mutation
     */
    rollbackMutation(mutationId: string): AppliedMutation<T> | undefined;
    /**
     * Rollback all mutations in reverse order
     */
    rollbackAll(): AppliedMutation<T>[];
    /**
     * Rollback all mutations and return them in reverse order for restore
     */
    rollbackAllWithRestore(): AppliedMutation<T>[];
    /**
     * Rollback all mutations after a given ID (exclusive)
     */
    rollbackAfter(afterId: string): void;
    /**
     * Register a rollback event handler
     */
    onRollback(handler: (event: {
        mutationId: string;
        type: string;
        recordId: string | number;
    }) => void): () => void;
    /**
     * Get merged optimistic state for a specific record
     */
    getMergedOptimisticState(recordId: string | number): Partial<T>;
    /**
     * Rollback with custom merge strategy
     */
    rollbackWithMerge(mutationId: string, mergeFn: (local: Partial<T>, server: T) => T): void;
    /**
     * Get merged state for a record (combining server + optimistic + merge results)
     */
    getMergedState(recordId: string | number): Partial<T>;
    /**
     * Get current optimistic state
     */
    getState(): OptimisticState<T>;
    /**
     * Check if there are pending mutations
     */
    hasPendingMutations(): boolean;
    /**
     * Get mutations for a specific record
     */
    getMutationsForRecord(recordId: string | number): AppliedMutation<T>[];
    /**
     * Subscribe to state changes
     */
    subscribe(callback: (state: OptimisticState<T>) => void): () => void;
    /**
     * Get the current subscriber count for debugging
     */
    getSubscriberCount(): number;
    /**
     * Dispose all resources
     */
    dispose(): void;
    private generateMutationId;
    private emitRollback;
    private notifySubscribers;
}
/**
 * Factory function to create an OptimisticStore
 */
export declare function createOptimisticStore<T extends BaseRecord>(options: OptimisticStoreOptions): OptimisticStore<T>;
/**
 * Apply an optimistic update to a data map (immutably)
 */
export declare function applyOptimisticUpdate<T extends BaseRecord>(data: Map<string | number, T>, type: 'insert' | 'update' | 'delete', id: string | number, changes: Partial<T>): Map<string | number, T>;
/**
 * Rollback an optimistic update (immutably)
 */
export declare function rollbackOptimisticUpdate<T extends BaseRecord>(data: Map<string | number, T>, type: 'insert' | 'update' | 'delete', id: string | number, previousData?: T): Map<string | number, T>;
//# sourceMappingURL=optimistic-store.d.ts.map