@loro-extended/change 0.8.1 → 0.9.1

package/README.md

@@ -547,6 +547,26 @@ draft.metadata.values();
 const value = draft.metadata.get("key");
 ```
 
+### JSON Serialization and Snapshots
+
+You can easily get a plain JavaScript object snapshot of any part of the document using `JSON.stringify()` or `.toJSON()`. This works for the entire document, nested containers, and even during loading states (placeholders).
+
+```typescript
+// Get full document snapshot
+const snapshot = doc.toJSON();
+
+// Get snapshot of a specific list
+const todos = doc.value.todos.toJSON(); // returns plain array of todos
+
+// Works with nested structures
+const metadata = doc.value.metadata.toJSON(); // returns plain object
+
+// Serialize as JSON
+const serializedMetadata = JSON.stringify(doc.value.metadata); // returns string
+```
+
+**Note:** `JSON.stringify()` is recommended for serialization as it handles all data types correctly. `.toJSON()` is available on all `TypedRef` objects and proxied placeholders for convenience when you need a direct object snapshot.
+
 ## Type Safety
 
 Full TypeScript support with compile-time validation:
@@ -616,6 +636,64 @@ loroDoc.subscribe((event) => {
 });
 ```
 
+## TypedPresence
+
+The `TypedPresence` class provides type-safe access to ephemeral presence data with placeholder defaults:
+
+```typescript
+import { TypedPresence, Shape } from "@loro-extended/change";
+
+// Define a presence schema with placeholders
+const PresenceSchema = Shape.plain.object({
+  cursor: Shape.plain.object({
+    x: Shape.plain.number(),
+    y: Shape.plain.number(),
+  }),
+  name: Shape.plain.string().placeholder("Anonymous"),
+  status: Shape.plain.string().placeholder("online"),
+});
+
+// Create typed presence from a PresenceInterface
+// (Usually obtained from handle.presence in @loro-extended/repo)
+const typedPresence = new TypedPresence(PresenceSchema, presenceInterface);
+
+// Read your presence (with placeholder defaults merged in)
+console.log(typedPresence.self);
+// { cursor: { x: 0, y: 0 }, name: "Anonymous", status: "online" }
+
+// Set presence values
+typedPresence.set({ cursor: { x: 100, y: 200 }, name: "Alice" });
+
+// Read all peers' presence
+console.log(typedPresence.all);
+// { "peer-1": { cursor: { x: 100, y: 200 }, name: "Alice", status: "online" } }
+
+// Subscribe to presence changes
+typedPresence.subscribe(({ self, all }) => {
+  console.log("My presence:", self);
+  console.log("All peers:", all);
+});
+```
+
+### PresenceInterface
+
+`TypedPresence` works with any object implementing `PresenceInterface`:
+
+```typescript
+import type { PresenceInterface, ObjectValue } from "@loro-extended/change";
+
+interface PresenceInterface {
+  set: (values: ObjectValue) => void;
+  get: (key: string) => Value;
+  readonly self: ObjectValue;
+  readonly all: Record<string, ObjectValue>;
+  setRaw: (key: string, value: Value) => void;
+  subscribe: (cb: (values: ObjectValue) => void) => () => void;
+}
+```
+
+This is typically provided by `UntypedDocHandle.presence` in `@loro-extended/repo`.
+
 ## Performance Considerations
 
 - All changes within a `change()` block are batched into a single transaction

package/dist/index.d.ts

@@ -30,7 +30,15 @@ import { LoroList, LoroMovableList, Container, LoroMap, Value, LoroText, LoroCou
  * ```
  */
 type Infer<T> = T extends Shape<infer P, any, any> ? P : never;
-type InferDraftType<T> = T extends Shape<any, infer D, any> ? D : never;
+/**
+ * Infers the mutable type from any Shape.
+ * This is the type used within change() callbacks for mutation.
+ */
+type InferMutableType<T> = T extends Shape<any, infer M, any> ? M : never;
+/**
+ * @deprecated Use InferMutableType<T> instead
+ */
+type InferDraftType<T> = InferMutableType<T>;
 /**
  * Extracts the valid placeholder type from a shape.
  *
@@ -38,36 +46,80 @@ type InferDraftType<T> = T extends Shape<any, infer D, any> ? D : never;
  * empty values ([] or {}) to prevent users from expecting per-entry merging.
  */
 type InferPlaceholderType<T> = T extends Shape<any, any, infer P> ? P : never;
-type Draft<T extends DocShape<Record<string, ContainerShape>>> = InferDraftType<T>;
-type DeepReadonly<T> = {
+/**
+ * Mutable type for use within change() callbacks.
+ * This is the type-safe wrapper around CRDT containers that allows mutation.
+ */
+type Mutable<T extends DocShape<Record<string, ContainerShape>>> = InferMutableType<T>;
+/**
+ * @deprecated Use Mutable<T> instead
+ */
+type Draft<T extends DocShape<Record<string, ContainerShape>>> = Mutable<T>;
+/**
+ * Interface for objects that have a toJSON method.
+ * This is separate from the data type to avoid polluting Object.values().
+ */
+interface HasToJSON<T> {
+    toJSON(): T;
+}
+/**
+ * Deep readonly wrapper for plain objects (no index signature).
+ * Includes toJSON() method.
+ */
+type DeepReadonlyObject<T extends object> = {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
-};
+} & HasToJSON<T>;
+/**
+ * Deep readonly wrapper for Record types (with string index signature).
+ * The toJSON() method is available but NOT part of the index signature,
+ * so Object.values() returns clean types.
+ */
+type DeepReadonlyRecord<T> = {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} & HasToJSON<Record<string, T[keyof T]>>;
+/**
+ * Deep readonly wrapper that makes all properties readonly recursively
+ * and adds a toJSON() method for JSON serialization.
+ *
+ * For arrays: Returns ReadonlyArray with toJSON()
+ * For objects with string index signature (Records): toJSON() is available
+ *   but doesn't pollute Object.values() type inference
+ * For plain objects: Returns readonly properties with toJSON()
+ * For primitives: Returns as-is
+ */
+type DeepReadonly<T> = T extends any[] ? ReadonlyArray<DeepReadonly<T[number]>> & HasToJSON<T> : T extends object ? string extends keyof T ? DeepReadonlyRecord<T> : DeepReadonlyObject<T> : T;
 
-type DraftNodeParams<Shape extends DocShape | ContainerShape> = {
+type TypedRefParams<Shape extends DocShape | ContainerShape> = {
     shape: Shape;
     placeholder?: Infer<Shape>;
     getContainer: () => ShapeToContainer<Shape>;
     readonly?: boolean;
 };
-declare abstract class DraftNode<Shape extends DocShape | ContainerShape> {
-    protected _params: DraftNodeParams<Shape>;
+declare abstract class TypedRef<Shape extends DocShape | ContainerShape> {
+    protected _params: TypedRefParams<Shape>;
     protected _cachedContainer?: ShapeToContainer<Shape>;
-    constructor(_params: DraftNodeParams<Shape>);
+    constructor(_params: TypedRefParams<Shape>);
     abstract absorbPlainValues(): void;
     protected get shape(): Shape;
     protected get placeholder(): Infer<Shape> | undefined;
     protected get readonly(): boolean;
+    /**
+     * Throws an error if this ref is in readonly mode.
+     * Call this at the start of any mutating method.
+     */
+    protected assertMutable(): void;
     protected get container(): ShapeToContainer<Shape>;
 }
 
-declare class CounterDraftNode extends DraftNode<CounterContainerShape> {
+declare class CounterRef extends TypedRef<CounterContainerShape> {
     absorbPlainValues(): void;
     increment(value: number): void;
     decrement(value: number): void;
     get value(): number;
+    toJSON(): number;
 }
 
-declare abstract class ListDraftNodeBase<NestedShape extends ContainerOrValueShape, Item = NestedShape["_plain"], DraftItem = NestedShape["_draft"]> extends DraftNode<any> {
+declare abstract class ListRefBase<NestedShape extends ContainerOrValueShape, Item = NestedShape["_plain"], MutableItem = NestedShape["_mutable"]> extends TypedRef<any> {
     private itemCache;
     protected get container(): LoroList | LoroMovableList;
     protected get shape(): ListContainerShape<NestedShape> | MovableListContainerShape<NestedShape>;
@@ -75,43 +127,47 @@ declare abstract class ListDraftNodeBase<NestedShape extends ContainerOrValueSha
     protected abstract absorbValueAtIndex(index: number, value: any): void;
     protected insertWithConversion(index: number, item: Item): void;
     protected pushWithConversion(item: Item): void;
-    getDraftNodeParams(index: number, shape: ContainerShape): DraftNodeParams<ContainerShape>;
+    getTypedRefParams(index: number, shape: ContainerShape): TypedRefParams<ContainerShape>;
     protected getPredicateItem(index: number): Item;
-    protected getDraftItem(index: number): any;
-    find(predicate: (item: Item, index: number) => boolean): DraftItem | undefined;
+    protected getMutableItem(index: number): any;
+    find(predicate: (item: Item, index: number) => boolean): MutableItem | undefined;
     findIndex(predicate: (item: Item, index: number) => boolean): number;
     map<ReturnType>(callback: (item: Item, index: number) => ReturnType): ReturnType[];
-    filter(predicate: (item: Item, index: number) => boolean): DraftItem[];
+    filter(predicate: (item: Item, index: number) => boolean): MutableItem[];
     forEach(callback: (item: Item, index: number) => void): void;
     some(predicate: (item: Item, index: number) => boolean): boolean;
     every(predicate: (item: Item, index: number) => boolean): boolean;
+    slice(start?: number, end?: number): MutableItem[];
     insert(index: number, item: Item): void;
     delete(index: number, len: number): void;
     push(item: Item): void;
     pushContainer(container: Container): Container;
     insertContainer(index: number, container: Container): Container;
-    get(index: number): DraftItem;
+    get(index: number): MutableItem;
     toArray(): Item[];
+    toJSON(): Item[];
+    [Symbol.iterator](): IterableIterator<MutableItem>;
     get length(): number;
     private updateCacheForDelete;
     private updateCacheForInsert;
 }
 
-declare class ListDraftNode<NestedShape extends ContainerOrValueShape> extends ListDraftNodeBase<NestedShape> {
+declare class ListRef<NestedShape extends ContainerOrValueShape> extends ListRefBase<NestedShape> {
     [index: number]: Infer<NestedShape>;
     protected get container(): LoroList;
     protected absorbValueAtIndex(index: number, value: any): void;
 }
 
-declare class MapDraftNode<NestedShapes extends Record<string, ContainerOrValueShape>> extends DraftNode<any> {
+declare class MapRef<NestedShapes extends Record<string, ContainerOrValueShape>> extends TypedRef<any> {
     private propertyCache;
-    constructor(params: DraftNodeParams<MapContainerShape<NestedShapes>>);
+    constructor(params: TypedRefParams<MapContainerShape<NestedShapes>>);
     protected get shape(): MapContainerShape<NestedShapes>;
     protected get container(): LoroMap;
     absorbPlainValues(): void;
-    getDraftNodeParams<S extends ContainerShape>(key: string, shape: S): DraftNodeParams<ContainerShape>;
-    getOrCreateNode<Shape extends ContainerShape | ValueShape>(key: string, shape: Shape): any;
+    getTypedRefParams<S extends ContainerShape>(key: string, shape: S): TypedRefParams<ContainerShape>;
+    getOrCreateRef<Shape extends ContainerShape | ValueShape>(key: string, shape: Shape): any;
     private createLazyProperties;
+    toJSON(): any;
     get(key: string): any;
     set(key: string, value: Value): void;
     setContainer<C extends Container>(key: string, container: C): C;
@@ -122,7 +178,7 @@ declare class MapDraftNode<NestedShapes extends Record<string, ContainerOrValueS
     get size(): number;
 }
 
-declare class MovableListDraftNode<NestedShape extends ContainerOrValueShape, Item = NestedShape["_plain"]> extends ListDraftNodeBase<NestedShape> {
+declare class MovableListRef<NestedShape extends ContainerOrValueShape, Item = NestedShape["_plain"]> extends ListRefBase<NestedShape> {
     [index: number]: Infer<NestedShape>;
     protected get container(): LoroMovableList;
     protected absorbValueAtIndex(index: number, value: any): void;
@@ -130,15 +186,15 @@ declare class MovableListDraftNode<NestedShape extends ContainerOrValueShape, It
     set(index: number, item: Exclude<Item, Container>): void;
 }
 
-declare class RecordDraftNode<NestedShape extends ContainerOrValueShape> extends DraftNode<any> {
+declare class RecordRef<NestedShape extends ContainerOrValueShape> extends TypedRef<any> {
     [key: string]: Infer<NestedShape> | any;
-    private nodeCache;
+    private refCache;
     protected get shape(): RecordContainerShape<NestedShape>;
     protected get container(): LoroMap;
     absorbPlainValues(): void;
-    getDraftNodeParams<S extends ContainerShape>(key: string, shape: S): DraftNodeParams<ContainerShape>;
-    getOrCreateNode(key: string): any;
-    get(key: string): InferDraftType<NestedShape>;
+    getTypedRefParams<S extends ContainerShape>(key: string, shape: S): TypedRefParams<ContainerShape>;
+    getOrCreateRef(key: string): any;
+    get(key: string): InferMutableType<NestedShape>;
     set(key: string, value: any): void;
     setContainer<C extends Container>(key: string, container: C): C;
     delete(key: string): void;
@@ -146,13 +202,15 @@ declare class RecordDraftNode<NestedShape extends ContainerOrValueShape> extends
     keys(): string[];
     values(): any[];
     get size(): number;
+    toJSON(): Record<string, any>;
 }
 
-declare class TextDraftNode extends DraftNode<TextContainerShape> {
+declare class TextRef extends TypedRef<TextContainerShape> {
     absorbPlainValues(): void;
     insert(index: number, content: string): void;
     delete(index: number, len: number): void;
     toString(): string;
+    toJSON(): string;
     update(text: string): void;
     mark(range: {
         start: number;
@@ -173,42 +231,42 @@ type WithPlaceholder<S extends Shape<any, any, any>> = S & {
 interface DocShape<NestedShapes extends Record<string, ContainerShape> = Record<string, ContainerShape>> extends Shape<{
     [K in keyof NestedShapes]: NestedShapes[K]["_plain"];
 }, {
-    [K in keyof NestedShapes]: NestedShapes[K]["_draft"];
+    [K in keyof NestedShapes]: NestedShapes[K]["_mutable"];
 }, {
     [K in keyof NestedShapes]: NestedShapes[K]["_placeholder"];
 }> {
     readonly _type: "doc";
     readonly shapes: NestedShapes;
 }
-interface TextContainerShape extends Shape<string, TextDraftNode, string> {
+interface TextContainerShape extends Shape<string, TextRef, string> {
     readonly _type: "text";
 }
-interface CounterContainerShape extends Shape<number, CounterDraftNode, number> {
+interface CounterContainerShape extends Shape<number, CounterRef, number> {
     readonly _type: "counter";
 }
 interface TreeContainerShape<NestedShape = ContainerOrValueShape> extends Shape<any, any, never[]> {
     readonly _type: "tree";
     readonly shape: NestedShape;
 }
-interface ListContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<NestedShape["_plain"][], ListDraftNode<NestedShape>, never[]> {
+interface ListContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<NestedShape["_plain"][], ListRef<NestedShape>, never[]> {
     readonly _type: "list";
     readonly shape: NestedShape;
 }
-interface MovableListContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<NestedShape["_plain"][], MovableListDraftNode<NestedShape>, never[]> {
+interface MovableListContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<NestedShape["_plain"][], MovableListRef<NestedShape>, never[]> {
     readonly _type: "movableList";
     readonly shape: NestedShape;
 }
 interface MapContainerShape<NestedShapes extends Record<string, ContainerOrValueShape> = Record<string, ContainerOrValueShape>> extends Shape<{
     [K in keyof NestedShapes]: NestedShapes[K]["_plain"];
-}, MapDraftNode<NestedShapes> & {
-    [K in keyof NestedShapes]: NestedShapes[K]["_draft"];
+}, MapRef<NestedShapes> & {
+    [K in keyof NestedShapes]: NestedShapes[K]["_mutable"];
 }, {
     [K in keyof NestedShapes]: NestedShapes[K]["_placeholder"];
 }> {
     readonly _type: "map";
     readonly shapes: NestedShapes;
 }
-interface RecordContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<Record<string, NestedShape["_plain"]>, RecordDraftNode<NestedShape>, Record<string, never>> {
+interface RecordContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<Record<string, NestedShape["_plain"]>, RecordRef<NestedShape>, Record<string, never>> {
     readonly _type: "record";
     readonly shape: NestedShape;
 }
@@ -242,7 +300,7 @@ interface Uint8ArrayValueShape extends Shape<Uint8Array, Uint8Array, Uint8Array>
 interface ObjectValueShape<T extends Record<string, ValueShape> = Record<string, ValueShape>> extends Shape<{
     [K in keyof T]: T[K]["_plain"];
 }, {
-    [K in keyof T]: T[K]["_draft"];
+    [K in keyof T]: T[K]["_mutable"];
 }, {
     [K in keyof T]: T[K]["_placeholder"];
 }> {
@@ -250,17 +308,17 @@ interface ObjectValueShape<T extends Record<string, ValueShape> = Record<string,
     readonly valueType: "object";
     readonly shape: T;
 }
-interface RecordValueShape<T extends ValueShape = ValueShape> extends Shape<Record<string, T["_plain"]>, Record<string, T["_draft"]>, Record<string, never>> {
+interface RecordValueShape<T extends ValueShape = ValueShape> extends Shape<Record<string, T["_plain"]>, Record<string, T["_mutable"]>, Record<string, never>> {
     readonly _type: "value";
     readonly valueType: "record";
     readonly shape: T;
 }
-interface ArrayValueShape<T extends ValueShape = ValueShape> extends Shape<T["_plain"][], T["_draft"][], never[]> {
+interface ArrayValueShape<T extends ValueShape = ValueShape> extends Shape<T["_plain"][], T["_mutable"][], never[]> {
     readonly _type: "value";
     readonly valueType: "array";
     readonly shape: T;
 }
-interface UnionValueShape<T extends ValueShape[] = ValueShape[]> extends Shape<T[number]["_plain"], T[number]["_draft"], T[number]["_placeholder"]> {
+interface UnionValueShape<T extends ValueShape[] = ValueShape[]> extends Shape<T[number]["_plain"], T[number]["_mutable"], T[number]["_placeholder"]> {
     readonly _type: "value";
     readonly valueType: "union";
     readonly shapes: T;
@@ -278,7 +336,7 @@ interface UnionValueShape<T extends ValueShape[] = ValueShape[]> extends Shape<T
  * @typeParam K - The discriminant key (e.g., "type")
  * @typeParam T - A record mapping discriminant values to their object shapes
  */
-interface DiscriminatedUnionValueShape<K extends string = string, T extends Record<string, ObjectValueShape> = Record<string, ObjectValueShape>> extends Shape<T[keyof T]["_plain"], T[keyof T]["_draft"], T[keyof T]["_placeholder"]> {
+interface DiscriminatedUnionValueShape<K extends string = string, T extends Record<string, ObjectValueShape> = Record<string, ObjectValueShape>, Plain = T[keyof T]["_plain"], Mutable = T[keyof T]["_mutable"], Placeholder = T[keyof T]["_placeholder"]> extends Shape<Plain, Mutable, Placeholder> {
     readonly _type: "value";
     readonly valueType: "discriminatedUnion";
     readonly discriminantKey: K;
@@ -286,10 +344,10 @@ interface DiscriminatedUnionValueShape<K extends string = string, T extends Reco
 }
 type ValueShape = StringValueShape | NumberValueShape | BooleanValueShape | NullValueShape | UndefinedValueShape | Uint8ArrayValueShape | ObjectValueShape | RecordValueShape | ArrayValueShape | UnionValueShape | DiscriminatedUnionValueShape;
 type ContainerOrValueShape = ContainerShape | ValueShape;
-interface Shape<Plain, Draft, Placeholder = Plain> {
+interface Shape<Plain, Mutable, Placeholder = Plain> {
     readonly _type: string;
     readonly _plain: Plain;
-    readonly _draft: Draft;
+    readonly _mutable: Mutable;
     readonly _placeholder: Placeholder;
 }
 /**
@@ -380,6 +438,59 @@ declare function overlayPlaceholder<Shape extends DocShape>(shape: Shape, crdtVa
  */
 declare function mergeValue<Shape extends ContainerShape | ValueShape>(shape: Shape, crdtValue: Value, placeholderValue: Value): Value;
 
+/**
+ * Creates a proxy around a placeholder value (plain object/array) that mimics
+ * the behavior of TypedRef, specifically adding a .toJSON() method.
+ *
+ * This ensures consistent UX where users can call .toJSON() on document state
+ * regardless of whether it's loading (placeholder) or loaded (live ref).
+ */
+declare function createPlaceholderProxy<T extends object>(target: T): T;
+
+/**
+ * A record of string keys to Loro values, used for presence data.
+ */
+type ObjectValue = Record<string, Value>;
+/**
+ * Interface for presence management that can be implemented by different backends.
+ * This abstraction allows TypedPresence to work with any presence provider.
+ */
+interface PresenceInterface {
+    /**
+     * Set multiple presence values at once.
+     */
+    set: (values: ObjectValue) => void;
+    /**
+     * Get a single presence value by key.
+     */
+    get: (key: string) => Value;
+    /**
+     * The current peer's presence state.
+     */
+    readonly self: ObjectValue;
+    /**
+     * Other peers' presence states, keyed by peer ID.
+     * Does NOT include self. Use this for iterating over remote peers.
+     */
+    readonly peers: Map<string, ObjectValue>;
+    /**
+     * All peers' presence states, keyed by peer ID (includes self).
+     * @deprecated Use `peers` and `self` separately. This property is synthesized
+     * from `peers` and `self` for backward compatibility.
+     */
+    readonly all: Record<string, ObjectValue>;
+    /**
+     * Set a single raw value by key (escape hatch for arbitrary keys).
+     */
+    setRaw: (key: string, value: Value) => void;
+    /**
+     * Subscribe to presence changes.
+     * @param cb Callback that receives the aggregated presence values
+     * @returns Unsubscribe function
+     */
+    subscribe: (cb: (values: ObjectValue) => void) => () => void;
+}
+
 /** biome-ignore-all lint/suspicious/noExplicitAny: JSON Patch values can be any type */
 
 type JsonPatchAddOperation = {
@@ -462,10 +573,55 @@ declare class TypedDoc<Shape extends DocShape> {
 }
 declare function createTypedDoc<Shape extends DocShape>(shape: Shape, existingDoc?: LoroDoc): TypedDoc<Shape>;
 
+/**
+ * A strongly-typed wrapper around a PresenceInterface.
+ * Provides type-safe access to presence data with automatic placeholder merging.
+ *
+ * @typeParam S - The shape of the presence data
+ */
+declare class TypedPresence<S extends ContainerShape | ValueShape> {
+    shape: S;
+    private presence;
+    private placeholder;
+    constructor(shape: S, presence: PresenceInterface);
+    /**
+     * Get the current peer's presence state with placeholder values merged in.
+     */
+    get self(): Infer<S>;
+    /**
+     * Get other peers' presence states with placeholder values merged in.
+     * Does NOT include self. Use this for iterating over remote peers.
+     */
+    get peers(): Map<string, Infer<S>>;
+    /**
+     * Get all peers' presence states with placeholder values merged in.
+     * @deprecated Use `peers` and `self` separately. This property is synthesized
+     * from `peers` and `self` for backward compatibility.
+     */
+    get all(): Record<string, Infer<S>>;
+    /**
+     * Set presence values for the current peer.
+     */
+    set(value: Partial<Infer<S>>): void;
+    /**
+     * Subscribe to presence changes.
+     * The callback is called immediately with the current state, then on each change.
+     *
+     * @param cb Callback that receives the typed presence state
+     * @returns Unsubscribe function
+     */
+    subscribe(cb: (state: {
+        self: Infer<S>;
+        peers: Map<string, Infer<S>>;
+        /** @deprecated Use `peers` and `self` separately */
+        all: Record<string, Infer<S>>;
+    }) => void): () => void;
+}
+
 /**
  * Validates placeholder against schema structure without using Zod
  * Combines the functionality of createPlaceholderValidator and createValueValidator
  */
 declare function validatePlaceholder<T extends DocShape>(placeholder: unknown, schema: T): Infer<T>;
 
-export { type ArrayValueShape, type ContainerOrValueShape, type ContainerShape, type CounterContainerShape, type DeepReadonly, type DiscriminatedUnionValueShape, type DocShape, type Draft, type Infer, type InferDraftType, type InferPlaceholderType, type ListContainerShape, type MapContainerShape, type MovableListContainerShape, type ObjectValueShape, type RecordContainerShape, type RecordValueShape, type ContainerType as RootContainerType, Shape, type TextContainerShape, type TreeContainerShape, TypedDoc, type UnionValueShape, type ValueShape, type WithPlaceholder, createTypedDoc, derivePlaceholder, deriveShapePlaceholder, mergeValue, overlayPlaceholder, validatePlaceholder };
+export { type ArrayValueShape, type ContainerOrValueShape, type ContainerShape, type CounterContainerShape, type DeepReadonly, type DiscriminatedUnionValueShape, type DocShape, type Draft, type Infer, type InferDraftType, type InferMutableType, type InferPlaceholderType, type ListContainerShape, type MapContainerShape, type MovableListContainerShape, type Mutable, type ObjectValue, type ObjectValueShape, type PresenceInterface, type RecordContainerShape, type RecordValueShape, type ContainerType as RootContainerType, Shape, type TextContainerShape, type TreeContainerShape, TypedDoc, TypedPresence, type UnionValueShape, type ValueShape, type WithPlaceholder, createPlaceholderProxy, createTypedDoc, derivePlaceholder, deriveShapePlaceholder, mergeValue, overlayPlaceholder, validatePlaceholder };