reptree 0.9.0 → 1.0.1

package/dist/index.d.cts

@@ -20,52 +20,52 @@ declare function tryParseOpIdStr(opIdStr: string): OpId;
 declare function isOpIdGreaterThan(opIdA: OpId | string, opIdB: OpId | string): boolean;
 declare function opIdToString(opId: OpId): string;
 
-declare class VertexState {
+declare class NodeState {
     readonly id: string;
-    parentId: TreeVertexId | null;
+    parentId: TreeNodeId | null;
     private properties;
     private transientProperties;
     children: string[];
-    constructor(id: string, parentId: TreeVertexId | null);
-    setProperty(key: string, value: VertexPropertyType): void;
-    setTransientProperty(key: string, value: VertexPropertyType): void;
-    getProperty(key: string, includingTransient?: boolean): VertexPropertyType | undefined;
-    getAllProperties(includingTransient?: boolean): ReadonlyArray<TreeVertexProperty>;
+    constructor(id: string, parentId: TreeNodeId | null);
+    setProperty(key: string, value: NodePropertyType): void;
+    setTransientProperty(key: string, value: NodePropertyType): void;
+    getProperty(key: string, includingTransient?: boolean): NodePropertyType | undefined;
+    getAllProperties(includingTransient?: boolean): ReadonlyArray<TreeNodeProperty>;
     removeProperty(key: string): void;
     removeTransientProperty(key: string): void;
-    getTransientProperties(): ReadonlyArray<TreeVertexProperty>;
+    getTransientProperties(): ReadonlyArray<TreeNodeProperty>;
     clearAllTransientProperties(): void;
 }
 
-type TreeVertexId = string;
+type TreeNodeId = string;
 type JsonPrimitive = string | number | boolean | null;
 type JsonValue = JsonPrimitive | JsonValue[] | {
     [key: string]: JsonValue;
 };
 /** Property type for state (undefined means removal) */
-type VertexPropertyType = JsonValue | undefined;
-type TreeVertexProperty = {
+type NodePropertyType = JsonValue | undefined;
+type TreeNodeProperty = {
     readonly key: string;
-    readonly value: VertexPropertyType;
+    readonly value: NodePropertyType;
 };
-type VertexChangeEventType = 'move' | 'property' | 'children';
-interface VertexChangeEvent {
-    type: VertexChangeEventType;
-    vertexId: TreeVertexId;
+type NodeChangeEventType = 'move' | 'property' | 'children';
+interface NodeChangeEvent {
+    type: NodeChangeEventType;
+    nodeId: TreeNodeId;
 }
-type VertexPropertyChangeEvent = VertexChangeEvent & {
+type NodePropertyChangeEvent = NodeChangeEvent & {
     type: 'property';
     key: string;
-    value: VertexPropertyType | undefined;
+    value: NodePropertyType | undefined;
 };
-type VertexMoveEvent = VertexChangeEvent & {
+type NodeMoveEvent = NodeChangeEvent & {
     type: 'move';
-    oldParentId: TreeVertexId | null | undefined;
-    newParentId: TreeVertexId;
+    oldParentId: TreeNodeId | null | undefined;
+    newParentId: TreeNodeId;
 };
-type VertexChildrenChangeEvent = VertexChangeEvent & {
+type NodeChildrenChangeEvent = NodeChangeEvent & {
     type: 'children';
-    children: VertexState[];
+    children: NodeState[];
 };
 /**
  * Type definition for operation ID range used in state vectors
@@ -75,25 +75,29 @@ interface OpIdRange {
     start: number;
     end: number;
 }
+type StateVectors = {
+    move: Record<string, number[][]>;
+    prop: Record<string, number[][]>;
+};
 
-interface MoveVertex {
+interface MoveNode {
     id: OpId;
     targetId: string;
     parentId: string | null;
 }
-interface SetVertexProperty {
+interface SetNodeProperty {
     id: OpId;
     targetId: string;
     key: string;
-    value: VertexPropertyType;
+    value: NodePropertyType;
     transient: boolean;
 }
-type VertexOperation = MoveVertex | SetVertexProperty;
-declare function isMoveVertexOp(op: VertexOperation): op is MoveVertex;
-declare function isAnyPropertyOp(op: VertexOperation): op is SetVertexProperty;
-declare function newMoveVertexOp(clock: number, peerId: string, targetId: string, parentId: string | null): MoveVertex;
-declare function newSetVertexPropertyOp(clock: number, peerId: string, targetId: string, key: string, value: VertexPropertyType): SetVertexProperty;
-declare function newSetTransientVertexPropertyOp(clock: number, peerId: string, targetId: string, key: string, value: VertexPropertyType): SetVertexProperty;
+type NodeOperation = MoveNode | SetNodeProperty;
+declare function isMoveNodeOp(op: NodeOperation): op is MoveNode;
+declare function isAnyPropertyOp(op: NodeOperation): op is SetNodeProperty;
+declare function newMoveNodeOp(clock: number, peerId: string, targetId: string, parentId: string | null): MoveNode;
+declare function newSetNodePropertyOp(clock: number, peerId: string, targetId: string, key: string, value: NodePropertyType): SetNodeProperty;
+declare function newSetTransientNodePropertyOp(clock: number, peerId: string, targetId: string, key: string, value: NodePropertyType): SetNodeProperty;
 
 type FieldSchemaLike = {
     safeParse?: (input: unknown) => {
@@ -118,15 +122,15 @@ type BindOptions<T> = {
     includeInternalKeys?: boolean;
 };
 /**
- * A bound vertex object that forwards reads/writes to a vertex.
- * @param T - The type of the vertex.
+ * A bound node object that forwards reads/writes to a node.
+ * @param T - The type of the node.
  */
-type BindedVertex<T> = T & {
-    $vertex: Vertex;
+type BindedNode<T> = T & {
+    $node: Node;
     $id: string;
     $parentId: string | null;
-    $parent: Vertex | undefined;
-    $children: Vertex[];
+    $parent: Node | undefined;
+    $children: Node[];
     $childrenIds: string[];
     /**
      * Apply transient edits that override reads but do not persist yet.
@@ -138,200 +142,210 @@ type BindedVertex<T> = T & {
      */
     $commitTransients(): void;
     /**
-     * Move the vertex to a new parent.
-     * @param parent - The new parent vertex or ID.
+     * Move the node to a new parent.
+     * @param parent - The new parent node or ID.
      */
-    $moveTo(parent: Vertex | BindedVertex<any> | string): void;
+    $moveTo(parent: Node | BindedNode<any> | string): void;
     /**
-     * Delete the vertex.
+     * Delete the node.
      */
     $delete(): void;
     /**
-     * Observe changes to the vertex.
+     * Observe changes to the node.
      * @param listener - The listener function to call when changes occur.
      */
     $observe(listener: (events: any[]) => void): () => void;
     /**
-     * Observe changes to the children of the vertex.
+     * Observe changes to the children of the node.
      * @param listener - The listener function to call when children change.
      */
-    $observeChildren(listener: (children: Vertex[]) => void): () => void;
+    $observeChildren(listener: (children: Node[]) => void): () => void;
     /**
-     * Create a new child vertex.
-     * @param props - The properties to set on the new child vertex.
+     * Create a new child node.
+     * @param props - The properties to set on the new child node.
      */
-    $newChild(props?: Record<string, any> | object | null): Vertex;
+    $newChild(props?: Record<string, any> | object | null): Node;
     /**
-     * Create a new named child vertex.
-     * @param name - The name of the new child vertex.
-     * @param props - The properties to set on the new child vertex.
+     * Create a new named child node.
+     * @param name - The name of the new child node.
+     * @param props - The properties to set on the new child node.
      */
-    $newNamedChild(name: string, props?: Record<string, any> | object | null): Vertex;
+    $newNamedChild(name: string, props?: Record<string, any> | object | null): Node;
 };
 /**
- * Returns a live Proxy that forwards reads/writes to a vertex.
+ * Returns a live Proxy that forwards reads/writes to a node.
  * - Reads reflect the latest CRDT state (including transients by default)
  * - Writes persist to the CRDT with optional schema validation
  */
-declare function bindVertex<T extends Record<string, unknown>>(tree: RepTree, id: string, schemaOrOptions?: SchemaLike<T> | BindOptions<T>): BindedVertex<T>;
+declare function bindNode<T extends Record<string, unknown>>(tree: RepTree, id: string, schemaOrOptions?: SchemaLike<T> | BindOptions<T>): BindedNode<T>;
 
 /**
- * A wrapper class for VertexState that provides a more convenient API
- * for working with vertices in a RepTree.
+ * A wrapper class for NodeState that provides a more convenient API
+ * for working with nodes in a RepTree.
  */
-declare class Vertex {
+declare class Node {
     private state;
     private _tree;
-    constructor(tree: RepTree, state: VertexState);
-    /** Returns the tree this vertex belongs to. */
+    constructor(tree: RepTree, state: NodeState);
+    /** Returns the tree this node belongs to. */
     get tree(): RepTree;
     private set tree(value);
-    /** Returns the ID of this vertex. */
+    /** Returns the ID of this node. */
     get id(): string;
-    /** Returns the name of this vertex. The name is stored as a property with the key 'name'. */
+    /** Returns the name of this node. The name is stored as a property with the key 'name'. */
     get name(): string | undefined;
-    /** Sets the name of this vertex. The name is stored as a property with the key 'name'. */
+    /** Sets the name of this node. The name is stored as a property with the key 'name'. */
     set name(name: string);
-    /** Returns the creation date of this vertex. The creation date is stored as a property with the key '_c'. */
+    /** Returns the creation date of this node. The creation date is stored as a property with the key '_c'. */
     get createdAt(): Date;
-    /** Returns the ID of the parent vertex of this vertex. */
+    /** Returns the ID of the parent node of this node. */
     get parentId(): string | null;
-    /** Returns the parent vertex of this vertex. */
-    get parent(): Vertex | undefined;
-    /** Returns the children vertices of this vertex. */
-    get children(): Vertex[];
-    /** Returns the IDs of the children vertices of this vertex. */
+    /** Returns the parent node of this node. */
+    get parent(): Node | undefined;
+    /** Returns the children nodes of this node. */
+    get children(): Node[];
+    /** Returns the IDs of the children nodes of this node. */
     get childrenIds(): string[];
-    /** Returns the ancestors of this vertex. The first element is the root vertex.
+    /** Returns the ancestors of this node. The first element is the root node.
      * E.g root -> grandparent -> parent.
-     * Doesn't include this vertex in the array.
+     * Doesn't include this node in the array.
      */
-    get ancestors(): Vertex[];
-    /** Returns the ID of the root vertex of the tree this vertex belongs to. */
+    get ancestors(): Node[];
+    /** Returns the ID of the root node of the tree this node belongs to. */
     get treeId(): string;
-    /** Returns the root vertex of the tree this vertex belongs to. */
-    get root(): Vertex;
+    /** Returns the root node of the tree this node belongs to. */
+    get root(): Node;
     getAsTypedObject<T>(): T;
     getChildrenAsTypedArray<T>(): T[];
-    /** Creates a new child vertex of this vertex. */
-    newChild(props?: Record<string, VertexPropertyType> | object | null): Vertex;
-    /** Creates a new named child vertex of this vertex. */
-    newNamedChild(name: string, props?: Record<string, VertexPropertyType> | object | null): Vertex;
-    /** Sets a property on this vertex. */
-    setProperty(key: string, value: VertexPropertyType): void;
-    /** Sets a transient property on this vertex. Transient properties are not persisted to the tree and are not included in the state vector. */
-    setTransientProperty(key: string, value: VertexPropertyType): void;
+    /** Creates a new child node of this node. */
+    newChild(props?: Record<string, NodePropertyType> | object | null): Node;
+    /** Creates a new named child node of this node. */
+    newNamedChild(name: string, props?: Record<string, NodePropertyType> | object | null): Node;
+    /** Sets a property on this node. */
+    setProperty(key: string, value: NodePropertyType): void;
+    /** Sets a transient property on this node. Transient properties are not persisted to the tree and are not included in the state vector. */
+    setTransientProperty(key: string, value: NodePropertyType): void;
     /** Promotes all transient (temporary) properties to persistent properties. */
     commitTransients(): void;
-    /** Sets multiple properties on this vertex. */
-    setProperties(props: Record<string, VertexPropertyType> | object): void;
-    /** Returns the value of a property on this vertex. */
-    getProperty(key: string, includingTransient?: boolean): VertexPropertyType | undefined;
-    /** Returns all properties on this vertex. */
-    getProperties(): Record<string, VertexPropertyType>;
-    findAllChildrenWithProperty(key: string, value: VertexPropertyType): Vertex[];
-    findFirstChildVertexWithProperty(key: string, value: VertexPropertyType): Vertex | undefined;
-    findFirstTypedChildWithProperty<T>(key: string, value: VertexPropertyType): T | undefined;
-    findAllTypedChildrenWithProperty<T>(key: string, value: VertexPropertyType): T[];
-    /** Observes changes to this vertex. */
-    observe(listener: (events: VertexChangeEvent[]) => void): () => void;
-    /** Observes changes to the children of this vertex. */
-    observeChildren(listener: (children: Vertex[]) => void): () => void;
+    /** Sets multiple properties on this node. */
+    setProperties(props: Record<string, NodePropertyType> | object): void;
+    /** Returns the value of a property on this node. */
+    getProperty(key: string, includingTransient?: boolean): NodePropertyType | undefined;
+    /** Returns all properties on this node. */
+    getProperties(): Record<string, NodePropertyType>;
+    findAllChildrenWithProperty(key: string, value: NodePropertyType): Node[];
+    findFirstChildNodeWithProperty(key: string, value: NodePropertyType): Node | undefined;
+    findFirstTypedChildWithProperty<T>(key: string, value: NodePropertyType): T | undefined;
+    findAllTypedChildrenWithProperty<T>(key: string, value: NodePropertyType): T[];
+    /** Observes changes to this node. */
+    observe(listener: (events: NodeChangeEvent[]) => void): () => void;
+    /** Observes changes to the children of this node. */
+    observeChildren(listener: (children: Node[]) => void): () => void;
     observeChildrenAsTypedArray<T>(listener: (children: T[]) => void): () => void;
     delete(): void;
-    moveTo(parent: Vertex): void;
-    /** Returns a live reactive object bound to this vertex. Accepts schema or options. */
-    bind<T extends Record<string, unknown>>(schemaOrOptions?: SchemaLike<T> | BindOptions<T>): BindedVertex<T>;
+    moveTo(parent: Node): void;
+    /** Returns a live reactive object bound to this node. Accepts schema or options. */
+    bind<T extends Record<string, unknown>>(schemaOrOptions?: SchemaLike<T> | BindOptions<T>): BindedNode<T>;
 }
 
 /**
- * RepTree is a tree data structure for storing vertices with properties.
+ * RepTree is a tree data structure for storing nodes with properties.
  * It uses 2 conflict-free replicated data types (CRDTs) to manage seamless replication between peers.
  * A move tree CRDT is used for the tree structure (https://martin.kleppmann.com/papers/move-op.pdf).
  * A last writer wins (LWW) CRDT is used for properties.
  */
 declare class RepTree {
-    private static NULL_VERTEX_ID;
+    private static NULL_NODE_ID;
     readonly peerId: string;
-    private rootVertexId;
-    private lamportClock;
+    private rootNodeId;
+    private moveClock;
+    private propClock;
     private state;
     private moveOps;
-    private setPropertyOps;
-    private propertiesAndTheirOpIds;
+    private propertyOpsByKey;
     private transientPropertiesAndTheirOpIds;
     private localOps;
     private pendingMovesWithMissingParent;
-    private pendingPropertiesWithMissingVertex;
+    private pendingPropertiesWithMissingNode;
     private knownOps;
     private parentIdBeforeMove;
     private opAppliedCallbacks;
-    private stateVector;
+    private moveStateVector;
+    private propStateVector;
     private _stateVectorEnabled;
     /**
      * @param peerId - The peer ID of the current client. Should be unique across all peers.
-     * @param ops - The operations to replicate an existing tree, if not provided - an empty tree will be created without a root vertex
+     * @param ops - The operations to replicate an existing tree, if not provided - an empty tree will be created without a root node
      */
-    constructor(peerId: string, ops?: ReadonlyArray<VertexOperation>);
-    get root(): Vertex | undefined;
+    constructor(peerId: string, ops?: ReadonlyArray<NodeOperation>);
+    dispose(): void;
+    get root(): Node | undefined;
     replicate(newPeerId: string): RepTree;
-    getMoveOps(): ReadonlyArray<MoveVertex>;
-    getAllOps(): ReadonlyArray<VertexOperation>;
-    getVertex(vertexId: string): Vertex | undefined;
-    getAllVertices(): ReadonlyArray<Vertex>;
-    getParent(vertexId: string): Vertex | undefined;
-    getChildren(vertexId: string): Vertex[];
-    getChildrenIds(vertexId: string): string[];
-    /** Returns the ancestors of the given vertex. The first element is the root vertex. */
-    getAncestors(vertexId: string): Vertex[];
-    getVertexProperty(vertexId: string, key: string, includingTransient?: boolean): VertexPropertyType | undefined;
-    getVertexProperties(vertexId: string): Readonly<TreeVertexProperty[]>;
+    getMoveOps(): ReadonlyArray<MoveNode>;
+    getAllOps(): ReadonlyArray<NodeOperation>;
+    getNode(nodeId: string): Node | undefined;
+    getAllNodes(): ReadonlyArray<Node>;
+    getParent(nodeId: string): Node | undefined;
+    getChildren(nodeId: string): Node[];
+    getChildrenIds(nodeId: string): string[];
+    /** Returns the ancestors of the given node. The first element is the root node. */
+    getAncestors(nodeId: string): Node[];
+    getNodeProperty(nodeId: string, key: string, includingTransient?: boolean): NodePropertyType | undefined;
+    getNodeProperties(nodeId: string): Readonly<TreeNodeProperty[]>;
     /**
      * Returns all local operations and clears the local operations list.
      * Can be used to get all operations that were generated from this peer and need to be sent to other peers.
      */
-    popLocalOps(): VertexOperation[];
+    popLocalOps(): NodeOperation[];
     /**
-     * This is the first vertex that will contain all other vertices.
+     * This is the first node that will contain all other nodes.
      * If you plan to replicate a tree then don't use this method and instead merge
-     * in the ops from another tree (that will also contain the root vertex).
-     * @returns The root vertex
+     * in the ops from another tree (that will also contain the root node).
+     * @returns The root node
      */
-    createRoot(): Vertex;
-    newVertex(parentId: string, props?: Record<string, VertexPropertyType> | object | null): Vertex;
-    newNamedVertex(parentId: string, name: string, props?: Record<string, VertexPropertyType> | object | null): Vertex;
-    moveVertex(vertexId: string, parentId: string): void;
-    deleteVertex(vertexId: string): void;
-    setTransientVertexProperty(vertexId: string, key: string, value: VertexPropertyType): void;
+    createRoot(): Node;
+    newNode(parentId: string, props?: Record<string, NodePropertyType> | object | null): Node;
+    newNamedNode(parentId: string, name: string, props?: Record<string, NodePropertyType> | object | null): Node;
+    moveNode(nodeId: string, parentId: string): void;
+    deleteNode(nodeId: string): void;
+    setTransientNodeProperty(nodeId: string, key: string, value: NodePropertyType): void;
     /**
      * Promotes all transient (temporary) properties to persistent properties.
-     * @param vertexId - The ID of the vertex to commit transients for.
+     * @param nodeId - The ID of the node to commit transients for.
      * @returns
      */
-    commitTransients(vertexId: string): void;
-    setVertexProperty(vertexId: string, key: string, value: VertexPropertyType): void;
-    setVertexProperties(vertexId: string, props: Record<string, VertexPropertyType> | object): void;
-    getVertexByPath(path: string): Vertex | undefined;
-    private getVertexByPathArray;
+    commitTransients(nodeId: string): void;
+    setNodeProperty(nodeId: string, key: string, value: NodePropertyType): void;
+    setNodeProperties(nodeId: string, props: Record<string, NodePropertyType> | object): void;
+    getNodeByPath(path: string): Node | undefined;
+    private getNodeByPathArray;
     printTree(): string;
-    merge(ops: ReadonlyArray<VertexOperation>): void;
+    merge(ops: ReadonlyArray<NodeOperation>): void;
     private applyOps;
     /** Applies operations in an optimized way, sorting move ops by OpId to avoid undo-do-redo cycles */
     private applyOpsOptimizedForLotsOfMoves;
     compareStructure(other: RepTree): boolean;
     compareMoveOps(other: RepTree): boolean;
-    /** Checks if the given `ancestorId` is an ancestor of `childId` in the tree */
+    /** Checks whether moving `targetId` under `parentId` would create a cycle. */
+    wouldMoveCreateCycle(move: Pick<MoveNode, 'targetId' | 'parentId'>): boolean;
+    /**
+     * Checks if the given `ancestorId` is an ancestor of `childId` in the tree.
+     *
+     * @deprecated Use `wouldMoveCreateCycle` for move validation.
+     */
     isAncestor(childId: string, ancestorId: string | null): boolean;
-    observeVertex(vertexId: string, callback: (updatedVertex: Vertex) => void): () => void;
-    observeVertexMove(callback: (movedVertex: Vertex, isNew: boolean) => void): () => void;
-    observe(vertexId: string, callback: (events: VertexChangeEvent[]) => void): () => void;
-    observeOpApplied(callback: (op: VertexOperation) => void): () => void;
-    static compareVertices(vertexId: string, treeA: RepTree, treeB: RepTree): boolean;
-    private newVertexInternal;
-    private newVertexInternalWithUUID;
-    private ensureNullVertex;
+    private hasAncestor;
+    observeNode(nodeId: string, callback: (updatedNode: Node) => void): () => void;
+    observeNodeMove(callback: (movedNode: Node, isNew: boolean) => void): () => void;
+    observe(nodeId: string, callback: (events: NodeChangeEvent[]) => void): () => void;
+    observeOpApplied(callback: (op: NodeOperation) => void): () => void;
+    static compareNodes(nodeId: string, treeA: RepTree, treeB: RepTree): boolean;
+    private newNodeInternal;
+    private newNodeInternalWithUUID;
+    private ensureNullNode;
     /** Updates the lamport clock with the counter value of the operation */
-    private updateLamportClock;
+    private updateMoveClock;
+    private updatePropClock;
     private applyPendingMovesForParent;
     private applyMove;
     private setLLWPropertyAndItsOpId;
@@ -339,22 +353,26 @@ declare class RepTree {
     private applyProperty;
     private applyLLWProperty;
     private applyOperation;
+    private markOpSeen;
     private reportOpAsApplied;
     private tryToMove;
     private undoMove;
     /**
-     * Returns the current state vector.
-     * Returns a readonly reference to the internal state vector.
+     * Returns the current state vectors for move and property streams.
+     * Returns readonly references to the internal state vectors.
      */
-    getStateVector(): Readonly<Record<string, number[][]>> | null;
+    getStateVectors(): {
+        move: Readonly<StateVectors["move"]>;
+        prop: Readonly<StateVectors["prop"]>;
+    } | null;
     /**
      * Determines which operations are needed to synchronize
      * with the provided state vector.
      *
-     * @param theirStateVector The state vector from another peer
-     * @returns Operations that should be sent to the other peer, sorted by OpId.
+     * @param theirStateVectors The state vectors from another peer
+     * @returns Operations that should be sent to the other peer, sorted by OpId within each stream.
      */
-    getMissingOps(theirStateVector: Record<string, number[][]>): VertexOperation[];
+    getMissingOps(theirStateVectors: StateVectors): NodeOperation[];
     /**
      * Gets or sets whether state vector tracking is enabled
      */
@@ -365,35 +383,41 @@ declare class RepTree {
      */
     set stateVectorEnabled(value: boolean);
     /**
-     * Parses the vertex properties with a provided schema that has a `parse` method (e.g., Zod schema)
+     * Parses the node properties with a provided schema that has a `parse` method (e.g., Zod schema)
      */
-    parseVertex<T>(vertexId: string, schema: {
+    parseNode<T>(nodeId: string, schema: {
         parse: (data: unknown) => T;
     }): T;
+    private getPropertyOps;
+    private refreshPropStateVector;
+    private getOpKey;
+    private filterOpsByRanges;
 }
 
 declare class TreeState {
-    private vertices;
+    private static BATCH_DELAY_MS;
+    private nodes;
     private changeCallbacks;
     private globalChangeCallbacks;
-    private batchTickInterval;
+    private batchTickTimeout;
     private batchedEvents;
     constructor();
     dispose(): void;
+    private scheduleBatchProcessing;
     private processBatchedEvents;
-    getAllVertices(): ReadonlyArray<VertexState>;
-    getVertex(id: string): VertexState | undefined;
-    getChildrenIds(vertexId: TreeVertexId): string[];
-    getChildren(vertexId: TreeVertexId): VertexState[];
-    moveVertex(vertexId: TreeVertexId, newParentId: TreeVertexId | null): VertexState;
-    setProperty(vertexId: string, key: string, value: VertexPropertyType): void;
-    setTransientProperty(vertexId: string, key: string, value: VertexPropertyType): void;
-    addChangeCallback(vertexId: TreeVertexId, listener: (events: VertexChangeEvent[]) => void): void;
-    removeChangeCallback(vertexId: TreeVertexId, listener: (events: VertexChangeEvent[]) => void): void;
-    addGlobalChangeCallback(listener: (events: VertexChangeEvent[]) => void): void;
-    removeGlobalChangeCallback(listener: (events: VertexChangeEvent[]) => void): void;
+    getAllNodes(): ReadonlyArray<NodeState>;
+    getNode(id: string): NodeState | undefined;
+    getChildrenIds(nodeId: TreeNodeId): string[];
+    getChildren(nodeId: TreeNodeId): NodeState[];
+    moveNode(nodeId: TreeNodeId, newParentId: TreeNodeId | null): NodeState;
+    setProperty(nodeId: string, key: string, value: NodePropertyType): void;
+    setTransientProperty(nodeId: string, key: string, value: NodePropertyType): void;
+    addChangeCallback(nodeId: TreeNodeId, listener: (events: NodeChangeEvent[]) => void): void;
+    removeChangeCallback(nodeId: TreeNodeId, listener: (events: NodeChangeEvent[]) => void): void;
+    addGlobalChangeCallback(listener: (events: NodeChangeEvent[]) => void): void;
+    removeGlobalChangeCallback(listener: (events: NodeChangeEvent[]) => void): void;
     private notifyChange;
-    printTree(vertexId: TreeVertexId, indent?: string, isLast?: boolean): string;
+    printTree(nodeId: TreeNodeId, indent?: string, isLast?: boolean): string;
 }
 
 /**
@@ -420,7 +444,7 @@ declare class StateVector {
      *
      * @param op The operation that was just applied
      */
-    updateFromOp(op: VertexOperation): void;
+    updateFromOp(op: NodeOperation): void;
     /**
      * Returns the current state vector.
      * Returns a readonly reference to the internal state.
@@ -450,9 +474,9 @@ declare class StateVector {
      * @param operations The operations to build the state vector from
      * @returns A new StateVector instance
      */
-    static fromOperations(operations: ReadonlyArray<VertexOperation>): StateVector;
+    static fromOperations(operations: ReadonlyArray<NodeOperation>): StateVector;
 }
 
 declare function uuid(): string;
 
-export { type BindOptions, type BindedVertex, type JsonPrimitive, type JsonValue, type MoveVertex, type OpId, type OpIdRange, RepTree, type SchemaLike, type SetVertexProperty, StateVector, TreeState, type TreeVertexId, type TreeVertexProperty, Vertex, type VertexChangeEvent, type VertexChildrenChangeEvent, type VertexMoveEvent, type VertexOperation, type VertexPropertyChangeEvent, type VertexPropertyType, VertexState, bindVertex, compareOpId, createOpId, equalsOpId, isAnyPropertyOp, isMoveVertexOp, isOpIdGreaterThan, newMoveVertexOp, newSetTransientVertexPropertyOp, newSetVertexPropertyOp, opIdToString, tryParseOpIdStr, uuid };
+export { type BindOptions, type BindedNode, type JsonPrimitive, type JsonValue, type MoveNode, Node, type NodeChangeEvent, type NodeChildrenChangeEvent, type NodeMoveEvent, type NodeOperation, type NodePropertyChangeEvent, type NodePropertyType, NodeState, type OpId, type OpIdRange, RepTree, type SchemaLike, type SetNodeProperty, StateVector, type StateVectors, type TreeNodeId, type TreeNodeProperty, TreeState, bindNode, compareOpId, createOpId, equalsOpId, isAnyPropertyOp, isMoveNodeOp, isOpIdGreaterThan, newMoveNodeOp, newSetNodePropertyOp, newSetTransientNodePropertyOp, opIdToString, tryParseOpIdStr, uuid };