@liveblocks/client 0.17.11 → 0.18.0-beta0

package/{index-0007883d.d.ts → index-4e7d8cac.d.ts}

@@ -1,107 +1,9 @@
-declare abstract class AbstractCrdt {
-    get roomId(): string | null;
-}
-
-/**
- * The LiveList class represents an ordered collection of items that is synchronized across clients.
- */
-declare class LiveList<TItem extends Lson> extends AbstractCrdt {
-    constructor(items?: TItem[]);
-    /**
-     * Returns the number of elements.
-     */
-    get length(): number;
-    /**
-     * Adds one element to the end of the LiveList.
-     * @param element The element to add to the end of the LiveList.
-     */
-    push(element: TItem): void;
-    /**
-     * Inserts one element at a specified index.
-     * @param element The element to insert.
-     * @param index The index at which you want to insert the element.
-     */
-    insert(element: TItem, index: number): void;
-    /**
-     * Move one element from one index to another.
-     * @param index The index of the element to move
-     * @param targetIndex The index where the element should be after moving.
-     */
-    move(index: number, targetIndex: number): void;
-    /**
-     * Deletes an element at the specified index
-     * @param index The index of the element to delete
-     */
-    delete(index: number): void;
-    clear(): void;
-    set(index: number, item: TItem): void;
-    /**
-     * Returns an Array of all the elements in the LiveList.
-     */
-    toArray(): TItem[];
-    /**
-     * Tests whether all elements pass the test implemented by the provided function.
-     * @param predicate Function to test for each element, taking two arguments (the element and its index).
-     * @returns true if the predicate function returns a truthy value for every element. Otherwise, false.
-     */
-    every(predicate: (value: TItem, index: number) => unknown): boolean;
-    /**
-     * Creates an array with all elements that pass the test implemented by the provided function.
-     * @param predicate Function to test each element of the LiveList. Return a value that coerces to true to keep the element, or to false otherwise.
-     * @returns An array with the elements that pass the test.
-     */
-    filter(predicate: (value: TItem, index: number) => unknown): TItem[];
-    /**
-     * Returns the first element that satisfies the provided testing function.
-     * @param predicate Function to execute on each value.
-     * @returns The value of the first element in the LiveList that satisfies the provided testing function. Otherwise, undefined is returned.
-     */
-    find(predicate: (value: TItem, index: number) => unknown): TItem | undefined;
-    /**
-     * Returns the index of the first element in the LiveList that satisfies the provided testing function.
-     * @param predicate Function to execute on each value until the function returns true, indicating that the satisfying element was found.
-     * @returns The index of the first element in the LiveList that passes the test. Otherwise, -1.
-     */
-    findIndex(predicate: (value: TItem, index: number) => unknown): number;
-    /**
-     * Executes a provided function once for each element.
-     * @param callbackfn Function to execute on each element.
-     */
-    forEach(callbackfn: (value: TItem, index: number) => void): void;
-    /**
-     * Get the element at the specified index.
-     * @param index The index on the element to get.
-     * @returns The element at the specified index or undefined.
-     */
-    get(index: number): TItem | undefined;
-    /**
-     * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
-     * @param searchElement Element to locate.
-     * @param fromIndex The index to start the search at.
-     * @returns The first index of the element in the LiveList; -1 if not found.
-     */
-    indexOf(searchElement: TItem, fromIndex?: number): number;
-    /**
-     * Returns the last index at which a given element can be found in the LiveList, or -1 if it is not present. The LiveLsit is searched backwards, starting at fromIndex.
-     * @param searchElement Element to locate.
-     * @param fromIndex The index at which to start searching backwards.
-     * @returns
-     */
-    lastIndexOf(searchElement: TItem, fromIndex?: number): number;
-    /**
-     * Creates an array populated with the results of calling a provided function on every element.
-     * @param callback Function that is called for every element.
-     * @returns An array with each element being the result of the callback function.
-     */
-    map<U>(callback: (value: TItem, index: number) => U): U[];
-    /**
-     * Tests whether at least one element in the LiveList passes the test implemented by the provided function.
-     * @param predicate Function to test for each element.
-     * @returns true if the callback function returns a truthy value for at least one element. Otherwise, false.
-     */
-    some(predicate: (value: TItem, index: number) => unknown): boolean;
-    [Symbol.iterator](): IterableIterator<TItem>;
-}
+declare type Callback<T> = (event: T) => void;
+declare type UnsubscribeCallback = () => void;
+declare type Observable<T> = {
+    subscribe(callback: Callback<T>): UnsubscribeCallback;
+    subscribeOnce(callback: Callback<T>): UnsubscribeCallback;
+};
 
 /**
  * The LiveMap class is similar to a JavaScript Map that is synchronized on all clients.
@@ -110,10 +12,6 @@ declare class LiveList<TItem extends Lson> extends AbstractCrdt {
  */
 declare class LiveMap<TKey extends string, TValue extends Lson> extends AbstractCrdt {
     constructor(entries?: readonly (readonly [TKey, TValue])[] | undefined);
-    /**
-     * @deprecated Please call as `new LiveMap()` or `new LiveMap([])` instead.
-     */
-    constructor(entries: null);
     /**
      * Returns a specified element from the LiveMap.
      * @param key The key of the element to return.
@@ -162,6 +60,7 @@ declare class LiveMap<TKey extends string, TValue extends Lson> extends Abstract
      * @param callback Function to execute for each entry in the map.
      */
     forEach(callback: (value: TValue, key: TKey, map: LiveMap<TKey, TValue>) => void): void;
+    toImmutable(): ReadonlyMap<TKey, ToImmutable<TValue>>;
 }
 
 /**
@@ -193,9 +92,10 @@ declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
     delete(key: keyof O): void;
     /**
      * Adds or updates multiple properties at once with an object.
-     * @param overrides The object used to overrides properties
+     * @param patch The object used to overrides properties
      */
-    update(overrides: Partial<O>): void;
+    update(patch: Partial<O>): void;
+    toImmutable(): ToImmutable<O>;
 }
 
 /**
@@ -218,18 +118,6 @@ declare function isJsonScalar(data: Json): data is JsonScalar;
 declare function isJsonArray(data: Json): data is JsonArray;
 declare function isJsonObject(data: Json): data is JsonObject;
 
-declare type BaseUserMeta = {
-    /**
-     * The id of the user that has been set in the authentication endpoint.
-     * Useful to get additional information about the connected user.
-     */
-    id?: string;
-    /**
-     * Additional user information that has been set in the authentication endpoint.
-     */
-    info?: Json;
-};
-
 /**
  * INTERNAL
  */
@@ -257,6 +145,182 @@ declare type LiveNode = LiveStructure | LiveRegister<Json>;
 declare type LsonObject = {
     [key: string]: Lson | undefined;
 };
+/**
+ * Helper type to convert any valid Lson type to the equivalent Json type.
+ *
+ * Examples:
+ *
+ *   ToJson<42>                         // 42
+ *   ToJson<'hi'>                       // 'hi'
+ *   ToJson<number>                     // number
+ *   ToJson<string>                     // string
+ *   ToJson<string | LiveList<number>>  // string | number[]
+ *   ToJson<LiveMap<string, LiveList<number>>>
+ *                                      // { [key: string]: number[] }
+ *   ToJson<LiveObject<{ a: number, b: LiveList<string>, c?: number }>>
+ *                                      // { a: null, b: string[], c?: number }
+ *
+ */
+declare type ToJson<T extends Lson | LsonObject> = T extends Json ? T : T extends LsonObject ? {
+    [K in keyof T]: ToJson<Exclude<T[K], undefined>> | (undefined extends T[K] ? undefined : never);
+} : T extends LiveList<infer I> ? ToJson<I>[] : T extends LiveObject<infer O> ? ToJson<O> : T extends LiveMap<infer KS, infer V> ? {
+    [K in KS]: ToJson<V>;
+} : never;
+
+/**
+ * Represents an indefinitely deep arbitrary immutable data
+ * structure, as returned by the .toImmutable().
+ */
+
+declare type Immutable = Scalar | ImmutableList | ImmutableObject | ImmutableMap;
+declare type Scalar = string | number | boolean | null;
+declare type ImmutableList = readonly Immutable[];
+declare type ImmutableObject = {
+    readonly [key: string]: Immutable | undefined;
+};
+declare type ImmutableMap = ReadonlyMap<string, Immutable>;
+declare type ImmutableRef = Exclude<Immutable, Scalar>;
+/**
+ * Helper type to convert any valid Lson type to the equivalent Json type.
+ *
+ * Examples:
+ *
+ *   ToImmutable<42>                         // 42
+ *   ToImmutable<'hi'>                       // 'hi'
+ *   ToImmutable<number>                     // number
+ *   ToImmutable<string>                     // string
+ *   ToImmutable<string | LiveList<number>>  // string | readonly number[]
+ *   ToImmutable<LiveMap<string, LiveList<number>>>
+ *                                           // { readonly [key: string]: readonly number[] }
+ *   ToImmutable<LiveObject<{ a: number, b: LiveList<string>, c?: number }>>
+ *                                           // { readonly a: null, readonly b: readonly string[], readonly c?: number }
+ *
+ */
+declare type ToImmutable<L extends Lson | LsonObject> = L extends LiveList<infer I> ? readonly ToImmutable<I>[] : L extends LiveObject<infer O> ? ToImmutable<O> : L extends LiveMap<infer K, infer V> ? ReadonlyMap<K, ToImmutable<V>> : L extends LsonObject ? {
+    readonly [K in keyof L]: ToImmutable<Exclude<L[K], undefined>> | (undefined extends L[K] ? undefined : never);
+} : L extends Json ? L : never;
+
+declare abstract class AbstractCrdt {
+    get roomId(): string | null;
+    /**
+     * Return an immutable snapshot of this Live node and its children.
+     */
+    toImmutable(): Immutable;
+}
+
+/**
+ * The LiveList class represents an ordered collection of items that is synchronized across clients.
+ */
+declare class LiveList<TItem extends Lson> extends AbstractCrdt {
+    constructor(items?: TItem[]);
+    /**
+     * Returns the number of elements.
+     */
+    get length(): number;
+    /**
+     * Adds one element to the end of the LiveList.
+     * @param element The element to add to the end of the LiveList.
+     */
+    push(element: TItem): void;
+    /**
+     * Inserts one element at a specified index.
+     * @param element The element to insert.
+     * @param index The index at which you want to insert the element.
+     */
+    insert(element: TItem, index: number): void;
+    /**
+     * Move one element from one index to another.
+     * @param index The index of the element to move
+     * @param targetIndex The index where the element should be after moving.
+     */
+    move(index: number, targetIndex: number): void;
+    /**
+     * Deletes an element at the specified index
+     * @param index The index of the element to delete
+     */
+    delete(index: number): void;
+    clear(): void;
+    set(index: number, item: TItem): void;
+    /**
+     * Returns an Array of all the elements in the LiveList.
+     */
+    toArray(): TItem[];
+    /**
+     * Tests whether all elements pass the test implemented by the provided function.
+     * @param predicate Function to test for each element, taking two arguments (the element and its index).
+     * @returns true if the predicate function returns a truthy value for every element. Otherwise, false.
+     */
+    every(predicate: (value: TItem, index: number) => unknown): boolean;
+    /**
+     * Creates an array with all elements that pass the test implemented by the provided function.
+     * @param predicate Function to test each element of the LiveList. Return a value that coerces to true to keep the element, or to false otherwise.
+     * @returns An array with the elements that pass the test.
+     */
+    filter(predicate: (value: TItem, index: number) => unknown): TItem[];
+    /**
+     * Returns the first element that satisfies the provided testing function.
+     * @param predicate Function to execute on each value.
+     * @returns The value of the first element in the LiveList that satisfies the provided testing function. Otherwise, undefined is returned.
+     */
+    find(predicate: (value: TItem, index: number) => unknown): TItem | undefined;
+    /**
+     * Returns the index of the first element in the LiveList that satisfies the provided testing function.
+     * @param predicate Function to execute on each value until the function returns true, indicating that the satisfying element was found.
+     * @returns The index of the first element in the LiveList that passes the test. Otherwise, -1.
+     */
+    findIndex(predicate: (value: TItem, index: number) => unknown): number;
+    /**
+     * Executes a provided function once for each element.
+     * @param callbackfn Function to execute on each element.
+     */
+    forEach(callbackfn: (value: TItem, index: number) => void): void;
+    /**
+     * Get the element at the specified index.
+     * @param index The index on the element to get.
+     * @returns The element at the specified index or undefined.
+     */
+    get(index: number): TItem | undefined;
+    /**
+     * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index to start the search at.
+     * @returns The first index of the element in the LiveList; -1 if not found.
+     */
+    indexOf(searchElement: TItem, fromIndex?: number): number;
+    /**
+     * Returns the last index at which a given element can be found in the LiveList, or -1 if it is not present. The LiveLsit is searched backwards, starting at fromIndex.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index at which to start searching backwards.
+     * @returns
+     */
+    lastIndexOf(searchElement: TItem, fromIndex?: number): number;
+    /**
+     * Creates an array populated with the results of calling a provided function on every element.
+     * @param callback Function that is called for every element.
+     * @returns An array with each element being the result of the callback function.
+     */
+    map<U>(callback: (value: TItem, index: number) => U): U[];
+    /**
+     * Tests whether at least one element in the LiveList passes the test implemented by the provided function.
+     * @param predicate Function to test for each element.
+     * @returns true if the callback function returns a truthy value for at least one element. Otherwise, false.
+     */
+    some(predicate: (value: TItem, index: number) => unknown): boolean;
+    [Symbol.iterator](): IterableIterator<TItem>;
+    toImmutable(): ImmutableList;
+}
+
+declare type BaseUserMeta = {
+    /**
+     * The id of the user that has been set in the authentication endpoint.
+     * Useful to get additional information about the connected user.
+     */
+    id?: string;
+    /**
+     * Additional user information that has been set in the authentication endpoint.
+     */
+    info?: Json;
+};
 
 /**
  * This helper type is effectively a no-op, but will force TypeScript to
@@ -283,15 +347,10 @@ declare type LsonObject = {
 declare type Resolve<T> = T extends (...args: unknown[]) => unknown ? T : {
     [K in keyof T]: T[K];
 };
-declare type MyPresenceCallback<TPresence extends JsonObject> = (me: TPresence) => void;
-declare type OthersEventCallback<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = (others: Others<TPresence, TUserMeta>, event: OthersEvent<TPresence, TUserMeta>) => void;
-declare type EventCallback<TRoomEvent extends Json> = ({ connectionId, event, }: {
+declare type CustomEvent<TRoomEvent extends Json> = {
     connectionId: number;
     event: TRoomEvent;
-}) => void;
-declare type ErrorCallback = (error: Error) => void;
-declare type ConnectionCallback = (state: ConnectionState) => void;
-declare type HistoryCallback = (event: HistoryEvent) => void;
+};
 declare type UpdateDelta = {
     type: "update";
 } | {
@@ -368,21 +427,11 @@ declare type RoomInitializers<TPresence extends JsonObject, TStorage extends Lso
      * The initial Presence to use and announce when you enter the Room. The
      * Presence is available on all users in the Room (me & others).
      */
-    initialPresence?: TPresence | ((roomId: string) => TPresence);
+    initialPresence: TPresence | ((roomId: string) => TPresence);
     /**
      * The initial Storage to use when entering a new Room.
      */
     initialStorage?: TStorage | ((roomId: string) => TStorage);
-    /**
-     * @deprecated Please use `initialPresence` instead. This property is
-     * scheduled for removal in 0.18.
-     */
-    defaultPresence?: () => TPresence;
-    /**
-     * @deprecated Please use `initialStorage` instead. This property is
-     * scheduled for removal in 0.18.
-     */
-    defaultStorageRoot?: TStorage;
 }>;
 declare type Client = {
     /**
@@ -396,34 +445,27 @@ declare type Client = {
      * @param roomId The id of the room
      * @param options Optional. You can provide initializers for the Presence or Storage when entering the Room.
      */
-    enter<TPresence extends JsonObject, TStorage extends LsonObject = LsonObject, TUserMeta extends BaseUserMeta = BaseUserMeta, TRoomEvent extends Json = never>(roomId: string, options?: RoomInitializers<TPresence, TStorage>): Room<TPresence, TStorage, TUserMeta, TRoomEvent>;
+    enter<TPresence extends JsonObject, TStorage extends LsonObject = LsonObject, TUserMeta extends BaseUserMeta = BaseUserMeta, TRoomEvent extends Json = never>(roomId: string, options: RoomInitializers<TPresence, TStorage>): Room<TPresence, TStorage, TUserMeta, TRoomEvent>;
     /**
      * Leaves a room.
      * @param roomId The id of the room
      */
     leave(roomId: string): void;
 };
-/**
- * Represents all the other users connected in the room. Treated as immutable.
- */
-interface Others<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> {
+declare type ReadonlyArrayWithLegacyMethods<T> = readonly T[] & {
     /**
-     * Number of other users in the room.
+     * @deprecated Prefer the normal .length property on arrays.
      */
     readonly count: number;
     /**
-     * Returns a new Iterator object that contains the users.
+     * @deprecated Calling .toArray() is no longer needed
      */
-    [Symbol.iterator](): IterableIterator<User<TPresence, TUserMeta>>;
-    /**
-     * Returns the array of connected users in room.
-     */
-    toArray(): User<TPresence, TUserMeta>[];
-    /**
-     * This function let you map over the connected users in the room.
-     */
-    map<U>(callback: (user: User<TPresence, TUserMeta>) => U): U[];
-}
+    readonly toArray: () => readonly T[];
+};
+/**
+ * Represents all the other users connected in the room. Treated as immutable.
+ */
+declare type Others<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = ReadonlyArrayWithLegacyMethods<User<TPresence, TUserMeta>>;
 /**
  * Represents a user connected in a room. Treated as immutable.
  */
@@ -444,24 +486,8 @@ declare type User<TPresence extends JsonObject, TUserMeta extends BaseUserMeta>
     /**
      * The user presence.
      */
-    readonly presence?: TPresence;
+    readonly presence: TPresence;
 };
-/**
- * @deprecated Whatever you want to store as presence is app-specific. Please
- * define your own Presence type instead of importing it from
- * `@liveblocks/client`, for example:
- *
- *    type Presence = {
- *      name: string,
- *      cursor: {
- *        x: number,
- *        y: number,
- *      } | null,
- *    }
- *
- * As long as it only contains JSON-serializable values, you're good!
- */
-declare type Presence = JsonObject;
 declare type AuthEndpointCallback = (room: string) => Promise<{
     token: string;
 }>;
@@ -494,12 +520,23 @@ declare type ClientOptions = {
     authEndpoint: AuthEndpoint;
 });
 declare type Connection = {
-    state: "closed" | "authenticating" | "unavailable" | "failed";
+    state: "closed";
+} | {
+    state: "authenticating";
+} | {
+    state: "connecting";
+    id: number;
+    userId?: string;
+    userInfo?: Json;
 } | {
-    state: "open" | "connecting";
+    state: "open";
     id: number;
     userId?: string;
     userInfo?: Json;
+} | {
+    state: "unavailable";
+} | {
+    state: "failed";
 };
 declare type ConnectionState = Connection["state"];
 declare type OthersEvent<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = {
@@ -597,6 +634,11 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      * The id of the room.
      */
     readonly id: string;
+    /**
+     * A client is considered "self aware" if it knows its own
+     * metadata and connection ID (from the auth server).
+     */
+    isSelfAware(): boolean;
     getConnectionState(): ConnectionState;
     subscribe: {
         /**
@@ -611,7 +653,7 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
          *   // Do something
          * });
          */
-        (type: "my-presence", listener: MyPresenceCallback<TPresence>): () => void;
+        (type: "my-presence", listener: Callback<TPresence>): () => void;
         /**
          * Subscribe to the other users updates.
          *
@@ -623,8 +665,9 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
          * room.subscribe("others", (others) => {
          *   // Do something
          * });
+         *
          */
-        (type: "others", listener: OthersEventCallback<TPresence, TUserMeta>): () => void;
+        (type: "others", listener: (others: Others<TPresence, TUserMeta>, event: OthersEvent<TPresence, TUserMeta>) => void): () => void;
         /**
          * Subscribe to events broadcasted by {@link Room.broadcastEvent}
          *
@@ -636,20 +679,23 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
          * room.subscribe("event", ({ event, connectionId }) => {
          *   // Do something
          * });
+         *
          */
-        (type: "event", listener: EventCallback<TRoomEvent>): () => void;
+        (type: "event", listener: Callback<CustomEvent<TRoomEvent>>): () => void;
         /**
          * Subscribe to errors thrown in the room.
          *
          * @returns Unsubscribe function.
+         *
          */
         (type: "error", listener: ErrorCallback): () => void;
         /**
          * Subscribe to connection state updates.
          *
          * @returns Unsubscribe function.
+         *
          */
-        (type: "connection", listener: ConnectionCallback): () => void;
+        (type: "connection", listener: Callback<ConnectionState>): () => void;
         /**
          * Subscribes to changes made on a Live structure. Returns an unsubscribe function.
          * In a future version, we will also expose what exactly changed in the Live structure.
@@ -691,8 +737,9 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
          * room.subscribe("history", ({ canUndo, canRedo }) => {
          *   // Do something
          * });
+         *
          */
-        (type: "history", listener: HistoryCallback): () => void;
+        (type: "history", listener: Callback<HistoryEvent>): () => void;
     };
     /**
      * Room's history contains functions that let you undo and redo operation made on by the current client on the presence and storage.
@@ -722,8 +769,8 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
     getOthers: () => Others<TPresence, TUserMeta>;
     /**
      * Updates the presence of the current user. Only pass the properties you want to update. No need to send the full presence.
-     * @param overrides A partial object that contains the properties you want to update.
-     * @param overrides Optional object to configure the behavior of updatePresence.
+     * @param patch A partial object that contains the properties you want to update.
+     * @param options Optional object to configure the behavior of updatePresence.
      *
      * @example
      * room.updatePresence({ x: 0 });
@@ -732,7 +779,7 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      * const presence = room.getPresence();
      * // presence is equivalent to { x: 0, y: 0 }
      */
-    updatePresence: (overrides: Partial<TPresence>, options?: {
+    updatePresence: (patch: Partial<TPresence>, options?: {
         /**
          * Whether or not the presence should have an impact on the undo/redo history.
          */
@@ -764,6 +811,34 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
     getStorage: () => Promise<{
         root: LiveObject<TStorage>;
     }>;
+    /**
+     * Get the room's storage synchronously.
+     * The storage's root is a {@link LiveObject}.
+     *
+     * @example
+     * const root = room.getStorageSnapshot();
+     */
+    getStorageSnapshot(): LiveObject<TStorage> | null;
+    events: {
+        customEvent: Observable<{
+            connectionId: number;
+            event: TRoomEvent;
+        }>;
+        me: Observable<TPresence>;
+        others: Observable<{
+            others: Others<TPresence, TUserMeta>;
+            event: OthersEvent<TPresence, TUserMeta>;
+        }>;
+        error: Observable<Error>;
+        connection: Observable<ConnectionState>;
+        storage: Observable<StorageUpdate[]>;
+        history: Observable<HistoryEvent>;
+        /**
+         * Subscribe to the storage loaded event. Will fire at most once during the
+         * lifetime of a Room.
+         */
+        storageDidLoad: Observable<void>;
+    };
     /**
      * Batches modifications made during the given function.
      * All the modifications are sent to other clients in a single message.
@@ -790,4 +865,4 @@ declare enum WebsocketCloseCodes {
     CLOSE_WITHOUT_RETRY = 4999
 }
 
-export { BaseUserMeta as B, ClientOptions as C, History as H, Json as J, LiveList as L, Others as O, Presence as P, Room as R, StorageUpdate as S, User as U, WebsocketCloseCodes as W, Client as a, LiveMap as b, LiveObject as c, BroadcastOptions as d, JsonObject as e, LiveStructure as f, Lson as g, LsonObject as h, LiveNode as i, Resolve as j, RoomInitializers as k, isJsonArray as l, isJsonObject as m, isJsonScalar as n };
+export { BaseUserMeta as B, ClientOptions as C, History as H, Immutable as I, Json as J, LiveList as L, Others as O, Room as R, StorageUpdate as S, ToJson as T, User as U, WebsocketCloseCodes as W, Client as a, LiveMap as b, LiveObject as c, BroadcastOptions as d, ImmutableList as e, ImmutableMap as f, ImmutableObject as g, ImmutableRef as h, JsonObject as i, LiveStructure as j, Lson as k, LsonObject as l, LiveNode as m, Resolve as n, RoomInitializers as o, ToImmutable as p, isJsonArray as q, isJsonObject as r, isJsonScalar as s };

package/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ClientOptions, a as Client } from './index-0007883d.js';
-export { B as BaseUserMeta, d as BroadcastOptions, a as Client, H as History, J as Json, e as JsonObject, L as LiveList, b as LiveMap, c as LiveObject, f as LiveStructure, g as Lson, h as LsonObject, O as Others, P as Presence, R as Room, S as StorageUpdate, U as User } from './index-0007883d.js';
+import { C as ClientOptions, a as Client } from './index-4e7d8cac.js';
+export { B as BaseUserMeta, d as BroadcastOptions, a as Client, H as History, I as Immutable, e as ImmutableList, f as ImmutableMap, g as ImmutableObject, h as ImmutableRef, J as Json, i as JsonObject, L as LiveList, b as LiveMap, c as LiveObject, j as LiveStructure, k as Lson, l as LsonObject, O as Others, R as Room, S as StorageUpdate, U as User } from './index-4e7d8cac.js';
 
 /**
  * Create a client that will be responsible to communicate with liveblocks servers.
@@ -28,6 +28,17 @@ export { B as BaseUserMeta, d as BroadcastOptions, a as Client, H as History, J
  */
 declare function createClient(options: ClientOptions): Client;
 
+/**
+ * Shallowly compares two given values.
+ *
+ * - Two simple values are considered equal if they're strictly equal
+ * - Two arrays are considered equal if their members are strictly equal
+ * - Two objects are considered equal if their values are strictly equal
+ *
+ * Testing goes one level deep.
+ */
+declare function shallow(a: unknown, b: unknown): boolean;
+
 /**
  * Helper type to help users adopt to Lson types from interface definitions.
  * You should only use this to wrap interfaces you don't control. For more
@@ -40,4 +51,4 @@ declare type EnsureJson<T> = [
     [K in keyof T]: EnsureJson<T[K]>;
 };
 
-export { EnsureJson, createClient };
+export { EnsureJson, createClient, shallow };