import * as decoding from 'lib0/decoding';
import * as encoding from 'lib0/encoding';
import { Observable } from 'lib0/observable';
import * as awarenessProtocol from 'y-protocols/awareness';
import { Doc } from 'yjs';

declare const messageSync = 0;
declare const messageQueryAwareness = 3;
declare const messageAwareness = 1;
declare const messageAuth = 2;
declare const messageHandlers: Array<(encoder: encoding.Encoder, decoder: decoding.Decoder, provider: WebsocketProvider, emitSynced: boolean, messageType: number) => void>;
type AwarenessUpdate = {
    added: number[];
    updated: number[];
    removed: number[];
};
/**
 * Websocket Provider for Yjs. Creates a websocket connection to sync the shared document.
 * The document name is attached to the provided url. I.e. the following example
 * creates a websocket connection to http://localhost:1234/my-document-name
 *
 * @example
 *   import * as Y from 'yjs'
 *   import { WebsocketProvider } from 'y-websocket'
 *   const doc = new Y.Doc()
 *   const provider = new WebsocketProvider('http://localhost:1234', 'my-document-name', doc)
 *
 * @extends {Observable<string>}
 */
declare class WebsocketProvider extends Observable<string> {
    maxBackoffTime: number;
    bcChannel: string;
    url: string;
    roomname: string;
    doc: Doc;
    _WS: typeof WebSocket;
    awareness: awarenessProtocol.Awareness;
    wsconnected: boolean;
    wsconnecting: boolean;
    bcconnected: boolean;
    disableBc: boolean;
    wsUnsuccessfulReconnects: number;
    messageHandlers: typeof messageHandlers;
    _synced: boolean;
    ws: WebSocket | null;
    wsLastMessageReceived: number;
    shouldConnect: boolean;
    _resyncInterval: ReturnType<typeof setInterval> | number;
    _bcSubscriber: (message: Uint8Array, origin: unknown) => void;
    _updateHandler: (update: Uint8Array, origin: unknown) => void;
    _awarenessUpdateHandler: (update: AwarenessUpdate, origin: unknown) => void;
    _unloadHandler: () => void;
    _checkInterval: ReturnType<typeof setInterval> | number;
    constructor(serverUrl: string, roomname: string, doc: Doc, { connect, awareness, params, isPrefixedUrl, WebSocketPolyfill, // Optionally provide a WebSocket polyfill
    resyncInterval, // Request server state every `resyncInterval` milliseconds
    maxBackoffTime, // Maximum amount of time to wait before trying to reconnect (we try to reconnect using exponential backoff)
    disableBc }?: {
        connect?: boolean;
        awareness?: awarenessProtocol.Awareness;
        params?: {
            [s: string]: string;
        };
        isPrefixedUrl?: boolean;
        WebSocketPolyfill?: typeof WebSocket;
        resyncInterval?: number;
        maxBackoffTime?: number;
        disableBc?: boolean;
    });
    /**
     * @type {boolean}
     */
    get synced(): boolean;
    set synced(state: boolean);
    destroy(): void;
    connectBc(): void;
    disconnectBc(): void;
    disconnect(): void;
    connect(): void;
}
type Params = Record<string, string | null | undefined>;
type ParamsProvider = Params | (() => Params | Promise<Params>);
type BaseProviderOptions = ConstructorParameters<typeof WebsocketProvider>[3];
type YPartyKitProviderOptions = Omit<NonNullable<BaseProviderOptions>, "params"> & {
    connectionId?: string;
    party?: string;
    prefix?: string;
    params?: ParamsProvider;
    protocol?: "ws" | "wss";
};
declare class YPartyKitProvider extends WebsocketProvider {
    #private;
    id: string;
    constructor(host: string, room: string, doc?: Doc, options?: YPartyKitProviderOptions);
    connect(): void;
}

export { WebsocketProvider, YPartyKitProvider as default, messageAuth, messageAwareness, messageQueryAwareness, messageSync };