/**
 * TanStack Sync Collection
 *
 * Provides local-first sync with background synchronization.
 * Uses Electric-style shape subscriptions for real-time data.
 */
import type { BaseRecord, SyncCollectionOptions, Collection, SyncState, ConflictResolver } from '../types';
/**
 * Extended SyncCollection options with additional features
 */
interface ExtendedSyncCollectionOptions<T extends BaseRecord> extends SyncCollectionOptions<T> {
    retryOnReconnect?: boolean;
    onConflict?: ConflictResolver<T>;
    batchMutations?: {
        maxBatchSize: number;
        batchDelayMs: number;
    };
    onConnectionChange?: (event: {
        connected: boolean;
        previousState: SyncState;
    }) => void;
    autoReconnect?: {
        enabled: boolean;
        maxRetries: number;
        initialDelay: number;
        maxDelay: number;
        backoffMultiplier: number;
    };
    healthCheck?: {
        interval: number;
        timeout: number;
    };
    offlineSupport?: boolean;
}
/**
 * SyncCollection - A collection that maintains real-time sync
 */
export declare class SyncCollection<T extends BaseRecord> implements Collection<T> {
    readonly id: string;
    readonly table: string;
    readonly syncUrl: string;
    private items;
    private subscribers;
    private options;
    private syncState;
    private pollIntervalId;
    private pendingMutations;
    private debug;
    private retryOnReconnect;
    private onConflict?;
    private batchConfig?;
    private batchTimeout?;
    private pendingBatch;
    private onConnectionChange?;
    private autoReconnectConfig?;
    private _healthCheckConfig?;
    private offlineSupport;
    private isCurrentlyOffline;
    private syncStateChangeHandlers;
    private healthStatus;
    constructor(options: ExtendedSyncCollectionOptions<T>);
    /**
     * Get the health check configuration
     */
    getHealthCheckConfig(): {
        interval: number;
        timeout: number;
    } | undefined;
    /**
     * Expose fetchData for testing
     */
    fetchData(): Promise<void>;
    /**
     * Debug log helper - only logs if debug mode is enabled
     */
    private debugLog;
    /**
     * Get all items in the collection
     */
    getAll(): T[];
    /**
     * Get item by ID
     */
    get(id: string | number): T | undefined;
    /**
     * Connect to the sync endpoint and start syncing
     */
    connect(): Promise<void>;
    /**
     * Schedule an auto-reconnect attempt
     */
    private scheduleReconnect;
    /**
     * Register a sync state change handler
     */
    onSyncStateChange(handler: (event: string, state: SyncState) => void): () => void;
    /**
     * Get health status
     */
    getHealthStatus(): {
        status: 'healthy' | 'degraded' | 'unhealthy';
        lastCheckAt: number;
        latencyMs: number;
        consecutiveFailures: number;
    };
    /**
     * Check if the collection is currently offline
     */
    isOffline(): boolean;
    /**
     * Disconnect from sync
     */
    disconnect(): void;
    /**
     * Clear all local data and pending mutations
     */
    clear(): void;
    /**
     * Get the current subscriber count for debugging
     */
    getSubscriberCount(): number;
    /**
     * Insert a new item
     */
    insert(data: Omit<T, 'id'> & {
        id?: T['id'];
    }): Promise<T>;
    /**
     * Update an existing item
     */
    update(id: string | number, data: Partial<T>): Promise<T>;
    /**
     * Delete an item
     */
    delete(id: string | number): Promise<void>;
    /**
     * Subscribe to changes
     */
    subscribe(callback: (items: T[]) => void): () => void;
    /**
     * Get current sync state
     */
    getSyncState(): SyncState;
    /**
     * Get the pending mutation count
     */
    getPendingMutationCount(): number;
    /**
     * Dispose of all resources - call when the collection is no longer needed
     */
    dispose(): void;
    private buildSyncUrl;
    private mergeData;
    /**
     * Clear pending mutations that have been confirmed by the server.
     * - Insert/Update mutations are confirmed when the item appears in sync response
     * - Delete mutations are confirmed when the item does NOT appear in sync response
     */
    private clearConfirmedMutations;
    private scheduleBatchFlush;
    private startPolling;
    private stopPolling;
    private generateId;
    private generateMutationId;
    private updatePendingCount;
    /**
     * Emit a sync state change event to all registered handlers
     */
    private emitSyncStateEvent;
    private notifySubscribers;
}
/**
 * Factory function to create a SyncCollection.
 *
 * @param options - Configuration including table name, sync URL, and polling parameters
 * @returns A new SyncCollection instance configured for real-time sync
 *
 * @example
 * ```typescript
 * const todos = createSyncCollection({
 *   id: 'todos',
 *   table: 'todos',
 *   syncUrl: 'https://db.postgres.do/v1/shape',
 *   pollInterval: 5000,
 * })
 * await todos.connect()
 * ```
 */
export declare function createSyncCollection<T extends BaseRecord>(options: SyncCollectionOptions<T>): SyncCollection<T>;
/**
 * SyncEngine - Manages multiple sync collections
 */
export interface SyncEngineOptions {
    baseUrl: string;
}
export declare class SyncEngine {
    private baseUrl;
    private collections;
    constructor(options: SyncEngineOptions);
    /**
     * Register a collection for syncing
     */
    registerCollection<T extends BaseRecord>(options: Omit<SyncCollectionOptions<T>, 'syncUrl'> & {
        syncUrl?: string;
    }): SyncCollection<T>;
    /**
     * Get a registered collection
     */
    getCollection<T extends BaseRecord>(id: string): SyncCollection<T> | undefined;
    /**
     * Get all collection IDs
     */
    getCollectionIds(): string[];
    /**
     * Connect all collections
     */
    connectAll(): Promise<void>;
    /**
     * Disconnect all collections
     */
    disconnectAll(): void;
    /**
     * Get total pending mutations across all collections
     */
    getTotalPendingMutations(): number;
    /**
     * Dispose all resources
     */
    dispose(): Promise<void>;
}
export {};
//# sourceMappingURL=sync-collection.d.ts.map