/**
 * db4ai Real-Time Subscription Manager
 *
 * Provides real-time subscription functionality for query results and single documents.
 * Built on top of @db4/rpc WebSocket subscriptions.
 *
 * @packageDocumentation
 */
import type { WhereClause } from './query.js';
/**
 * Subscription state.
 */
export type SubscriptionState = 'pending' | 'active' | 'paused' | 'closed' | 'error';
/**
 * Subscription event type.
 */
export type SubscriptionEventType = 'change' | 'create' | 'update' | 'delete' | 'error' | 'initial';
/**
 * Subscription event data.
 */
export interface SubscriptionEvent<T = unknown> {
    /** Event type */
    type: SubscriptionEventType;
    /** Event data */
    data: T;
    /** Previous value (for updates) */
    previousData?: T;
    /** Timestamp of the event */
    timestamp: number;
}
/**
 * Callback function for query subscriptions.
 */
export type QuerySubscriptionCallback<T> = (docs: T[], event?: SubscriptionEvent<T[]>) => void;
/**
 * Callback function for single document subscriptions.
 */
export type DocumentSubscriptionCallback<T> = (doc: T | null, event?: SubscriptionEvent<T | null>) => void;
/**
 * Unsubscribe function returned by subscribe methods.
 */
export type Unsubscribe = () => void;
/**
 * Subscription options.
 */
export interface SubscriptionOptions {
    /** Debounce changes before emitting (ms) */
    debounce?: number;
    /** Include initial data on subscribe */
    includeInitial?: boolean;
}
/**
 * WebSocket connection state.
 */
export type WebSocketState = 'connecting' | 'open' | 'closing' | 'closed';
/**
 * Reconnection options.
 */
export interface ReconnectOptions {
    /** Maximum reconnect attempts */
    maxAttempts?: number;
    /** Initial delay in ms */
    initialDelay?: number;
    /** Maximum delay in ms */
    maxDelay?: number;
    /** Backoff multiplier */
    backoffMultiplier?: number;
}
/**
 * Manages real-time subscriptions for db4ai.
 */
export declare class SubscriptionManager<TDocument = unknown> {
    private subscriptions;
    private subscriptionCounter;
    private ws;
    private wsState;
    private reconnectAttempts;
    private reconnectTimer;
    private pendingSubscriptions;
    private readonly url;
    private readonly reconnectOptions;
    private messageHandlers;
    private mockDataStore;
    private mockQueryResults;
    constructor(url: string, options?: ReconnectOptions);
    /**
     * Connect to the WebSocket server.
     */
    connect(): Promise<void>;
    /**
     * Disconnect from the WebSocket server.
     */
    disconnect(): void;
    /**
     * Get the current WebSocket state.
     */
    get connectionState(): WebSocketState;
    /**
     * Subscribe to query results.
     */
    subscribe<T extends TDocument = TDocument>(filter: WhereClause<T>, callback: QuerySubscriptionCallback<T>, options?: SubscriptionOptions): Unsubscribe;
    /**
     * Subscribe to a single document by ID.
     */
    subscribeOne<T extends TDocument = TDocument>(documentId: string, callback: DocumentSubscriptionCallback<T>, options?: SubscriptionOptions): Unsubscribe;
    /**
     * Unsubscribe from a subscription.
     */
    private unsubscribe;
    /**
     * Get all active subscriptions.
     */
    getSubscriptions(): Array<{
        id: string;
        type: 'query' | 'document';
        state: SubscriptionState;
    }>;
    /**
     * Emit a change event for testing purposes.
     */
    emitChange<T extends TDocument>(type: SubscriptionEventType, data: T, documentId?: string): void;
    /**
     * Simulate connection loss for testing.
     */
    simulateConnectionLoss(): void;
    /**
     * Simulate reconnection for testing.
     */
    simulateReconnect(): Promise<void>;
    /**
     * Set mock data for testing.
     */
    setMockData(documentId: string, data: TDocument): void;
    /**
     * Set mock query results for testing.
     */
    setMockQueryResults(filterKey: string, results: TDocument[]): void;
    private generateSubscriptionId;
    private sendSubscribe;
    private handleMessage;
    private handleDisconnect;
    private resubscribeAll;
    private getMatchingDocuments;
    private documentMatchesFilter;
    private getDocumentId;
}
/**
 * Creates a subscription interface for a collection.
 */
export declare function createCollectionSubscription<T>(manager: SubscriptionManager<T>, collectionName: string): {
    /**
     * Subscribe to query results.
     */
    subscribe(filter: WhereClause<T>, callback: QuerySubscriptionCallback<T>, options?: SubscriptionOptions): Unsubscribe;
    /**
     * Subscribe to a single document by ID.
     */
    subscribeOne(documentId: string, callback: DocumentSubscriptionCallback<T>, options?: SubscriptionOptions): Unsubscribe;
};
/**
 * Create a new subscription manager.
 */
export declare function createSubscriptionManager<T = unknown>(url: string, options?: ReconnectOptions): SubscriptionManager<T>;
//# sourceMappingURL=subscription.d.ts.map