@liveblocks/client 0.15.0-alpha.2 → 0.15.0

package/lib/esm/client.js

@@ -1,76 +0,0 @@
-import { createRoom } from "./room";
-/**
- * Create a client that will be responsible to communicate with liveblocks servers.
- *
- * @example
- * const client = createClient({
- *   authEndpoint: "/api/auth"
- * });
- *
- * // It's also possible to use a function to call your authentication endpoint.
- * // Useful to add additional headers or use an API wrapper (like Firebase functions)
- * const client = createClient({
- *   authEndpoint: async (room) => {
- *     const response = await fetch("/api/auth", {
- *       method: "POST",
- *       headers: {
- *          Authentication: "token",
- *          "Content-Type": "application/json"
- *       },
- *       body: JSON.stringify({ room })
- *     });
- *
- *     return await response.json();
- *   }
- * });
- */
-export function createClient(options) {
-    const clientOptions = options;
-    if (typeof clientOptions.throttle === "number") {
-        if (clientOptions.throttle < 80 || clientOptions.throttle > 1000) {
-            throw new Error("Liveblocks client throttle should be between 80 and 1000 ms");
-        }
-    }
-    const rooms = new Map();
-    function getRoom(roomId) {
-        const internalRoom = rooms.get(roomId);
-        return internalRoom ? internalRoom.room : null;
-    }
-    function enter(roomId, options = {}) {
-        let internalRoom = rooms.get(roomId);
-        if (internalRoom) {
-            return internalRoom.room;
-        }
-        internalRoom = createRoom(roomId, Object.assign(Object.assign({}, clientOptions), options));
-        rooms.set(roomId, internalRoom);
-        internalRoom.connect();
-        return internalRoom.room;
-    }
-    function leave(roomId) {
-        let room = rooms.get(roomId);
-        if (room) {
-            room.disconnect();
-            rooms.delete(roomId);
-        }
-    }
-    if (typeof window !== "undefined") {
-        // TODO: Expose a way to clear these
-        window.addEventListener("online", () => {
-            for (const [, room] of rooms) {
-                room.onNavigatorOnline();
-            }
-        });
-    }
-    if (typeof document !== "undefined") {
-        document.addEventListener("visibilitychange", () => {
-            for (const [, room] of rooms) {
-                room.onVisibilityChange(document.visibilityState);
-            }
-        });
-    }
-    return {
-        getRoom,
-        enter,
-        leave,
-    };
-}

package/lib/esm/immutable.d.ts

@@ -1,9 +0,0 @@
-import { LiveList } from "./LiveList";
-import { LiveObject } from "./LiveObject";
-import { StorageUpdate } from "./types";
-export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
-export declare function liveNodeToJson(value: any): any;
-export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
-export declare function patchLiveObjectKey<T>(liveObject: LiveObject<T>, key: keyof T, prev: any, next: any): void;
-export declare function patchLiveObject<T extends Record<string, any>>(root: LiveObject<T>, prev: T, next: T): void;
-export declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;

package/lib/esm/immutable.js

@@ -1,282 +0,0 @@
-import { LiveList } from "./LiveList";
-import { LiveMap } from "./LiveMap";
-import { LiveObject } from "./LiveObject";
-import { LiveRegister } from "./LiveRegister";
-export function liveObjectToJson(liveObject) {
-    const result = {};
-    const obj = liveObject.toObject();
-    for (const key in obj) {
-        result[key] = liveNodeToJson(obj[key]);
-    }
-    return result;
-}
-function liveMapToJson(map) {
-    const result = {};
-    const obj = Object.fromEntries(map);
-    for (const key in obj) {
-        result[key] = liveNodeToJson(obj[key]);
-    }
-    return result;
-}
-function liveListToJson(value) {
-    return value.toArray().map(liveNodeToJson);
-}
-export function liveNodeToJson(value) {
-    if (value instanceof LiveObject) {
-        return liveObjectToJson(value);
-    }
-    else if (value instanceof LiveList) {
-        return liveListToJson(value);
-    }
-    else if (value instanceof LiveMap) {
-        return liveMapToJson(value);
-    }
-    else if (value instanceof LiveRegister) {
-        return value.data;
-    }
-    return value;
-}
-function isPlainObject(obj) {
-    return Object.prototype.toString.call(obj) === "[object Object]";
-}
-function anyToCrdt(obj) {
-    if (obj == null) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return new LiveList(obj.map(anyToCrdt));
-    }
-    if (isPlainObject(obj)) {
-        const init = {};
-        for (const key in obj) {
-            init[key] = anyToCrdt(obj[key]);
-        }
-        return new LiveObject(init);
-    }
-    return obj;
-}
-export function patchLiveList(liveList, prev, next) {
-    let i = 0;
-    let prevEnd = prev.length - 1;
-    let nextEnd = next.length - 1;
-    let prevNode = prev[0];
-    let nextNode = next[0];
-    /**
-     * For A,B,C => A,B,C,D
-     * i = 3, prevEnd = 2, nextEnd = 3
-     *
-     * For A,B,C => B,C
-     * i = 2, prevEnd = 2, nextEnd = 1
-     *
-     * For B,C => A,B,C
-     * i = 0, pre
-     */
-    outer: {
-        while (prevNode === nextNode) {
-            ++i;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[i];
-            nextNode = next[i];
-        }
-        prevNode = prev[prevEnd];
-        nextNode = next[nextEnd];
-        while (prevNode === nextNode) {
-            prevEnd--;
-            nextEnd--;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[prevEnd];
-            nextNode = next[nextEnd];
-        }
-    }
-    if (i > prevEnd) {
-        if (i <= nextEnd) {
-            while (i <= nextEnd) {
-                liveList.insert(anyToCrdt(next[i]), i);
-                i++;
-            }
-        }
-    }
-    else if (i > nextEnd) {
-        let localI = i;
-        while (localI <= prevEnd) {
-            liveList.delete(i);
-            localI++;
-        }
-    }
-    else {
-        while (i <= prevEnd && i <= nextEnd) {
-            prevNode = prev[i];
-            nextNode = next[i];
-            const liveListNode = liveList.get(i);
-            if (liveListNode instanceof LiveObject &&
-                isPlainObject(prevNode) &&
-                isPlainObject(nextNode)) {
-                patchLiveObject(liveListNode, prevNode, nextNode);
-            }
-            else {
-                liveList.delete(i);
-                liveList.insert(anyToCrdt(nextNode), i);
-            }
-            i++;
-        }
-        while (i <= nextEnd) {
-            liveList.insert(anyToCrdt(next[i]), i);
-            i++;
-        }
-        while (i <= prevEnd) {
-            liveList.delete(i);
-            i++;
-        }
-    }
-}
-export function patchLiveObjectKey(liveObject, key, prev, next) {
-    const value = liveObject.get(key);
-    if (next === undefined) {
-        liveObject.delete(key);
-    }
-    else if (value === undefined) {
-        liveObject.set(key, anyToCrdt(next));
-    }
-    else if (prev === next) {
-        return;
-    }
-    else if (value instanceof LiveList &&
-        Array.isArray(prev) &&
-        Array.isArray(next)) {
-        patchLiveList(value, prev, next);
-    }
-    else if (value instanceof LiveObject &&
-        isPlainObject(prev) &&
-        isPlainObject(next)) {
-        patchLiveObject(value, prev, next);
-    }
-    else {
-        liveObject.set(key, anyToCrdt(next));
-    }
-}
-export function patchLiveObject(root, prev, next) {
-    const updates = {};
-    for (const key in next) {
-        patchLiveObjectKey(root, key, prev[key], next[key]);
-    }
-    for (const key in prev) {
-        if (next[key] === undefined) {
-            root.delete(key);
-        }
-    }
-    if (Object.keys(updates).length > 0) {
-        root.update(updates);
-    }
-}
-function getParentsPath(node) {
-    const path = [];
-    while (node._parentKey != null && node._parent != null) {
-        if (node._parent instanceof LiveList) {
-            path.push(node._parent._indexOfPosition(node._parentKey));
-        }
-        else {
-            path.push(node._parentKey);
-        }
-        node = node._parent;
-    }
-    return path;
-}
-export function patchImmutableObject(state, updates) {
-    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
-}
-function patchImmutableObjectWithUpdate(state, update) {
-    const path = getParentsPath(update.node);
-    return patchImmutableNode(state, path, update);
-}
-function patchImmutableNode(state, path, update) {
-    var _a, _b, _c, _d;
-    const pathItem = path.pop();
-    if (pathItem === undefined) {
-        switch (update.type) {
-            case "LiveObject": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveObject but state was not an object");
-                }
-                let newState = Object.assign({}, state);
-                for (const key in update.updates) {
-                    if (((_a = update.updates[key]) === null || _a === void 0 ? void 0 : _a.type) === "update") {
-                        newState[key] = liveNodeToJson(update.node.get(key));
-                    }
-                    else if (((_b = update.updates[key]) === null || _b === void 0 ? void 0 : _b.type) === "delete") {
-                        delete newState[key];
-                    }
-                }
-                return newState;
-            }
-            case "LiveList": {
-                if (Array.isArray(state) === false) {
-                    throw new Error("Internal: received update on LiveList but state was not an array");
-                }
-                let newState = state.map((x) => x);
-                for (const listUpdate of update.updates) {
-                    if (listUpdate.type === "insert") {
-                        if (listUpdate.index === newState.length) {
-                            newState.push(liveNodeToJson(listUpdate.item));
-                        }
-                        else {
-                            newState = [
-                                ...newState.slice(0, listUpdate.index),
-                                liveNodeToJson(listUpdate.item),
-                                ...newState.slice(listUpdate.index),
-                            ];
-                        }
-                    }
-                    else if (listUpdate.type === "delete") {
-                        newState.splice(listUpdate.index, 1);
-                    }
-                    else if (listUpdate.type === "move") {
-                        if (listUpdate.previousIndex > listUpdate.index) {
-                            newState = [
-                                ...newState.slice(0, listUpdate.index),
-                                liveNodeToJson(listUpdate.item),
-                                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
-                                ...newState.slice(listUpdate.previousIndex + 1),
-                            ];
-                        }
-                        else {
-                            newState = [
-                                ...newState.slice(0, listUpdate.previousIndex),
-                                ...newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1),
-                                liveNodeToJson(listUpdate.item),
-                                ...newState.slice(listUpdate.index + 1),
-                            ];
-                        }
-                    }
-                }
-                return newState;
-            }
-            case "LiveMap": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveMap but state was not an object");
-                }
-                let newState = Object.assign({}, state);
-                for (const key in update.updates) {
-                    if (((_c = update.updates[key]) === null || _c === void 0 ? void 0 : _c.type) === "update") {
-                        newState[key] = liveNodeToJson(update.node.get(key));
-                    }
-                    else if (((_d = update.updates[key]) === null || _d === void 0 ? void 0 : _d.type) === "delete") {
-                        delete newState[key];
-                    }
-                }
-                return newState;
-            }
-        }
-    }
-    if (Array.isArray(state)) {
-        const newArray = [...state];
-        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
-        return newArray;
-    }
-    else {
-        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
-    }
-}

package/lib/esm/index.d.ts

@@ -1,6 +0,0 @@
-export { LiveObject } from "./LiveObject";
-export { LiveMap } from "./LiveMap";
-export { LiveList } from "./LiveList";
-export type { Others, Presence, Room, Client, User, BroadcastOptions, } from "./types";
-export { createClient } from "./client";
-export { liveObjectToJson, liveNodeToJson, patchLiveList, patchImmutableObject, patchLiveObject, patchLiveObjectKey, } from "./immutable";

package/lib/esm/live.js

@@ -1,46 +0,0 @@
-export var ServerMessageType;
-(function (ServerMessageType) {
-    ServerMessageType[ServerMessageType["UpdatePresence"] = 100] = "UpdatePresence";
-    ServerMessageType[ServerMessageType["UserJoined"] = 101] = "UserJoined";
-    ServerMessageType[ServerMessageType["UserLeft"] = 102] = "UserLeft";
-    ServerMessageType[ServerMessageType["Event"] = 103] = "Event";
-    ServerMessageType[ServerMessageType["RoomState"] = 104] = "RoomState";
-    ServerMessageType[ServerMessageType["InitialStorageState"] = 200] = "InitialStorageState";
-    ServerMessageType[ServerMessageType["UpdateStorage"] = 201] = "UpdateStorage";
-})(ServerMessageType || (ServerMessageType = {}));
-export var ClientMessageType;
-(function (ClientMessageType) {
-    ClientMessageType[ClientMessageType["UpdatePresence"] = 100] = "UpdatePresence";
-    ClientMessageType[ClientMessageType["ClientEvent"] = 103] = "ClientEvent";
-    ClientMessageType[ClientMessageType["FetchStorage"] = 200] = "FetchStorage";
-    ClientMessageType[ClientMessageType["UpdateStorage"] = 201] = "UpdateStorage";
-})(ClientMessageType || (ClientMessageType = {}));
-export var CrdtType;
-(function (CrdtType) {
-    CrdtType[CrdtType["Object"] = 0] = "Object";
-    CrdtType[CrdtType["List"] = 1] = "List";
-    CrdtType[CrdtType["Map"] = 2] = "Map";
-    CrdtType[CrdtType["Register"] = 3] = "Register";
-})(CrdtType || (CrdtType = {}));
-export var OpType;
-(function (OpType) {
-    OpType[OpType["Init"] = 0] = "Init";
-    OpType[OpType["SetParentKey"] = 1] = "SetParentKey";
-    OpType[OpType["CreateList"] = 2] = "CreateList";
-    OpType[OpType["UpdateObject"] = 3] = "UpdateObject";
-    OpType[OpType["CreateObject"] = 4] = "CreateObject";
-    OpType[OpType["DeleteCrdt"] = 5] = "DeleteCrdt";
-    OpType[OpType["DeleteObjectKey"] = 6] = "DeleteObjectKey";
-    OpType[OpType["CreateMap"] = 7] = "CreateMap";
-    OpType[OpType["CreateRegister"] = 8] = "CreateRegister";
-})(OpType || (OpType = {}));
-export var WebsocketCloseCodes;
-(function (WebsocketCloseCodes) {
-    WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
-    WebsocketCloseCodes[WebsocketCloseCodes["INVALID_MESSAGE_FORMAT"] = 4000] = "INVALID_MESSAGE_FORMAT";
-    WebsocketCloseCodes[WebsocketCloseCodes["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
-})(WebsocketCloseCodes || (WebsocketCloseCodes = {}));

package/lib/esm/position.d.ts

@@ -1,6 +0,0 @@
-export declare const min = 32;
-export declare const max = 126;
-export declare function makePosition(before?: string, after?: string): string;
-export declare function posCodes(str: string): number[];
-export declare function pos(codes: number[]): string;
-export declare function compare(posA: string, posB: string): number;

package/lib/esm/position.js

@@ -1,106 +0,0 @@
-export const min = 32;
-export const max = 126;
-export function makePosition(before, after) {
-    // No children
-    if (before == null && after == null) {
-        return pos([min + 1]);
-    }
-    // Insert at the end
-    if (before != null && after == null) {
-        return getNextPosition(before);
-    }
-    // Insert at the start
-    if (before == null && after != null) {
-        return getPreviousPosition(after);
-    }
-    return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
-}
-function getPreviousPosition(after) {
-    const result = [];
-    const afterCodes = posCodes(after);
-    for (let i = 0; i < afterCodes.length; i++) {
-        const code = afterCodes[i];
-        if (code <= min + 1) {
-            result.push(min);
-            if (afterCodes.length - 1 === i) {
-                result.push(max);
-                break;
-            }
-        }
-        else {
-            result.push(code - 1);
-            break;
-        }
-    }
-    return pos(result);
-}
-function getNextPosition(before) {
-    const result = [];
-    const beforeCodes = posCodes(before);
-    for (let i = 0; i < beforeCodes.length; i++) {
-        const code = beforeCodes[i];
-        if (code === max) {
-            result.push(code);
-            if (beforeCodes.length - 1 === i) {
-                result.push(min + 1);
-                break;
-            }
-        }
-        else {
-            result.push(code + 1);
-            break;
-        }
-    }
-    return pos(result);
-}
-function makePositionFromCodes(before, after) {
-    let index = 0;
-    const result = [];
-    while (true) {
-        const beforeDigit = before[index] || min;
-        const afterDigit = after[index] || max;
-        if (beforeDigit > afterDigit) {
-            throw new Error(`Impossible to generate position between ${before} and ${after}`);
-        }
-        if (beforeDigit === afterDigit) {
-            result.push(beforeDigit);
-            index++;
-            continue;
-        }
-        if (afterDigit - beforeDigit === 1) {
-            result.push(beforeDigit);
-            result.push(...makePositionFromCodes(before.slice(index + 1), []));
-            break;
-        }
-        const mid = (afterDigit + beforeDigit) >> 1;
-        result.push(mid);
-        break;
-    }
-    return result;
-}
-export function posCodes(str) {
-    const codes = [];
-    for (let i = 0; i < str.length; i++) {
-        codes.push(str.charCodeAt(i));
-    }
-    return codes;
-}
-export function pos(codes) {
-    return String.fromCharCode(...codes);
-}
-export function compare(posA, posB) {
-    const aCodes = posCodes(posA);
-    const bCodes = posCodes(posB);
-    const maxLength = Math.max(aCodes.length, bCodes.length);
-    for (let i = 0; i < maxLength; i++) {
-        const a = aCodes[i] == null ? min : aCodes[i];
-        const b = bCodes[i] == null ? min : bCodes[i];
-        if (a === b) {
-            continue;
-        }
-        else {
-            return a - b;
-        }
-    }
-    throw new Error(`Impossible to compare similar position "${posA}" and "${posB}"`);
-}

package/lib/esm/room.d.ts

@@ -1,159 +0,0 @@
-import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate, BroadcastOptions } from "./types";
-import { ClientMessage, Op } from "./live";
-import { LiveMap } from "./LiveMap";
-import { LiveObject } from "./LiveObject";
-import { LiveList } from "./LiveList";
-import { AbstractCrdt } from "./AbstractCrdt";
-declare type HistoryItem = Array<Op | {
-    type: "presence";
-    data: Presence;
-}>;
-declare type IdFactory = () => string;
-export declare type State = {
-    connection: Connection;
-    lastConnectionId: number | null;
-    socket: WebSocket | null;
-    lastFlushTime: number;
-    buffer: {
-        presence: Presence | null;
-        messages: ClientMessage[];
-        storageOperations: Op[];
-    };
-    timeoutHandles: {
-        flush: number | null;
-        reconnect: number;
-        pongTimeout: number;
-    };
-    intervalHandles: {
-        heartbeat: number;
-    };
-    listeners: {
-        event: EventCallback[];
-        others: OthersEventCallback[];
-        "my-presence": MyPresenceCallback[];
-        error: ErrorCallback[];
-        connection: ConnectionCallback[];
-        storage: StorageCallback[];
-    };
-    me: Presence;
-    others: Others;
-    users: {
-        [connectionId: number]: User;
-    };
-    idFactory: IdFactory | null;
-    numberOfRetry: number;
-    defaultStorageRoot?: {
-        [key: string]: any;
-    };
-    clock: number;
-    opClock: number;
-    items: Map<string, AbstractCrdt>;
-    root: LiveObject | undefined;
-    undoStack: HistoryItem[];
-    redoStack: HistoryItem[];
-    isHistoryPaused: boolean;
-    pausedHistory: HistoryItem;
-    isBatching: boolean;
-    batch: {
-        ops: Op[];
-        reverseOps: HistoryItem;
-        updates: {
-            others: [];
-            presence: boolean;
-            storageUpdates: Map<string, StorageUpdate>;
-        };
-    };
-    offlineOperations: Map<string, Op>;
-};
-export declare type Effects = {
-    authenticate(): void;
-    send(messages: ClientMessage[]): void;
-    delayFlush(delay: number): number;
-    startHeartbeatInterval(): number;
-    schedulePongTimeout(): number;
-    scheduleReconnect(delay: number): number;
-};
-declare type Context = {
-    room: string;
-    authEndpoint: AuthEndpoint;
-    liveblocksServer: string;
-    throttleDelay: number;
-    publicApiKey?: string;
-};
-export declare function makeStateMachine(state: State, context: Context, mockedEffects?: Effects): {
-    onOpen: () => void;
-    onClose: (event: {
-        code: number;
-        wasClean: boolean;
-        reason: any;
-    }) => void;
-    onMessage: (event: MessageEvent) => void;
-    authenticationSuccess: (token: AuthenticationToken, socket: WebSocket) => void;
-    heartbeat: () => void;
-    onNavigatorOnline: () => void;
-    simulateSocketClose: () => void;
-    simulateSendCloseEvent: (event: {
-        code: number;
-        wasClean: boolean;
-        reason: any;
-    }) => void;
-    onVisibilityChange: (visibilityState: VisibilityState) => void;
-    getUndoStack: () => HistoryItem[];
-    getItemsCount: () => number;
-    connect: () => null | undefined;
-    disconnect: () => void;
-    subscribe: {
-        (callback: (updates: StorageUpdate) => void): () => void;
-        <TKey extends string, TValue>(liveMap: LiveMap<TKey, TValue>, callback: (liveMap: LiveMap<TKey, TValue>) => void): () => void;
-        <TData>(liveObject: LiveObject<TData>, callback: (liveObject: LiveObject<TData>) => void): () => void;
-        <TItem>(liveList: LiveList<TItem>, callback: (liveList: LiveList<TItem>) => void): () => void;
-        <TItem_1 extends AbstractCrdt>(node: TItem_1, callback: (updates: StorageUpdate[]) => void, options: {
-            isDeep: true;
-        }): () => void;
-        <T extends Presence>(type: "my-presence", listener: MyPresenceCallback<T>): () => void;
-        <T_1 extends Presence>(type: "others", listener: OthersEventCallback<T_1>): () => void;
-        (type: "event", listener: EventCallback): () => void;
-        (type: "error", listener: ErrorCallback): () => void;
-        (type: "connection", listener: ConnectionCallback): () => void;
-    };
-    unsubscribe: {
-        <T_2 extends Presence>(type: "my-presence", listener: MyPresenceCallback<T_2>): void;
-        <T_3 extends Presence>(type: "others", listener: OthersEventCallback<T_3>): void;
-        (type: "event", listener: EventCallback): void;
-        (type: "error", listener: ErrorCallback): void;
-        (type: "connection", listener: ConnectionCallback): void;
-    };
-    updatePresence: <T_4 extends Presence>(overrides: Partial<T_4>, options?: {
-        addToHistory: boolean;
-    } | undefined) => void;
-    broadcastEvent: (event: any, options?: BroadcastOptions) => void;
-    batch: (callback: () => void) => void;
-    undo: () => void;
-    redo: () => void;
-    pauseHistory: () => void;
-    resumeHistory: () => void;
-    getStorage: <TRoot>() => Promise<{
-        root: LiveObject<TRoot>;
-    }>;
-    selectors: {
-        getConnectionState: () => "failed" | "closed" | "connecting" | "open" | "authenticating" | "unavailable";
-        getSelf: <TPresence extends Presence = Presence>() => User<TPresence> | null;
-        getPresence: <T_5 extends Presence>() => T_5;
-        getOthers: <T_6 extends Presence>() => Others<T_6>;
-    };
-};
-export declare function defaultState(me?: Presence, defaultStorageRoot?: {
-    [key: string]: any;
-}): State;
-export declare type InternalRoom = {
-    room: Room;
-    connect: () => void;
-    disconnect: () => void;
-    onNavigatorOnline: () => void;
-    onVisibilityChange: (visibilityState: VisibilityState) => void;
-};
-export declare function createRoom(name: string, options: ClientOptions & {
-    defaultPresence?: Presence;
-    defaultStorageRoot?: Record<string, any>;
-}): InternalRoom;
-export {};