/**
 * Real-Time Data Engine - WebSocket integration for live data updates
 *
 * Features:
 * - WebSocket connection management
 * - Optimistic updates
 * - Conflict resolution (last-write-wins, operational transformation)
 * - Change detection and auto-revalidation
 * - Offline support with queue
 * - Subscription-based updates
 * - Batch updates
 */
import type { EngineConfig } from './types';
export interface RealTimeItem {
    id: string;
    data: any;
    version: number;
    timestamp: number;
    _optimistic?: boolean;
    _pending?: boolean;
}
export interface RealTimeConfig extends EngineConfig {
    /** WebSocket URL */
    wsUrl?: string;
    /** Enable optimistic updates */
    enableOptimistic?: boolean;
    /** Conflict resolution strategy */
    conflictStrategy?: 'last-write-wins' | 'operational-transform' | 'manual';
    /** Auto-revalidate interval (ms) */
    revalidateInterval?: number;
    /** Enable offline queue */
    enableOfflineQueue?: boolean;
    /** Max offline queue size */
    maxOfflineQueueSize?: number;
    /** Reconnect delay (ms) */
    reconnectDelay?: number;
    /** Max reconnect attempts */
    maxReconnectAttempts?: number;
}
export interface RealTimeState {
    items: RealTimeItem[];
    connected: boolean;
    connecting: boolean;
    error: string | null;
    lastSyncTime: number | null;
    pendingUpdates: number;
    offline: boolean;
}
export interface UpdateOperation {
    type: 'insert' | 'update' | 'delete';
    itemId: string;
    data?: any;
    version: number;
    timestamp: number;
}
export declare class RealTimeEngine {
    private config;
    private state;
    private ws;
    private reconnectAttempts;
    private reconnectTimeout;
    private offlineQueue;
    private subscriptions;
    private pendingOptimistic;
    private revalidateInterval;
    constructor(config: RealTimeConfig);
    /**
     * Connect to WebSocket
     */
    connect(): void;
    /**
     * Disconnect from WebSocket
     */
    disconnect(): void;
    /**
     * Handle incoming WebSocket message
     */
    private handleMessage;
    /**
     * Apply remote update
     */
    private applyRemoteUpdate;
    /**
     * Insert item
     */
    private insertItem;
    /**
     * Update item
     */
    private updateItem;
    /**
     * Delete item
     */
    private deleteItem;
    /**
     * Optimistic update (apply immediately, sync later)
     */
    optimisticUpdate(id: string, data: any): void;
    /**
     * Send update to server
     */
    private sendUpdate;
    /**
     * Queue offline update
     */
    private queueOfflineUpdate;
    /**
     * Sync offline queue
     */
    private syncOfflineQueue;
    /**
     * Resolve conflict
     */
    private resolveConflict;
    /**
     * Full sync with server
     */
    private fullSync;
    /**
     * Setup online/offline detection
     */
    private setupOnlineOfflineDetection;
    /**
     * Attempt reconnect
     */
    private attemptReconnect;
    /**
     * Start revalidation
     */
    private startRevalidation;
    /**
     * Stop revalidation
     */
    private stopRevalidation;
    /**
     * Request full sync
     */
    private requestFullSync;
    /**
     * Subscribe to item updates
     */
    subscribe(itemId: string, callback: (item: RealTimeItem) => void): () => void;
    /**
     * Notify subscribers
     */
    private notifySubscribers;
    /**
     * Emit connection change
     */
    private emitConnectionChange;
    /**
     * Emit conflict
     */
    private emitConflict;
    /**
     * Get item by ID
     */
    getItem(id: string): RealTimeItem | null;
    /**
     * Get all items
     */
    getItems(): RealTimeItem[];
    /**
     * Get engine state
     */
    getState(): RealTimeState;
    /**
     * Destroy engine
     */
    destroy(): void;
}
//# sourceMappingURL=RealTimeEngine.d.ts.map