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

//#region src/provider/index.d.ts
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;
  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 | null;
      resyncInterval?: number;
      maxBackoffTime?: number;
      disableBc?: boolean;
    }
  );
  /**
   * @type {boolean}
   */
  get synced(): boolean;
  set synced(state: boolean);
  destroy(): void;
  connectBc(): void;
  disconnectBc(): void;
  disconnect(): void;
  /**
   * Called by the close handler to re-establish the WebSocket.
   * Subclasses (e.g. YProvider) override this to refresh dynamic
   * params before reconnecting.
   */
  _reconnectWS(): void;
  connect(): void;
}
type Params = Record<string, string | null | undefined>;
type ParamsProvider = Params | (() => Params | Promise<Params>);
type BaseProviderOptions = ConstructorParameters<typeof WebsocketProvider>[3];
type YProviderOptions = Omit<NonNullable<BaseProviderOptions>, "params"> & {
  connectionId?: string;
  party?: string;
  prefix?: string;
  params?: ParamsProvider;
  protocol?: "ws" | "wss";
};
declare class YProvider extends WebsocketProvider {
  #private;
  id: string;
  constructor(
    host: string,
    room: string,
    doc?: Doc,
    options?: YProviderOptions
  );
  connect(): Promise<void>;
  _reconnectWS(): Promise<void>;
  sendMessage(message: string): void;
}
//#endregion
export {
  WebsocketProvider,
  YProvider as default,
  messageAuth,
  messageAwareness,
  messageQueryAwareness,
  messageSync
};
//# sourceMappingURL=index.d.ts.map