import { BaseUser, BaseUser as BaseUser$1, BroadcastProxy, ConnectionState, CrdtDocLike, EventMessage, EventNotifierSubscriptionCallback, EventRecord, EventRecord as EventRecord$1, IOEventMessage, IOLike, IORouterLike, Id, InferIOAuthorize, InferIOAuthorizeUser, InferIOCrdt, InferIOCrdtKind, InferIOEvents, InferIOInput, InferIOOutput, InputZodLike, JsonObject, MaybePromise, MergeEvents, MergeEvents as MergeEvents$1, ProcedureLike, RoomEventListenerMap, RoomLike, RoomLike as RoomLike$1, SubscribeProxy, UpdateMyPresenceAction, UserInfo, UserInfo as UserInfo$1, WebSocketConnection, WebSocketConnection as WebSocketConnection$1, WebSocketState } from "@pluv/types";
import { AbstractCrdtDocFactory, CrdtType, InferCrdtJson, InferCrdtJson as InferCrdtJson$1, InferDoc, InferDocLike, InferStorage, NoopCrdtDocFactory } from "@pluv/crdt";

//#region src/AbstractStorageStore.d.ts
declare abstract class AbstractStorageStore {
  room: string;
  constructor(room: string);
  abstract addUpdate(update: string): Promise<void>;
  abstract destroy(): Promise<void>;
  abstract flatten(encodedState: string): Promise<void>;
  abstract getShouldFlatten(): Promise<boolean>;
  abstract getUpdates(start?: number): Promise<readonly string[]>;
  abstract initialize(): Promise<void>;
}
//#endregion
//#region src/utils/identity.d.ts
declare const identity: <T extends unknown>(x: T) => T;
//#endregion
//#region src/infer.d.ts
type InferCallback<TIO extends IOLike<any, any, any>> = (i: typeof identity) => {
  io: (io: TIO) => TIO;
};
declare const infer: <TIO extends IOLike<any, any, any>>(callback: InferCallback<TIO>) => InferCallback<IOLike<InferIOAuthorize<TIO>, InferIOCrdt<TIO>, InferIOEvents<TIO>>>;
//#endregion
//#region src/types.d.ts
type EventResolver<TIO extends IOLike, TInput extends JsonObject, TOutput extends EventRecord$1<string, any>, TPresence extends Record<string, any>, TDocLike extends CrdtDocLike<any, any>> = (data: TInput, context: EventResolverContext<TIO, TPresence, TDocLike>) => MaybePromise<TOutput | void>;
interface EventResolverContext<TIO extends IOLike, TPresence extends Record<string, any>, TDocLike extends CrdtDocLike<any, any>> {
  doc: TDocLike;
  others: readonly UserInfo$1<TIO, TPresence>[];
  room: string;
  user: UserInfo$1<TIO, TPresence>;
}
type InferMetadata<TClient extends PluvClient<any, any, any, any>> = TClient extends PluvClient<any, any, any, infer IMetadata> ? IMetadata : never;
type MergeEventRecords<TEventRecords extends EventRecord$1<string, any>[], TRoot extends EventRecord$1<string, any> = {}> = TEventRecords extends [infer IHead extends EventRecord$1<string, any>, ...infer ITail extends EventRecord$1<string, any>[]] ? MergeEventRecords<ITail, Omit<TRoot, keyof IHead> & { [P in keyof IHead]: TRoot extends Record<P, any> ? TRoot[P] | IHead[P] : IHead[P] }> : Id<TRoot>;
interface PluvClientLimits {
  /**
   * @description Maximum size of presence object in bytes
   */
  presenceMaxSize?: number | null;
}
interface PublicKeyParams<TMetadata extends JsonObject> {
  metadata: TMetadata;
}
type PublicKey<TMetadata extends JsonObject> = string | ((params: PublicKeyParams<TMetadata>) => string);
type WithMetadata<TMetadata extends JsonObject = {}> = keyof TMetadata extends never ? {
  metadata?: undefined;
} : {
  metadata: TMetadata;
};
//#endregion
//#region src/PluvProcedure.d.ts
interface PluvProcedureConfig<TIO extends IOLike, TInput extends JsonObject, TOutput extends EventRecord$1<string, any>, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>> {
  broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, InferDocLike<TCrdt>> | null;
  input?: InputZodLike<TInput>;
}
declare class PluvProcedure<TIO extends IOLike, TInput extends JsonObject, TOutput extends EventRecord$1<string, any>, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>, TFilled extends "input" | "broadcast" | ""> implements ProcedureLike<TInput, TOutput> {
  private _broadcast;
  private _input;
  get config(): ProcedureLike<TInput, TOutput>["config"];
  constructor(config?: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TCrdt>);
  broadcast<TResult extends EventRecord$1<string, any> = {}>(resolver: EventResolver<TIO, TInput, TResult, TPresence, InferDocLike<TCrdt>>): Omit<PluvProcedure<TIO, TInput, MergeEventRecords<[TOutput, TResult]>, TPresence, TCrdt, TFilled | "input" | "broadcast">, TFilled | "input" | "broadcast">;
  input<TData extends JsonObject>(input: InputZodLike<TData>): Omit<PluvProcedure<TIO, TData, {}, TPresence, TCrdt, TFilled | "input">, TFilled | "input">;
  private _resolver;
}
//#endregion
//#region src/CrdtManager.d.ts
type CrdtManagerOptions<TCrdt extends AbstractCrdtDocFactory<any, any>> = {
  initialStorage?: TCrdt;
};
//#endregion
//#region src/PluvRouter.d.ts
type PluvRouterEventConfig<TIO extends IOLike, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>> = {
  [P: string]: Pick<PluvProcedure<TIO, any, any, TPresence, TCrdt, "">, "config">;
};
type MergedRouter<TRouters extends PluvRouter<TIO, TPresence, TCrdt, any>[], TIO extends IOLike, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>, TRoot extends TRouters[0]["_defs"]["events"]> = TRouters extends [infer IHead extends PluvRouter<TIO, TPresence, TCrdt, any>, ...infer ITail extends PluvRouter<TIO, TPresence, TCrdt, any>[]] ? MergedRouter<ITail, TIO, TPresence, TCrdt, TRoot & IHead["_defs"]["events"]> : PluvRouter<TIO, TPresence, TCrdt, TRoot>;
declare class PluvRouter<TIO extends IOLike, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>, TEvents extends PluvRouterEventConfig<TIO, TPresence, TCrdt> = {}> implements IORouterLike<TEvents> {
  readonly _defs: {
    events: TEvents;
  };
  constructor(events: TEvents);
  static merge<TRouters extends PluvRouter<TIO, TPresence, TCrdt, any>[], TIO extends IOLike, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>>(...routers: TRouters): MergedRouter<TRouters, TIO, TPresence, TCrdt, {}>;
  private _isValidEventName;
}
//#endregion
//#region src/UsersManager.d.ts
type UsersManagerConfig<TPresence extends Record<string, any> = {}> = {
  initialPresence?: TPresence;
  limits: PluvClientLimits;
  presence?: InputZodLike<TPresence>;
};
//#endregion
//#region src/PluvRoom.d.ts
declare global {
  var process: {
    env: {
      [key: string]: string | undefined;
    };
  };
}
interface EndpointParams<TMetadata extends JsonObject> {
  metadata: TMetadata;
  room: string;
}
type AuthEndpoint<TMetadata extends JsonObject> = string | ((params: EndpointParams<TMetadata>) => string | FetchOptions) | true;
type WsEndpoint<TMetadata extends JsonObject> = string | ((params: EndpointParams<TMetadata>) => string);
type FetchOptions = {
  url: string;
  options?: RequestInit;
};
type RoomEndpoints<TIO extends IOLike<any, any, any>, TMetadata extends JsonObject> = {
  wsEndpoint?: WsEndpoint<TMetadata>;
} & (InferIOAuthorizeUser<InferIOAuthorize<TIO>> extends BaseUser$1 ? {
  authEndpoint: AuthEndpoint<TMetadata>;
} : {
  authEndpoint?: undefined;
});
type PluvRoomAddon<TIO extends IOLike, TMetadata extends JsonObject, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>> = (input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TCrdt>) => Partial<PluvRoomAddonResult>;
interface PluvRoomAddonInput<TIO extends IOLike, TMetadata extends JsonObject, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>> {
  room: PluvRoom<TIO, TMetadata, TPresence, TCrdt>;
}
interface PluvRoomAddonResult {
  storage: AbstractStorageStore;
}
type PluvRoomDebug<TIO extends IOLike> = Id<{
  output: readonly (keyof InferIOOutput<TIO>)[];
  input: readonly (keyof InferIOInput<TIO>)[];
}>;
type RoomConnectParams<TMetadata extends JsonObject = {}> = keyof TMetadata extends never ? [] : [WithMetadata<TMetadata>];
interface ReconnectTimeoutMsParams {
  attempts: number;
}
type ReconnectTimeoutMs = number | ((params: ReconnectTimeoutMsParams) => number);
type RoomConfig<TIO extends IOLike, TMetadata extends JsonObject, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>, TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>> = Id<{
  addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt>[];
  debug?: boolean | PluvRoomDebug<TIO>;
  limits: PluvClientLimits;
  onAuthorizationFail?: (error: Error) => void;
  metadata?: InputZodLike<TMetadata>;
  publicKey?: PublicKey<TMetadata>;
  reconnectTimeoutMs?: ReconnectTimeoutMs;
  router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
} & RoomEndpoints<TIO, TMetadata> & Pick<CrdtManagerOptions<TCrdt>, "initialStorage"> & UsersManagerConfig<TPresence>>;
declare class PluvRoom<TIO extends IOLike<any, any, any>, TMetadata extends JsonObject = {}, TPresence extends Record<string, any> = {}, TCrdt extends AbstractCrdtDocFactory<any, any> = NoopCrdtDocFactory, TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {}> implements RoomLike$1<TIO, InferDoc<TCrdt>, TPresence, InferStorage<TCrdt>> {
  #private;
  readonly _endpoints: RoomEndpoints<TIO, TMetadata>;
  readonly id: string;
  readonly metadata?: InputZodLike<TMetadata>;
  private readonly _crdtManager;
  private readonly _crdtNotifier;
  private readonly _debug;
  private readonly _eventNotifier;
  private readonly _intervals;
  private readonly _limits;
  private readonly _listenerManager;
  private readonly _listeners;
  private readonly _publicKey;
  private readonly _reconnectTimeoutMs;
  private readonly _router;
  private readonly _stateNotifier;
  private readonly _storageStore;
  private readonly _subscriptions;
  private readonly _timeouts;
  private readonly _usersManager;
  private readonly _usersNotifier;
  private _lastMetadata;
  private _state;
  private _windowListeners;
  private _wsListeners;
  constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TCrdt, TEvents>);
  get webSocket(): WebSocket | null;
  addEventListener<TKind extends keyof RoomEventListenerMap>(kind: TKind, handler: RoomEventListenerMap[TKind]): () => void;
  broadcast: BroadcastProxy<TIO, TEvents>;
  canRedo: () => boolean;
  canUndo: () => boolean;
  connect(...args: RoomConnectParams<TMetadata>): Promise<void>;
  disconnect(): Promise<void>;
  getConnection: () => WebSocketConnection$1;
  getDoc: () => CrdtDocLike<InferDoc<TCrdt>, InferStorage<TCrdt>>;
  getMyPresence: () => TPresence;
  getMyself: () => Id<UserInfo$1<TIO, TPresence>> | null;
  getOther: (connectionId: string) => Id<UserInfo$1<TIO, TPresence>> | null;
  getOthers: () => readonly Id<UserInfo$1<TIO, TPresence>>[];
  getStorage: <TKey extends keyof InferStorage<TCrdt>>(type: TKey) => InferStorage<TCrdt>[TKey] | null;
  getStorageJson(): InferCrdtJson$1<InferStorage<TCrdt>> | null;
  getStorageJson<TKey extends keyof InferStorage<TCrdt>>(type: TKey): InferCrdtJson$1<InferStorage<TCrdt>[TKey]> | null;
  getStorageLoaded: () => boolean;
  redo: () => void;
  subscribe: SubscribeProxy<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
  transact: (fn: (storage: InferStorage<TCrdt>) => void, origin?: string) => void;
  undo: () => void;
  updateMyPresence: (presence: UpdateMyPresenceAction<TPresence>) => void;
  private _addToStorageStore;
  private _attachWindowListeners;
  private _attachWsListeners;
  private _clearInterval;
  private _clearTimeout;
  private _closeWs;
  private _detachWindowListeners;
  private _detachWsListeners;
  private _emitSharedTypes;
  private _event;
  private _flattenStorageStore;
  private _getAddon;
  private _getAuthFetchOptions;
  private _getAuthorization;
  private _getPublicKey;
  private _getWsEndpoint;
  private _handleExit;
  private _handlePresenceUpdatedMessage;
  private _handleReceiveOthers;
  private _handleRegisteredMessage;
  private _handleStorageReceivedMessage;
  private _handleStorageUpdatedMessage;
  private _handleSyncStateReceived;
  private _handleUserJoinedMessage;
  private _heartbeat;
  private _logDebug;
  private _observeCrdt;
  private _onAuthorizationFail;
  private _onClose;
  /**
   * TODO
   * @description Handle websocket errors in a meaningful way, should they occur
   * @date August 19, 2022
   */
  private _onError;
  private _onMessage;
  private _onOpen;
  private _onNavigatorOffline;
  private _onNavigatorOnline;
  private _onVisibilityChange;
  private _onWindowFocus;
  private _other;
  private _parseMessage;
  private _pollReconnect;
  private _reconnect;
  private _sendMessage;
  private _setMetadata;
  private _updateState;
}
//#endregion
//#region src/PluvClient.d.ts
type PluvClientOptions<TIO extends IOLike<any, any, any>, TPresence extends Record<string, any>, TCrdt extends InferIOCrdtKind<TIO>, TMetadata extends JsonObject> = RoomEndpoints<TIO, TMetadata> & {
  debug?: boolean;
  /**
   * @description Configurable limits defined for client-side validation. You should only set
   * this if you control the server and have changed the limits there.
   */
  limits?: PluvClientLimits;
  metadata?: InputZodLike<TMetadata>;
  presence?: InputZodLike<TPresence>;
  publicKey?: PublicKey<TMetadata>;
  types: InferCallback<TIO>;
} & (InferIOCrdtKind<TIO> extends NoopCrdtDocFactory ? {
  initialStorage?: "[ERROR]: Must provide crdt to createIO to use storage";
} : {
  initialStorage?: TCrdt;
});
type CreateRoomOptions<TIO extends IOLike<any, any, any>, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>, TMetadata extends JsonObject, TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {}> = {
  addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, InferStorage<TCrdt>>[];
  debug?: boolean | PluvRoomDebug<TIO>;
  initialPresence?: TPresence;
  initialStorage?: TCrdt;
  onAuthorizationFail?: (error: Error) => void;
  reconnectTimeoutMs?: ReconnectTimeoutMs;
  router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
};
type EnterRoomParams<TMetadata extends JsonObject = {}> = keyof TMetadata extends never ? [] : [WithMetadata<TMetadata>];
declare class PluvClient<TIO extends IOLike<any, any, any>, TPresence extends Record<string, any> = {}, TCrdt extends InferIOCrdtKind<TIO> = InferIOCrdtKind<TIO>, TMetadata extends JsonObject = {}> {
  readonly metadata?: InputZodLike<TMetadata>;
  private readonly _authEndpoint;
  private readonly _debug;
  private readonly _initialStorage?;
  private readonly _limits;
  private readonly _presence?;
  private readonly _publicKey;
  private readonly _rooms;
  private readonly _wsEndpoint;
  get _defs(): {
    initialStorage: TCrdt | undefined;
  };
  get procedure(): PluvProcedure<TIO, {}, {}, TPresence, TCrdt, "">;
  constructor(options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>);
  createRoom: <TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {}>(room: string, options?: CreateRoomOptions<TIO, TPresence, TCrdt, TMetadata, TEvents>) => PluvRoom<TIO, TMetadata, TPresence, TCrdt, TEvents>;
  enter: (room: string | PluvRoom<TIO, TMetadata, any, any, any>, ...args: EnterRoomParams<TMetadata>) => Promise<PluvRoom<TIO, TMetadata, TPresence, TCrdt, any>>;
  getRoom: (room: string) => PluvRoom<TIO, TMetadata, TPresence, TCrdt, any> | null;
  getRooms: () => readonly PluvRoom<TIO, TMetadata, TPresence, TCrdt, any>[];
  leave: (room: string | PluvRoom<TIO, any, any, any>) => Promise<void>;
  router<TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {}>(events: TEvents): PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
  private _logDebug;
}
//#endregion
//#region src/createClient.d.ts
declare const createClient: <TIO extends IOLike<any, any, any>, TPresence extends Record<string, any> = {}, TCrdt extends InferIOCrdtKind<TIO> = InferIOCrdtKind<TIO>, TMetadata extends JsonObject = {}>(options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>) => PluvClient<TIO, TPresence, TCrdt, TMetadata>;
//#endregion
//#region src/MockedRoom.d.ts
type MockedRoomEvents<TIO extends IOLike> = Partial<{ [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>> }>;
type MockedRoomConfig<TIO extends IOLike, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>, TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>> = {
  events?: MockedRoomEvents<MergeEvents$1<TEvents, TIO>>;
  limits?: PluvClientLimits;
  router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
} & Pick<CrdtManagerOptions<TCrdt>, "initialStorage"> & Omit<UsersManagerConfig<TPresence>, "limits">;
declare class MockedRoom<TIO extends IOLike, TPresence extends Record<string, any>, TCrdt extends AbstractCrdtDocFactory<any, any>, TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>> implements RoomLike$1<TIO, InferDoc<TCrdt>, TPresence, InferStorage<TCrdt>> {
  #private;
  readonly id: string;
  private readonly _crdtManager;
  private readonly _crdtNotifier;
  private readonly _eventNotifier;
  private readonly _events?;
  private readonly _limits;
  private readonly _usersNotifier;
  private readonly _router;
  private _state;
  private readonly _stateNotifier;
  private readonly _subscriptions;
  private readonly _usersManager;
  constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TCrdt, TEvents>);
  addEventListener<TKind extends keyof RoomEventListenerMap>(kind: TKind, handler: RoomEventListenerMap[TKind]): () => void;
  broadcast: BroadcastProxy<TIO, TEvents>;
  canRedo: () => boolean;
  canUndo: () => boolean;
  getConnection: () => WebSocketConnection$1;
  getDoc(): CrdtDocLike<InferDoc<TCrdt>, InferStorage<TCrdt>>;
  getMyPresence: () => TPresence;
  getMyself: () => Id<UserInfo$1<TIO, TPresence>> | null;
  getOther: (connectionId: string) => Id<UserInfo$1<TIO, TPresence>> | null;
  getOthers: () => readonly Id<UserInfo$1<TIO, TPresence>>[];
  getStorage: <TKey extends keyof InferStorage<TCrdt>>(type: TKey) => InferStorage<TCrdt>[TKey] | null;
  getStorageJson(): InferCrdtJson$1<InferStorage<TCrdt>> | null;
  getStorageJson<TKey extends keyof InferStorage<TCrdt>>(type: TKey): InferCrdtJson$1<InferStorage<TCrdt>[TKey]> | null;
  getStorageLoaded(): boolean;
  redo: () => void;
  storageRoot: (fn: (value: { [P in keyof InferStorage<TCrdt>]: InferCrdtJson$1<InferStorage<TCrdt>[P]> }) => void) => (() => void);
  subscribe: SubscribeProxy<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
  transact: (fn: (storage: InferStorage<TCrdt>) => void, origin?: string) => void;
  undo: () => void;
  updateMyPresence: (presence: UpdateMyPresenceAction<TPresence>) => void;
  private _event;
  private _observeCrdt;
  private _other;
  private _simulateEvent;
}
//#endregion
//#region src/register.d.ts
interface RegisterParams<TMetadata extends JsonObject> {
  authEndpoint: AuthEndpoint<TMetadata>;
  publicKey: string;
}
declare const register: <TMetadata extends JsonObject>(params: RegisterParams<TMetadata>) => {
  authEndpoint: AuthEndpoint<TMetadata>;
  publicKey: string;
  wsEndpoint: (params: EndpointParams<TMetadata>) => string;
};
//#endregion
export { AbstractStorageStore, type BaseUser, ConnectionState, type CrdtType, type CreateRoomOptions, type EnterRoomParams, type EventMessage, type EventNotifierSubscriptionCallback, type EventRecord, type IOEventMessage, type InferCallback, type InferCrdtJson, type InferMetadata, type MergeEvents, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, type PluvProcedureConfig, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, type PluvRouter, type PluvRouterEventConfig, type PublicKey, type PublicKeyParams, type RegisterParams, type RoomConnectParams, type RoomEndpoints, type RoomLike, type UserInfo, type WebSocketConnection, type WebSocketState, createClient, infer, register };
//# sourceMappingURL=index.d.mts.map