import { AbstractPGProvider } from './provider';
import type { PGProvider, PGProviderConnection, PGProviderResult } from './provider';
interface PGWebSocketCloseEvent {
    readonly code: number;
    readonly reason: string;
}
interface PGWebSocketMessageEvent {
    readonly data?: any;
}
interface PGWebSocketErrorEvent {
    readonly error?: any;
}
export interface PGWebSocket {
    addEventListener(event: 'close', handler: (event: PGWebSocketCloseEvent) => void): void;
    addEventListener(event: 'error', handler: (event: PGWebSocketErrorEvent) => void): void;
    addEventListener(event: 'message', handler: (event: PGWebSocketMessageEvent) => void): void;
    addEventListener(event: 'open', handler: () => void): void;
    removeEventListener(event: 'close', handler: (event: PGWebSocketCloseEvent) => void): void;
    removeEventListener(event: 'error', handler: (event: PGWebSocketErrorEvent) => void): void;
    removeEventListener(event: 'message', handler: (event: PGWebSocketMessageEvent) => void): void;
    removeEventListener(event: 'open', handler: () => void): void;
    readonly readyState: number;
    send(message: string): void;
    close(code?: number, reason?: string): void;
}
/** A connection to the database backed by a `WebSocket` */
export interface WebSocketConnection extends PGProviderConnection {
    /** Close this connection and the underlying `WebSocket` */
    close(): void;
}
/** An abstract provider implementing `connect(...)` via WHATWG WebSockets */
export declare abstract class WebSocketProvider extends AbstractPGProvider implements PGProvider<WebSocketConnection> {
    private readonly _connections;
    abstract query(text: string, params?: (string | null)[]): Promise<PGProviderResult>;
    /** Return a unique request identifier to correlate responses */
    protected abstract _getUniqueRequestId(): string;
    /**
     * Create a new WebSocket.
     *
     * This method can be asynchronous and can return a `Promise`. This is
     * due to the fact that in order to create our authentication token with the
     * Web Cryptography API, we need to _await_ the resolution of our token.
     *
     * This method should call _synchronously_ the {@link WebSocketProvider._connectWebSocket}
     * as soon as the WebSocket instance is created, in order to handle `open`,
     * `close`, or `error` events before the event loop has a chance to resolve
     * the `Promise` asynchronously.
     */
    protected abstract _getWebSocket(): Promise<PGWebSocket>;
    /**
     * Handle the initial connection of a WebSocket.
     *
     * This method should be called _synchronously_ by {@link WebSocketProvider._getWebSocket} as
     * soon as the WebSocket instance is created.
     */
    protected _connectWebSocket<S extends PGWebSocket>(socket: S): Promise<S>;
    acquire(): Promise<WebSocketConnection>;
    release(connection: WebSocketConnection): Promise<void>;
    destroy(): Promise<void>;
}
export {};