@pluv/client 0.25.4 → 0.27.0

package/dist/index.d.ts

@@ -1,16 +1,12 @@
 import { CrdtType, AbstractCrdtDoc, InferCrdtJson, AbstractCrdtDocFactory } from '@pluv/crdt';
 export { CrdtType, InferCrdtJson } from '@pluv/crdt';
 import * as _pluv_types from '@pluv/types';
-import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, InferIOAuthorizeUser, InferIOAuthorize, InferIOInput, InputZodLike, InferIOAuthorizeRequired } from '@pluv/types';
+import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, InferIOAuthorizeUser, InferIOAuthorize, EventRecord, MaybePromise, InputZodLike, ProcedureLike, IORouterLike, InferIOInput, InferIOAuthorizeRequired } from '@pluv/types';
 export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
 import { Subject } from 'wonka';
 
 type EventNotifierSubscriptionCallback<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
 
-interface AuthorizationState<TIO extends IOLike> {
-    token: string | null;
-    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
-}
 declare enum ConnectionState {
     Closed = "Closed",
     Connecting = "Connecting",
@@ -18,6 +14,24 @@ declare enum ConnectionState {
     Unavailable = "Unavailable",
     Untouched = "Untouched"
 }
+
+interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
+}
+type EventResolver<TIO extends IOLike = IOLike, TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = (data: TInput, context: EventResolverContext<TIO, TPresence, TStorage>) => MaybePromise<TOutput | void>;
+interface EventResolverContext<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
+    doc: AbstractCrdtDoc<TStorage>;
+    others: readonly UserInfo<TIO, TPresence>[];
+    room: string;
+    user: UserInfo<TIO, TPresence>;
+}
+type MergeEventRecords<TEventRecords extends EventRecord<string, any>[], TRoot extends EventRecord<string, any> = {}> = TEventRecords extends [
+    infer IHead extends EventRecord<string, any>,
+    ...infer ITail extends EventRecord<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>;
 type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
 interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
     connectionId: string;
@@ -37,6 +51,40 @@ interface WebSocketState<TIO extends IOLike> {
 
 type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (value: Id<UserInfo<TIO>> | null) => void;
 
+interface PluvProcedureConfig<TIO extends IOLike = IOLike, TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
+    broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, TStorage> | null;
+    input?: InputZodLike<TInput>;
+}
+declare class PluvProcedure<TIO extends IOLike = IOLike, TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TFilled extends "input" | "broadcast" | "" = ""> {
+    private _broadcast;
+    private _input;
+    get config(): ProcedureLike<TInput, TOutput>["config"];
+    constructor(config?: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TStorage>);
+    broadcast<TResult extends EventRecord<string, any> = {}>(resolver: EventResolver<TIO, TInput, TResult, TPresence, TStorage>): Omit<PluvProcedure<TIO, TInput, MergeEventRecords<[TOutput, TResult]>, TPresence, TStorage, TFilled | "input" | "broadcast">, TFilled | "input" | "broadcast">;
+    input<TData extends JsonObject>(input: InputZodLike<TData>): Omit<PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">, TFilled | "input">;
+    private _resolver;
+}
+
+type PluvRouterEventConfig<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = {
+    [P: string]: Pick<PluvProcedure<TIO, any, any, TPresence, TStorage>, "config">;
+};
+type MergedRouter<TRouters extends PluvRouter<TIO, TPresence, TStorage, any>[] = [], TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TRoot extends TRouters[0]["_defs"]["events"] = {}> = TRouters extends [
+    infer IHead extends PluvRouter<TIO, TPresence, TStorage, any>,
+    ...infer ITail extends PluvRouter<TIO, TPresence, TStorage, any>[]
+] ? MergedRouter<ITail, TIO, TPresence, TStorage, TRoot & IHead["_defs"]["events"]> : PluvRouter<TIO, TPresence, TStorage, TRoot>;
+type MergeEvents<TClientEvents extends PluvRouterEventConfig<any, any, any>, TServerIO extends IOLike<any, any>> = TServerIO extends IOLike<infer IAuthorize, infer IServerEvents> ? IOLike<IAuthorize, {
+    [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<infer IClientInput, infer IClientOutput> ? {
+        [K in keyof IClientOutput]: K extends keyof IServerEvents ? IServerEvents[K] : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
+    }[keyof IClientOutput] : never;
+} & IServerEvents> : never;
+declare class PluvRouter<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> implements IORouterLike<TEvents> {
+    readonly _defs: {
+        events: TEvents;
+    };
+    constructor(events: TEvents);
+    static merge<TRouters extends PluvRouter<any, any, any, any>[]>(...routers: TRouters): MergedRouter<TRouters>;
+}
+
 interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
     connection: Subject<Id<WebSocketState<TIO>>>;
     "my-presence": Subject<TPresence | null>;
@@ -47,15 +95,15 @@ interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject
 type InferSubjectValue<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
 type SubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
 
-declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
+declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> {
     readonly id: string;
     constructor(room: string);
     abstract storageLoaded: boolean;
-    abstract broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    abstract broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>): void;
     abstract canRedo(): boolean;
     abstract canUndo(): boolean;
     abstract getDoc(): AbstractCrdtDoc<TStorage>;
-    abstract event<TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>): () => void;
+    abstract event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>): () => void;
     abstract getConnection(): WebSocketConnection;
     abstract getMyPresence(): TPresence;
     abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
@@ -97,48 +145,6 @@ type UsersManagerConfig<TPresence extends JsonObject = {}> = {
     presence?: InputZodLike<TPresence>;
 };
 
-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 JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = {
-    events?: MockedRoomEvents<TIO>;
-} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
-declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
-    private _crdtManager;
-    private _crdtNotifier;
-    private _eventNotifier;
-    private _events?;
-    private _otherNotifier;
-    private _state;
-    private _stateNotifier;
-    private _subscriptions;
-    private _usersManager;
-    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>);
-    get storageLoaded(): boolean;
-    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
-    canRedo: () => boolean;
-    canUndo: () => boolean;
-    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
-    getConnection: () => WebSocketConnection;
-    getDoc(): AbstractCrdtDoc<TStorage>;
-    getMyPresence: () => TPresence;
-    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
-    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
-    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
-    getStorage: <TKey extends keyof TStorage>(type: TKey) => TStorage[TKey] | null;
-    getStorageJson(): InferCrdtJson<TStorage> | null;
-    getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
-    other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
-    redo: () => void;
-    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void) => (() => void);
-    storageRoot: (fn: (value: { [P in keyof TStorage]: InferCrdtJson<TStorage[P]>; }) => void) => (() => void);
-    subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
-    transact: (fn: (storage: TStorage) => void, origin?: string) => void;
-    undo: () => void;
-    updateMyPresence: (presence: UpdateMyPresenceAction<TPresence>) => void;
-    private _observeCrdt;
-}
-
 declare global {
     var process: {
         env: {
@@ -146,22 +152,26 @@ declare global {
         };
     };
 }
-type AuthEndpoint = string | ((room: string) => string | FetchOptions) | true;
-type WsEndpoint = string | ((room: string) => string);
+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> = {
-    wsEndpoint?: WsEndpoint;
+type RoomEndpoints<TIO extends IOLike, TMetadata extends JsonObject> = {
+    wsEndpoint?: WsEndpoint<TMetadata>;
 } & (InferIOAuthorizeRequired<InferIOAuthorize<TIO>> extends true ? {
-    authEndpoint: AuthEndpoint;
+    authEndpoint: AuthEndpoint<TMetadata>;
 } : {
     authEndpoint?: undefined;
 });
-type PluvRoomAddon<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
-interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
-    room: PluvRoom<TIO, TPresence, TStorage>;
+type PluvRoomAddon<TIO extends IOLike = IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = (input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
+interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
+    room: PluvRoom<TIO, TMetadata, TPresence, TStorage>;
 }
 interface PluvRoomAddonResult {
     storage: AbstractStorageStore;
@@ -170,21 +180,27 @@ type PluvRoomDebug<TIO extends IOLike> = Id<{
     output: readonly (keyof InferIOOutput<TIO>)[];
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
-type PluvRoomOptions<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = {
-    addons?: readonly PluvRoomAddon<TIO, TPresence, TStorage>[];
+type RoomConfig<TIO extends IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> = Id<{
+    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
     debug?: boolean | PluvRoomDebug<TIO>;
     onAuthorizationFail?: (error: Error) => void;
-} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
-type RoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = RoomEndpoints<TIO> & PluvRoomOptions<TIO, TPresence, TStorage>;
-declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
-    readonly _endpoints: RoomEndpoints<TIO>;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & RoomEndpoints<TIO, TMetadata> & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> & UsersManagerConfig<TPresence> & (keyof TMetadata extends never ? {
+    metadata?: undefined;
+} : {
+    metadata: TMetadata;
+})>;
+declare class PluvRoom<TIO extends IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    readonly _endpoints: RoomEndpoints<TIO, TMetadata>;
     private _crdtManager;
     private _crdtNotifier;
     private _debug;
     private _eventNotifier;
     private _intervals;
     private _listeners;
+    private _metadata;
     private _otherNotifier;
+    private _router;
     private _state;
     private _stateNotifier;
     private _storageStore;
@@ -193,15 +209,15 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _windowListeners;
     private _wsListeners;
     private _usersManager;
-    constructor(room: string, options: RoomConfig<TIO, TPresence, TStorage>);
+    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>);
     get storageLoaded(): boolean;
     get webSocket(): WebSocket | null;
-    broadcast: (<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>) => void) & { [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => void; };
+    broadcast: (<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>) => Promise<void>) & { [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => Promise<void>; };
     canRedo: () => boolean;
     canUndo: () => boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    event: (<TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => () => void) & { [event in keyof InferIOOutput<TIO>]: (callback: EventNotifierSubscriptionCallback<TIO, event>) => () => void; };
+    event: (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>) => () => void) & { [event in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>) => () => void; };
     getConnection: () => WebSocketConnection;
     getDoc: () => AbstractCrdtDoc<TStorage>;
     getMyPresence: () => TPresence;
@@ -270,23 +286,93 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _updateState;
 }
 
-type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO> & {
+declare const identity: <T extends unknown>(x: T) => T;
+
+type InferCallback<TIO extends IOLike> = (i: typeof identity) => {
+    io: (io: TIO) => TIO;
+};
+type PluvClientOptions<TIO extends IOLike, TPresence extends JsonObject, TStorage extends Record<string, CrdtType<any, any>>, TMetadata extends JsonObject> = RoomEndpoints<TIO, TMetadata> & {
     debug?: boolean;
+    infer: InferCallback<TIO>;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    metadata?: InputZodLike<TMetadata>;
+    presence?: InputZodLike<TPresence>;
 };
-declare class PluvClient<TIO extends IOLike = IOLike> {
+type CreateRoomOptions<TIO extends IOLike, TPresence extends JsonObject, TStorage extends Record<string, CrdtType<any, any>>, TMetadata extends JsonObject, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> = {
+    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
+    debug?: boolean | PluvRoomDebug<TIO>;
+    initialPresence?: TPresence;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    onAuthorizationFail?: (error: Error) => void;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & (keyof TMetadata extends never ? {
+    metadata?: undefined;
+} : {
+    metadata: TMetadata;
+});
+declare class PluvClient<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TMetadata extends JsonObject = {}> {
     private _authEndpoint;
     private _debug;
+    private _initialStorage?;
+    private _presence?;
     private _wsEndpoint;
     private _rooms;
-    constructor(options: PluvClientOptions<TIO>);
-    createRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(room: string, options: PluvRoomOptions<TIO, TPresence, TStorage>) => PluvRoom<TIO, TPresence, TStorage>;
-    enter: (room: string | PluvRoom<TIO, any, any>) => Promise<PluvRoom<TIO, JsonObject, any>>;
-    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
-    getRooms: () => readonly PluvRoom<TIO, JsonObject, any>[];
-    leave: (room: string | PluvRoom<TIO, any, any>) => Promise<void>;
+    get procedure(): PluvProcedure<TIO, {}, {}, TPresence, TStorage>;
+    constructor(options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>);
+    createRoom: <TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(room: string, options: CreateRoomOptions<TIO, TPresence, TStorage, TMetadata, TEvents>) => PluvRoom<TIO, TMetadata, TPresence, TStorage>;
+    enter: (room: string | PluvRoom<TIO, any, any, any>) => Promise<PluvRoom<TIO, TMetadata, TPresence, TStorage, any>>;
+    getRoom: (room: string) => PluvRoom<TIO, TMetadata, TPresence, TStorage, any> | null;
+    getRooms: () => readonly PluvRoom<TIO, TMetadata, TPresence, TStorage, any>[];
+    leave: (room: string | PluvRoom<TIO, any, any, any>) => Promise<void>;
+    router<TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(events: TEvents): PluvRouter<TIO, TPresence, TStorage, TEvents>;
     private _logDebug;
 }
 
-declare const createClient: <TIO extends IOLike = IOLike<_pluv_types.IOAuthorize<any, any, any>, {}>>(options: PluvClientOptions<TIO>) => PluvClient<TIO>;
+declare const createClient: <TIO extends IOLike = IOLike<_pluv_types.IOAuthorize<any, any, any>, {}>, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TMetadata extends JsonObject = {}>(options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>) => PluvClient<TIO, TPresence, TStorage, TMetadata>;
+
+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 JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> = {
+    events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> & UsersManagerConfig<TPresence>;
+declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    private _crdtManager;
+    private _crdtNotifier;
+    private _eventNotifier;
+    private _events?;
+    private _otherNotifier;
+    private _router;
+    private _state;
+    private _stateNotifier;
+    private _subscriptions;
+    private _usersManager;
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage, TEvents>);
+    get storageLoaded(): boolean;
+    broadcast: (<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>) => Promise<void>) & { [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => Promise<void>; };
+    canRedo: () => boolean;
+    canUndo: () => boolean;
+    event: (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>) => () => void) & { [event in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>) => () => void; };
+    getConnection: () => WebSocketConnection;
+    getDoc(): AbstractCrdtDoc<TStorage>;
+    getMyPresence: () => TPresence;
+    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
+    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
+    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
+    getStorage: <TKey extends keyof TStorage>(type: TKey) => TStorage[TKey] | null;
+    getStorageJson(): InferCrdtJson<TStorage> | null;
+    getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
+    other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
+    redo: () => void;
+    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void) => (() => void);
+    storageRoot: (fn: (value: { [P in keyof TStorage]: InferCrdtJson<TStorage[P]>; }) => void) => (() => void);
+    subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
+    transact: (fn: (storage: TStorage) => void, origin?: string) => void;
+    undo: () => void;
+    updateMyPresence: (presence: UpdateMyPresenceAction<TPresence>) => void;
+    private _observeCrdt;
+    private _simulateEvent;
+}
 
-export { AbstractRoom, AbstractStorageStore, ConnectionState, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, type UserInfo, type WebSocketConnection, type WebSocketState, createClient };
+export { AbstractRoom, AbstractStorageStore, ConnectionState, type CreateRoomOptions, type MergeEvents, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, type PluvProcedureConfig, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, PluvRouter, type PluvRouterEventConfig, type UserInfo, type WebSocketConnection, type WebSocketState, createClient };