@liveblocks/client 0.12.1 → 0.13.0

package/lib/cjs/LiveMap.js

@@ -0,0 +1,272 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LiveMap_map;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveMap = void 0;
+const AbstractCrdt_1 = require("./AbstractCrdt");
+const utils_1 = require("./utils");
+const live_1 = require("./live");
+/**
+ * The LiveMap class is similar to a JavaScript Map that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+class LiveMap extends AbstractCrdt_1.AbstractCrdt {
+    constructor(entries) {
+        super();
+        _LiveMap_map.set(this, void 0);
+        if (entries) {
+            const mappedEntries = [];
+            for (const entry of entries) {
+                const value = (0, utils_1.selfOrRegister)(entry[1]);
+                value._setParentLink(this, entry[0]);
+                mappedEntries.push([entry[0], value]);
+            }
+            __classPrivateFieldSet(this, _LiveMap_map, new Map(mappedEntries), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _LiveMap_map, new Map(), "f");
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        if (parentId == null || parentKey == null) {
+            throw new Error("Cannot serialize map if parentId or parentKey is undefined");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            type: live_1.OpType.CreateMap,
+            parentId,
+            parentKey,
+        };
+        ops.push(op);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveMap_map, "f")) {
+            ops.push(...value._serialize(this._id, key));
+        }
+        return ops;
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== live_1.CrdtType.Map) {
+            throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
+        }
+        const map = new LiveMap();
+        map._attach(id, doc);
+        const children = parentToChildren.get(id);
+        if (children == null) {
+            return map;
+        }
+        for (const entry of children) {
+            const crdt = entry[1];
+            if (crdt.parentKey == null) {
+                throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+            }
+            const child = (0, utils_1.deserialize)(entry, parentToChildren, doc);
+            child._setParentLink(map, crdt.parentKey);
+            __classPrivateFieldGet(map, _LiveMap_map, "f").set(crdt.parentKey, child);
+        }
+        return map;
+    }
+    /**
+     * INTERNAL
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveMap_map, "f")) {
+            if ((0, utils_1.isCrdt)(value)) {
+                value._attach(doc.generateId(), doc);
+            }
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _attachChild(id, key, child) {
+        if (this._doc == null) {
+            throw new Error("Can't attach child if doc is not present");
+        }
+        const previousValue = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
+        let reverse;
+        if (previousValue) {
+            reverse = previousValue._serialize(this._id, key);
+            previousValue._detach();
+        }
+        else {
+            reverse = [{ type: live_1.OpType.DeleteCrdt, id }];
+        }
+        child._setParentLink(this, key);
+        child._attach(id, this._doc);
+        __classPrivateFieldGet(this, _LiveMap_map, "f").set(key, child);
+        return { modified: this, reverse };
+    }
+    /**
+     * INTERNAL
+     */
+    _detach() {
+        super._detach();
+        for (const item of __classPrivateFieldGet(this, _LiveMap_map, "f").values()) {
+            item._detach();
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _detachChild(child) {
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveMap_map, "f")) {
+            if (value === child) {
+                __classPrivateFieldGet(this, _LiveMap_map, "f").delete(key);
+            }
+        }
+        child._detach();
+    }
+    /**
+     * Returns a specified element from the LiveMap.
+     * @param key The key of the element to return.
+     * @returns The element associated with the specified key, or undefined if the key can't be found in the LiveMap.
+     */
+    get(key) {
+        const value = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
+        if (value == undefined) {
+            return undefined;
+        }
+        return (0, utils_1.selfOrRegisterValue)(value);
+    }
+    /**
+     * Adds or updates an element with a specified key and a value.
+     * @param key The key of the element to add. Should be a string.
+     * @param value The value of the element to add. Should be serializable to JSON.
+     */
+    set(key, value) {
+        const oldValue = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
+        if (oldValue) {
+            oldValue._detach();
+        }
+        const item = (0, utils_1.selfOrRegister)(value);
+        item._setParentLink(this, key);
+        __classPrivateFieldGet(this, _LiveMap_map, "f").set(key, item);
+        if (this._doc && this._id) {
+            const id = this._doc.generateId();
+            item._attach(id, this._doc);
+            this._doc.dispatch(item._serialize(this._id, key), oldValue
+                ? oldValue._serialize(this._id, key)
+                : [{ type: live_1.OpType.DeleteCrdt, id }], [this]);
+        }
+    }
+    /**
+     * Returns the number of elements in the LiveMap.
+     */
+    get size() {
+        return __classPrivateFieldGet(this, _LiveMap_map, "f").size;
+    }
+    /**
+     * Returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key The key of the element to test for presence.
+     */
+    has(key) {
+        return __classPrivateFieldGet(this, _LiveMap_map, "f").has(key);
+    }
+    /**
+     * Removes the specified element by key.
+     * @param key The key of the element to remove.
+     * @returns true if an element existed and has been removed, or false if the element does not exist.
+     */
+    delete(key) {
+        const item = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
+        if (item == null) {
+            return false;
+        }
+        item._detach();
+        if (this._doc && item._id) {
+            this._doc.dispatch([{ type: live_1.OpType.DeleteCrdt, id: item._id }], item._serialize(this._id, key), [this]);
+        }
+        __classPrivateFieldGet(this, _LiveMap_map, "f").delete(key);
+        return true;
+    }
+    /**
+     * Returns a new Iterator object that contains the [key, value] pairs for each element.
+     */
+    entries() {
+        const innerIterator = __classPrivateFieldGet(this, _LiveMap_map, "f").entries();
+        return {
+            [Symbol.iterator]: function () {
+                return this;
+            },
+            next() {
+                const iteratorValue = innerIterator.next();
+                if (iteratorValue.done) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                const entry = iteratorValue.value;
+                return {
+                    value: [entry[0], (0, utils_1.selfOrRegisterValue)(iteratorValue.value[1])],
+                };
+            },
+        };
+    }
+    /**
+     * Same function object as the initial value of the entries method.
+     */
+    [(_LiveMap_map = new WeakMap(), Symbol.iterator)]() {
+        return this.entries();
+    }
+    /**
+     * Returns a new Iterator object that contains the keys for each element.
+     */
+    keys() {
+        return __classPrivateFieldGet(this, _LiveMap_map, "f").keys();
+    }
+    /**
+     * Returns a new Iterator object that contains the values for each element.
+     */
+    values() {
+        const innerIterator = __classPrivateFieldGet(this, _LiveMap_map, "f").values();
+        return {
+            [Symbol.iterator]: function () {
+                return this;
+            },
+            next() {
+                const iteratorValue = innerIterator.next();
+                if (iteratorValue.done) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                return {
+                    value: (0, utils_1.selfOrRegisterValue)(iteratorValue.value),
+                };
+            },
+        };
+    }
+    /**
+     * Executes a provided function once per each key/value pair in the Map object, in insertion order.
+     * @param callback Function to execute for each entry in the map.
+     */
+    forEach(callback) {
+        for (const entry of this) {
+            callback(entry[1], entry[0], this);
+        }
+    }
+}
+exports.LiveMap = LiveMap;

package/lib/cjs/LiveObject.d.ts

@@ -0,0 +1,61 @@
+import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
+import { Op, SerializedCrdtWithId } from "./live";
+/**
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+export declare class LiveObject<T extends Record<string, any> = Record<string, any>> extends AbstractCrdt {
+    #private;
+    constructor(object?: T);
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId?: string, parentKey?: string): Op[];
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item]: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveObject<{
+        [key: string]: any;
+    }>;
+    /**
+     * INTERNAL
+     */
+    _attach(id: string, doc: Doc): void;
+    /**
+     * INTERNAL
+     */
+    _attachChild(id: string, key: keyof T, child: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _detachChild(child: AbstractCrdt): void;
+    /**
+     * INTERNAL
+     */
+    _detach(): void;
+    /**
+     * INTERNAL
+     */
+    _apply(op: Op): ApplyResult;
+    /**
+     * Transform the LiveObject into a javascript object
+     */
+    toObject(): T;
+    /**
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
+     */
+    set<TKey extends keyof T>(key: TKey, value: T[TKey]): void;
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
+    get<TKey extends keyof T>(key: TKey): T[TKey];
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param overrides The object used to overrides properties
+     */
+    update(overrides: Partial<T>): void;
+}

package/lib/cjs/LiveObject.js

@@ -0,0 +1,330 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LiveObject_instances, _LiveObject_map, _LiveObject_propToLastUpdate, _LiveObject_applyUpdate, _LiveObject_applyDeleteObjectKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveObject = void 0;
+const AbstractCrdt_1 = require("./AbstractCrdt");
+const utils_1 = require("./utils");
+const live_1 = require("./live");
+/**
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+class LiveObject extends AbstractCrdt_1.AbstractCrdt {
+    constructor(object = {}) {
+        super();
+        _LiveObject_instances.add(this);
+        _LiveObject_map.set(this, void 0);
+        _LiveObject_propToLastUpdate.set(this, new Map());
+        for (const key in object) {
+            const value = object[key];
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                value._setParentLink(this, key);
+            }
+        }
+        __classPrivateFieldSet(this, _LiveObject_map, new Map(Object.entries(object)), "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            type: live_1.OpType.CreateObject,
+            parentId,
+            parentKey,
+            data: {},
+        };
+        ops.push(op);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                ops.push(...value._serialize(this._id, key));
+            }
+            else {
+                op.data[key] = value;
+            }
+        }
+        return ops;
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== live_1.CrdtType.Object) {
+            throw new Error(`Tried to deserialize a record but item type is "${item.type}"`);
+        }
+        const object = new LiveObject(item.data);
+        object._attach(id, doc);
+        const children = parentToChildren.get(id);
+        if (children == null) {
+            return object;
+        }
+        for (const entry of children) {
+            const crdt = entry[1];
+            if (crdt.parentKey == null) {
+                throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+            }
+            const child = (0, utils_1.deserialize)(entry, parentToChildren, doc);
+            child._setParentLink(object, crdt.parentKey);
+            __classPrivateFieldGet(object, _LiveObject_map, "f").set(crdt.parentKey, child);
+        }
+        return object;
+    }
+    /**
+     * INTERNAL
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                value._attach(doc.generateId(), doc);
+            }
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _attachChild(id, key, child) {
+        if (this._doc == null) {
+            throw new Error("Can't attach child if doc is not present");
+        }
+        const previousValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        let reverse;
+        if ((0, utils_1.isCrdt)(previousValue)) {
+            reverse = previousValue._serialize(this._id, key);
+            previousValue._detach();
+        }
+        else if (previousValue === undefined) {
+            reverse = [
+                { type: live_1.OpType.DeleteObjectKey, id: this._id, key: key },
+            ];
+        }
+        else {
+            reverse = [
+                {
+                    type: live_1.OpType.UpdateObject,
+                    id: this._id,
+                    data: { [key]: previousValue },
+                },
+            ];
+        }
+        __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, child);
+        child._setParentLink(this, key);
+        child._attach(id, this._doc);
+        return { reverse, modified: this };
+    }
+    /**
+     * INTERNAL
+     */
+    _detachChild(child) {
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value === child) {
+                __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+            }
+        }
+        if (child) {
+            child._detach();
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _detach() {
+        super._detach();
+        for (const value of __classPrivateFieldGet(this, _LiveObject_map, "f").values()) {
+            if ((0, utils_1.isCrdt)(value)) {
+                value._detach();
+            }
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _apply(op) {
+        if (op.type === live_1.OpType.UpdateObject) {
+            return __classPrivateFieldGet(this, _LiveObject_instances, "m", _LiveObject_applyUpdate).call(this, op);
+        }
+        else if (op.type === live_1.OpType.DeleteObjectKey) {
+            return __classPrivateFieldGet(this, _LiveObject_instances, "m", _LiveObject_applyDeleteObjectKey).call(this, op);
+        }
+        return super._apply(op);
+    }
+    /**
+     * Transform the LiveObject into a javascript object
+     */
+    toObject() {
+        return Object.fromEntries(__classPrivateFieldGet(this, _LiveObject_map, "f"));
+    }
+    /**
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
+     */
+    set(key, value) {
+        // TODO: Find out why typescript complains
+        this.update({ [key]: value });
+    }
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
+    get(key) {
+        return __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+    }
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param overrides The object used to overrides properties
+     */
+    update(overrides) {
+        if (this._doc == null || this._id == null) {
+            for (const key in overrides) {
+                const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+                if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                    oldValue._detach();
+                }
+                const newValue = overrides[key];
+                if (newValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                    newValue._setParentLink(this, key);
+                }
+                __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+            }
+            return;
+        }
+        const ops = [];
+        const reverseOps = [];
+        const opId = this._doc.generateOpId();
+        const updatedProps = {};
+        const reverseUpdateOp = {
+            id: this._id,
+            type: live_1.OpType.UpdateObject,
+            data: {},
+        };
+        for (const key in overrides) {
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, opId);
+            const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+            if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                reverseOps.push(...oldValue._serialize(this._id, key));
+                oldValue._detach();
+            }
+            else if (oldValue === undefined) {
+                reverseOps.push({ type: live_1.OpType.DeleteObjectKey, id: this._id, key });
+            }
+            else {
+                reverseUpdateOp.data[key] = oldValue;
+            }
+            const newValue = overrides[key];
+            if (newValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                newValue._setParentLink(this, key);
+                newValue._attach(this._doc.generateId(), this._doc);
+                ops.push(...newValue._serialize(this._id, key));
+            }
+            else {
+                updatedProps[key] = newValue;
+            }
+            __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+        }
+        if (Object.keys(reverseUpdateOp.data).length !== 0) {
+            reverseOps.unshift(reverseUpdateOp);
+        }
+        if (Object.keys(updatedProps).length !== 0) {
+            ops.unshift({
+                opId,
+                id: this._id,
+                type: live_1.OpType.UpdateObject,
+                data: updatedProps,
+            });
+        }
+        this._doc.dispatch(ops, reverseOps, [this]);
+    }
+}
+exports.LiveObject = LiveObject;
+_LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _LiveObject_instances = new WeakSet(), _LiveObject_applyUpdate = function _LiveObject_applyUpdate(op) {
+    let isModified = false;
+    const reverse = [];
+    const reverseUpdate = {
+        type: live_1.OpType.UpdateObject,
+        id: this._id,
+        data: {},
+    };
+    reverse.push(reverseUpdate);
+    for (const key in op.data) {
+        const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+            reverse.push(...oldValue._serialize(this._id, key));
+            oldValue._detach();
+        }
+        else if (oldValue !== undefined) {
+            reverseUpdate.data[key] = oldValue;
+        }
+        else if (oldValue === undefined) {
+            reverse.push({ type: live_1.OpType.DeleteObjectKey, id: this._id, key });
+        }
+    }
+    let isLocal = false;
+    if (op.opId == null) {
+        isLocal = true;
+        op.opId = this._doc.generateOpId();
+    }
+    for (const key in op.data) {
+        if (isLocal) {
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, op.opId);
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) == null) {
+            // Not modified localy so we apply update
+            isModified = true;
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) === op.opId) {
+            // Acknowlegment from local operation
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").delete(key);
+            continue;
+        }
+        else {
+            // Conflict, ignore remote operation
+            continue;
+        }
+        const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        if ((0, utils_1.isCrdt)(oldValue)) {
+            oldValue._detach();
+        }
+        isModified = true;
+        __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, op.data[key]);
+    }
+    if (Object.keys(reverseUpdate.data).length !== 0) {
+        reverse.unshift(reverseUpdate);
+    }
+    return isModified ? { modified: this, reverse } : { modified: false };
+}, _LiveObject_applyDeleteObjectKey = function _LiveObject_applyDeleteObjectKey(op) {
+    const key = op.key;
+    const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+    let reverse = [];
+    if ((0, utils_1.isCrdt)(oldValue)) {
+        reverse = oldValue._serialize(this._id, op.key);
+        oldValue._detach();
+    }
+    else if (oldValue !== undefined) {
+        reverse = [
+            {
+                type: live_1.OpType.UpdateObject,
+                id: this._id,
+                data: { [key]: oldValue },
+            },
+        ];
+    }
+    __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+    return { modified: this, reverse };
+};

package/lib/cjs/LiveRegister.d.ts

@@ -0,0 +1,21 @@
+import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
+import { SerializedCrdtWithId, Op } from "./live";
+/**
+ * INTERNAL
+ */
+export declare class LiveRegister<TValue = any> extends AbstractCrdt {
+    #private;
+    constructor(data: TValue);
+    get data(): TValue;
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item]: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveRegister<any>;
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId: string, parentKey: string): Op[];
+    _attachChild(id: string, key: string, crdt: AbstractCrdt): ApplyResult;
+    _detachChild(crdt: AbstractCrdt): void;
+    _apply(op: Op): ApplyResult;
+}