/**
 * Interface for WebSocket messages
 */
export interface WebSocketMessage {
    [key: string]: unknown;
}
/**
 * Filter configuration for WebSocket stream
 */
export interface WebSocketStreamFilter {
    /** Channel type to filter (e.g., 'transcript', 'scene_index') */
    channel?: string;
    /** Specific ID to filter (e.g., rtstream ID, index ID) */
    id?: string;
}
/**
 * WebSocketConnection class for real-time event streaming from VideoDB
 *
 * @example
 * ```typescript
 * const conn = videodb.connect(apiKey);
 * const ws = await conn.connectWebsocket();
 * await ws.connect();
 *
 * for await (const message of ws.receive()) {
 *   console.log('Received:', message);
 * }
 *
 * await ws.close();
 * ```
 */
export declare class WebSocketConnection {
    url: string;
    connectionId?: string;
    private _connection;
    private _messageHandlers;
    private _closeHandlers;
    private _errorHandlers;
    private _messageQueue;
    private _resolvers;
    constructor(url: string);
    /**
     * Establish the WebSocket connection
     * @returns Promise that resolves to this WebSocketConnection instance
     */
    connect(): Promise<WebSocketConnection>;
    /**
     * Handle incoming message - either queue it or pass to handler
     */
    private _handleMessage;
    /**
     * Close the WebSocket connection
     */
    close(): Promise<void>;
    /**
     * Send a message over the WebSocket
     * @param message - Message to send
     */
    send(message: WebSocketMessage): Promise<void>;
    /**
     * Register a message handler
     * @param handler - Function to call when a message is received
     */
    onMessage(handler: (message: WebSocketMessage) => void): void;
    /**
     * Register a close handler
     * @param handler - Function to call when the connection closes
     */
    onClose(handler: () => void): void;
    /**
     * Register an error handler
     * @param handler - Function to call when an error occurs
     */
    onError(handler: (error: Error) => void): void;
    /**
     * Check if the WebSocket is connected
     */
    get isConnected(): boolean;
    /**
     * Async generator that yields received messages
     * Use this with for-await-of loop
     *
     * @example
     * ```typescript
     * for await (const message of ws.receive()) {
     *   console.log(message);
     * }
     * ```
     */
    receive(): AsyncGenerator<WebSocketMessage, void, unknown>;
    /**
     * Async generator that yields filtered messages
     * Use this with for-await-of loop to receive messages matching the filter
     *
     * @param filter - Filter configuration with optional channel and id properties
     *
     * @example
     * ```typescript
     * // Listen for transcript events from a specific rtstream
     * for await (const ev of ws.stream({ channel: 'transcript', id: 'rts-xxx' })) {
     *   console.log('Transcript:', ev.data.text);
     * }
     *
     * // Listen for all scene index events
     * for await (const ev of ws.stream({ channel: 'scene_index' })) {
     *   console.log('Scene:', ev);
     * }
     * ```
     */
    stream(filter?: WebSocketStreamFilter): AsyncGenerator<WebSocketMessage, void, unknown>;
    /**
     * Async dispose method for use with `await using` syntax (TypeScript 5.2+)
     * Enables automatic cleanup when exiting scope
     *
     * @example
     * ```typescript
     * await using ws = await conn.connectWebsocket();
     * await ws.connect();
     * for await (const message of ws.receive()) {
     *   console.log(message);
     * }
     * // Connection automatically closed when scope exits
     * ```
     */
    [Symbol.asyncDispose](): Promise<void>;
}