fluid-framework 2.0.0-dev-rc.3.0.0.253463 → 2.0.0-dev-rc.3.0.0.254274

package/api-report/fluid-framework.api.md

@@ -128,6 +128,7 @@ export type ExtractItemType<Item extends LazyItem> = Item extends () => infer Re
 
 // @public
 export enum FieldKind {
+    Identifier = 2,
     Optional = 0,
     Required = 1
 }
@@ -269,7 +270,7 @@ export class IterableTreeArrayContent<T> implements Iterable<T> {
 
 // @public
 export interface ITree extends IChannel {
-    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TreeFieldFromImplicitField<TRoot>>;
+    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TRoot>;
 }
 
 // @public @sealed
@@ -325,11 +326,15 @@ export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
 
 // @public
 export interface Revertible {
-    release(): void;
+    [disposeSymbol](): void;
     revert(): void;
+    revert(dispose: boolean): void;
     readonly status: RevertibleStatus;
 }
 
+// @public
+export type RevertibleFactory = (onRevertibleDisposed?: (revertible: Revertible) => void) => Revertible;
+
 // @public
 export enum RevertibleStatus {
     Disposed = 1,
@@ -345,6 +350,7 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
     // @deprecated
     fixRecursiveReference<T extends AllowedTypes>(...types: T): void;
     readonly handle: TreeNodeSchema<"com.fluidframework.leaf.handle", NodeKind.Leaf, IFluidHandle<FluidObject<unknown> & IFluidLoadable>, IFluidHandle<FluidObject<unknown> & IFluidLoadable>>;
+    get identifier(): FieldSchema<FieldKind.Identifier>;
     map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, true, T>;
     map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, true, T>;
     namedArray_internal<Name extends TName | string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Array, TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, string>>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable, T>;
@@ -381,8 +387,9 @@ export const Tree: TreeApi;
 
 // @public
 export interface TreeApi extends TreeNodeApi {
+    contains(node: TreeNode, other: TreeNode): boolean;
     runTransaction<TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void | "rollback"): void;
-    runTransaction<TRoot>(tree: TreeView<TRoot>, transaction: (root: TRoot) => void | "rollback"): void;
+    runTransaction<TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void | "rollback"): void;
 }
 
 // @public
@@ -454,6 +461,7 @@ export interface TreeNodeApi {
     on<K extends keyof TreeChangeEvents>(node: TreeNode, eventName: K, listener: TreeChangeEvents[K]): () => void;
     parent(node: TreeNode): TreeNode | undefined;
     schema<T extends TreeNode | TreeLeafValue>(node: T): TreeNodeSchema<string, NodeKind, unknown, T>;
+    shortId(node: TreeNode): number | undefined;
     readonly status: (node: TreeNode) => TreeStatus;
 }
 
@@ -496,18 +504,18 @@ export enum TreeStatus {
 }
 
 // @public
-export interface TreeView<in out TRoot> extends IDisposable {
+export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
     readonly error?: SchemaIncompatible;
     readonly events: ISubscribable<TreeViewEvents>;
-    readonly root: TRoot;
+    get root(): TreeFieldFromImplicitField<TSchema>;
+    set root(newRoot: InsertableTreeFieldFromImplicitField<TSchema>);
     upgradeSchema(): void;
 }
 
 // @public
 export interface TreeViewEvents {
     afterBatch(): void;
-    commitApplied(data: CommitMetadata, getRevertible?: () => Revertible): void;
-    revertibleDisposed(revertible: Revertible): void;
+    commitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;
     rootChanged(): void;
 }
 

package/dist/fluid-framework-alpha.d.ts

@@ -221,6 +221,9 @@ export declare interface ContainerSchema {
  * constructor that will return the type of the `DataObject`.
  *
  * @typeParam T - The class of the `DataObject`.
+ * @privateRemarks
+ * Having both `factory` and `LoadableObjectCtor` is redundant, and having `factory` not actually work as a factory is also strange.
+ * This may need some refinement.
  * @public
  */
 export declare type DataObjectClass<T extends IFluidLoadable = IFluidLoadable> = {
@@ -366,7 +369,13 @@ export declare enum FieldKind {
      * @remarks
      * Only allows exactly one child.
      */
-    Required = 1
+    Required = 1,
+    /**
+     * A special field used for node identifiers.
+     * @remarks
+     * Only allows exactly one child.
+     */
+    Identifier = 2
 }
 
 /**
@@ -1008,7 +1017,7 @@ export declare interface ITree extends IChannel {
      * Additionally, once out of schema content adapters are properly supported (with lazy document updates),
      * this initialization could become just another out of schema content adapter and this initialization is no longer a special case.
      */
-    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TreeFieldFromImplicitField<TRoot>>;
+    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TRoot>;
 }
 
 /**
@@ -1228,15 +1237,36 @@ export declare interface Revertible {
      */
     readonly status: RevertibleStatus;
     /**
-     * Reverts the associated change.
+     * Reverts the associated change and disposes it.
      */
     revert(): void;
     /**
-     * Releases this revertible so that it can no longer be used.
+     * Reverts the associated change and optionally disposes it.
+     *
+     * @param dispose - If true, the revertible will be disposed after being reverted.
+     * If false, the revertible will remain valid. This can be useful for scenarios where the revert may be dropped
+     * due to merge conflicts, and one wants to attempt reverting again.
+     */
+    revert(dispose: boolean): void;
+    /**
+     * Disposes this revertible, allowing associated resources to be released.
      */
-    release(): void;
+    [disposeSymbol](): void;
 }
 
+/**
+ * Factory for creating a {@link Revertible}.
+ * Will error if invoked outside the scope of the `commitApplied` event that provides it, or if invoked multiple times.
+ *
+ * @param onRevertibleDisposed - A callback that will be invoked when the `Revertible` generated by this factory is disposed.
+ * This happens when the `Revertible` is disposed manually, or when the `TreeView` that the `Revertible` belongs to is disposed,
+ * whichever happens first.
+ * This is typically used to clean up any resources associated with the `Revertible` in the host application.
+ *
+ * @public
+ */
+export declare type RevertibleFactory = (onRevertibleDisposed?: (revertible: Revertible) => void) => Revertible;
+
 /**
  * The status of a {@link Revertible}.
  *
@@ -1496,6 +1526,10 @@ export declare class SchemaFactory<out TScope extends string | undefined = strin
      * and allows associating custom {@link FieldProps | properties} with the field.
      */
     required<const T extends ImplicitAllowedTypes>(t: T, props?: FieldProps): FieldSchema<FieldKind.Required, T>;
+    /**
+     * Make a field of type identifier instead of the default which is required.
+     */
+    get identifier(): FieldSchema<FieldKind.Identifier>;
     /**
      * Function which can be used for its compile time side-effects to tweak the evaluation order of recursive types to make them compile.
      * @remarks
@@ -1620,7 +1654,23 @@ export declare interface TreeApi extends TreeNodeApi {
      * Local change events will be emitted for each change as the transaction is being applied.
      * If the transaction is cancelled and rolled back, a corresponding change event will also be emitted for the rollback.
      */
-    runTransaction<TRoot>(tree: TreeView<TRoot>, transaction: (root: TRoot) => void | "rollback"): void;
+    runTransaction<TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void | "rollback"): void;
+    /**
+     * Check if the subtree defined by `node` contains `other`.
+     *
+     * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.
+     * @remarks
+     * This includes direct and indirect children:
+     * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.
+     *
+     * `node` is considered to contain itself, so the case where `node === other` returns true.
+     *
+     * This is handy when checking if moving `node` into `other` would create a cycle and thus is invalid.
+     *
+     * This check walks the parents of `other` looking for `node`,
+     * and thus runs in time proportional to the depth of child in the tree.
+     */
+    contains(node: TreeNode, other: TreeNode): boolean;
 }
 
 /**
@@ -2031,6 +2081,11 @@ export declare interface TreeNodeApi {
      * Returns the {@link TreeStatus} of the given node.
      */
     readonly status: (node: TreeNode) => TreeStatus;
+    /**
+     * If the given node has an identifier specified by a field of kind "identifier" then this returns the compressed form of that identifier.
+     * Otherwise returns undefined.
+     */
+    shortId(node: TreeNode): number | undefined;
 }
 
 /**
@@ -2161,7 +2216,7 @@ export declare enum TreeStatus {
  * it could be mitigated by adding a `rootOrError` member and deprecating `root` to give users a warning if they might be missing the error checking.
  * @public
  */
-export declare interface TreeView<in out TRoot> extends IDisposable {
+export declare interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
     /**
      * The current root of the tree.
      *
@@ -2171,7 +2226,8 @@ export declare interface TreeView<in out TRoot> extends IDisposable {
      * To get notified about changes to this field (including to it being in an `error` state),
      * use {@link TreeViewEvents.rootChanged} via `view.events.on("rootChanged", callback)`.
      */
-    readonly root: TRoot;
+    get root(): TreeFieldFromImplicitField<TSchema>;
+    set root(newRoot: InsertableTreeFieldFromImplicitField<TSchema>);
     /**
      * Description of the error state, if any.
      * When this is undefined, the view schema and stored schema are compatible, and `root` can be used.
@@ -2214,12 +2270,6 @@ export declare interface TreeViewEvents {
      * This does NOT include changes to the content (fields/children) of the root node: for that case subscribe to events on the root node.
      */
     rootChanged(): void;
-    /**
-     * Fired when a revertible made on this view is disposed.
-     *
-     * @param revertible - The revertible that was disposed.
-     */
-    revertibleDisposed(revertible: Revertible): void;
     /**
      * Fired when:
      * - a local commit is applied outside of a transaction
@@ -2233,7 +2283,7 @@ export declare interface TreeViewEvents {
      * @param getRevertible - a function provided that allows users to get a revertible for the commit that was applied. If not provided,
      * this commit is not revertible.
      */
-    commitApplied(data: CommitMetadata, getRevertible?: () => Revertible): void;
+    commitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;
 }
 
 /**

package/dist/fluid-framework-beta.d.ts

@@ -200,6 +200,9 @@ export declare interface ContainerSchema {
  * constructor that will return the type of the `DataObject`.
  *
  * @typeParam T - The class of the `DataObject`.
+ * @privateRemarks
+ * Having both `factory` and `LoadableObjectCtor` is redundant, and having `factory` not actually work as a factory is also strange.
+ * This may need some refinement.
  * @public
  */
 export declare type DataObjectClass<T extends IFluidLoadable = IFluidLoadable> = {
@@ -345,7 +348,13 @@ export declare enum FieldKind {
      * @remarks
      * Only allows exactly one child.
      */
-    Required = 1
+    Required = 1,
+    /**
+     * A special field used for node identifiers.
+     * @remarks
+     * Only allows exactly one child.
+     */
+    Identifier = 2
 }
 
 /**
@@ -987,7 +996,7 @@ export declare interface ITree extends IChannel {
      * Additionally, once out of schema content adapters are properly supported (with lazy document updates),
      * this initialization could become just another out of schema content adapter and this initialization is no longer a special case.
      */
-    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TreeFieldFromImplicitField<TRoot>>;
+    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TRoot>;
 }
 
 /**
@@ -1207,15 +1216,36 @@ export declare interface Revertible {
      */
     readonly status: RevertibleStatus;
     /**
-     * Reverts the associated change.
+     * Reverts the associated change and disposes it.
      */
     revert(): void;
     /**
-     * Releases this revertible so that it can no longer be used.
+     * Reverts the associated change and optionally disposes it.
+     *
+     * @param dispose - If true, the revertible will be disposed after being reverted.
+     * If false, the revertible will remain valid. This can be useful for scenarios where the revert may be dropped
+     * due to merge conflicts, and one wants to attempt reverting again.
+     */
+    revert(dispose: boolean): void;
+    /**
+     * Disposes this revertible, allowing associated resources to be released.
      */
-    release(): void;
+    [disposeSymbol](): void;
 }
 
+/**
+ * Factory for creating a {@link Revertible}.
+ * Will error if invoked outside the scope of the `commitApplied` event that provides it, or if invoked multiple times.
+ *
+ * @param onRevertibleDisposed - A callback that will be invoked when the `Revertible` generated by this factory is disposed.
+ * This happens when the `Revertible` is disposed manually, or when the `TreeView` that the `Revertible` belongs to is disposed,
+ * whichever happens first.
+ * This is typically used to clean up any resources associated with the `Revertible` in the host application.
+ *
+ * @public
+ */
+export declare type RevertibleFactory = (onRevertibleDisposed?: (revertible: Revertible) => void) => Revertible;
+
 /**
  * The status of a {@link Revertible}.
  *
@@ -1475,6 +1505,10 @@ export declare class SchemaFactory<out TScope extends string | undefined = strin
      * and allows associating custom {@link FieldProps | properties} with the field.
      */
     required<const T extends ImplicitAllowedTypes>(t: T, props?: FieldProps): FieldSchema<FieldKind.Required, T>;
+    /**
+     * Make a field of type identifier instead of the default which is required.
+     */
+    get identifier(): FieldSchema<FieldKind.Identifier>;
     /**
      * Function which can be used for its compile time side-effects to tweak the evaluation order of recursive types to make them compile.
      * @remarks
@@ -1599,7 +1633,23 @@ export declare interface TreeApi extends TreeNodeApi {
      * Local change events will be emitted for each change as the transaction is being applied.
      * If the transaction is cancelled and rolled back, a corresponding change event will also be emitted for the rollback.
      */
-    runTransaction<TRoot>(tree: TreeView<TRoot>, transaction: (root: TRoot) => void | "rollback"): void;
+    runTransaction<TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void | "rollback"): void;
+    /**
+     * Check if the subtree defined by `node` contains `other`.
+     *
+     * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.
+     * @remarks
+     * This includes direct and indirect children:
+     * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.
+     *
+     * `node` is considered to contain itself, so the case where `node === other` returns true.
+     *
+     * This is handy when checking if moving `node` into `other` would create a cycle and thus is invalid.
+     *
+     * This check walks the parents of `other` looking for `node`,
+     * and thus runs in time proportional to the depth of child in the tree.
+     */
+    contains(node: TreeNode, other: TreeNode): boolean;
 }
 
 /**
@@ -2010,6 +2060,11 @@ export declare interface TreeNodeApi {
      * Returns the {@link TreeStatus} of the given node.
      */
     readonly status: (node: TreeNode) => TreeStatus;
+    /**
+     * If the given node has an identifier specified by a field of kind "identifier" then this returns the compressed form of that identifier.
+     * Otherwise returns undefined.
+     */
+    shortId(node: TreeNode): number | undefined;
 }
 
 /**
@@ -2140,7 +2195,7 @@ export declare enum TreeStatus {
  * it could be mitigated by adding a `rootOrError` member and deprecating `root` to give users a warning if they might be missing the error checking.
  * @public
  */
-export declare interface TreeView<in out TRoot> extends IDisposable {
+export declare interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
     /**
      * The current root of the tree.
      *
@@ -2150,7 +2205,8 @@ export declare interface TreeView<in out TRoot> extends IDisposable {
      * To get notified about changes to this field (including to it being in an `error` state),
      * use {@link TreeViewEvents.rootChanged} via `view.events.on("rootChanged", callback)`.
      */
-    readonly root: TRoot;
+    get root(): TreeFieldFromImplicitField<TSchema>;
+    set root(newRoot: InsertableTreeFieldFromImplicitField<TSchema>);
     /**
      * Description of the error state, if any.
      * When this is undefined, the view schema and stored schema are compatible, and `root` can be used.
@@ -2193,12 +2249,6 @@ export declare interface TreeViewEvents {
      * This does NOT include changes to the content (fields/children) of the root node: for that case subscribe to events on the root node.
      */
     rootChanged(): void;
-    /**
-     * Fired when a revertible made on this view is disposed.
-     *
-     * @param revertible - The revertible that was disposed.
-     */
-    revertibleDisposed(revertible: Revertible): void;
     /**
      * Fired when:
      * - a local commit is applied outside of a transaction
@@ -2212,7 +2262,7 @@ export declare interface TreeViewEvents {
      * @param getRevertible - a function provided that allows users to get a revertible for the commit that was applied. If not provided,
      * this commit is not revertible.
      */
-    commitApplied(data: CommitMetadata, getRevertible?: () => Revertible): void;
+    commitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;
 }
 
 /**

package/dist/fluid-framework-public.d.ts

@@ -200,6 +200,9 @@ export declare interface ContainerSchema {
  * constructor that will return the type of the `DataObject`.
  *
  * @typeParam T - The class of the `DataObject`.
+ * @privateRemarks
+ * Having both `factory` and `LoadableObjectCtor` is redundant, and having `factory` not actually work as a factory is also strange.
+ * This may need some refinement.
  * @public
  */
 export declare type DataObjectClass<T extends IFluidLoadable = IFluidLoadable> = {
@@ -345,7 +348,13 @@ export declare enum FieldKind {
      * @remarks
      * Only allows exactly one child.
      */
-    Required = 1
+    Required = 1,
+    /**
+     * A special field used for node identifiers.
+     * @remarks
+     * Only allows exactly one child.
+     */
+    Identifier = 2
 }
 
 /**
@@ -987,7 +996,7 @@ export declare interface ITree extends IChannel {
      * Additionally, once out of schema content adapters are properly supported (with lazy document updates),
      * this initialization could become just another out of schema content adapter and this initialization is no longer a special case.
      */
-    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TreeFieldFromImplicitField<TRoot>>;
+    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TRoot>;
 }
 
 /**
@@ -1207,15 +1216,36 @@ export declare interface Revertible {
      */
     readonly status: RevertibleStatus;
     /**
-     * Reverts the associated change.
+     * Reverts the associated change and disposes it.
      */
     revert(): void;
     /**
-     * Releases this revertible so that it can no longer be used.
+     * Reverts the associated change and optionally disposes it.
+     *
+     * @param dispose - If true, the revertible will be disposed after being reverted.
+     * If false, the revertible will remain valid. This can be useful for scenarios where the revert may be dropped
+     * due to merge conflicts, and one wants to attempt reverting again.
+     */
+    revert(dispose: boolean): void;
+    /**
+     * Disposes this revertible, allowing associated resources to be released.
      */
-    release(): void;
+    [disposeSymbol](): void;
 }
 
+/**
+ * Factory for creating a {@link Revertible}.
+ * Will error if invoked outside the scope of the `commitApplied` event that provides it, or if invoked multiple times.
+ *
+ * @param onRevertibleDisposed - A callback that will be invoked when the `Revertible` generated by this factory is disposed.
+ * This happens when the `Revertible` is disposed manually, or when the `TreeView` that the `Revertible` belongs to is disposed,
+ * whichever happens first.
+ * This is typically used to clean up any resources associated with the `Revertible` in the host application.
+ *
+ * @public
+ */
+export declare type RevertibleFactory = (onRevertibleDisposed?: (revertible: Revertible) => void) => Revertible;
+
 /**
  * The status of a {@link Revertible}.
  *
@@ -1475,6 +1505,10 @@ export declare class SchemaFactory<out TScope extends string | undefined = strin
      * and allows associating custom {@link FieldProps | properties} with the field.
      */
     required<const T extends ImplicitAllowedTypes>(t: T, props?: FieldProps): FieldSchema<FieldKind.Required, T>;
+    /**
+     * Make a field of type identifier instead of the default which is required.
+     */
+    get identifier(): FieldSchema<FieldKind.Identifier>;
     /**
      * Function which can be used for its compile time side-effects to tweak the evaluation order of recursive types to make them compile.
      * @remarks
@@ -1599,7 +1633,23 @@ export declare interface TreeApi extends TreeNodeApi {
      * Local change events will be emitted for each change as the transaction is being applied.
      * If the transaction is cancelled and rolled back, a corresponding change event will also be emitted for the rollback.
      */
-    runTransaction<TRoot>(tree: TreeView<TRoot>, transaction: (root: TRoot) => void | "rollback"): void;
+    runTransaction<TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void | "rollback"): void;
+    /**
+     * Check if the subtree defined by `node` contains `other`.
+     *
+     * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.
+     * @remarks
+     * This includes direct and indirect children:
+     * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.
+     *
+     * `node` is considered to contain itself, so the case where `node === other` returns true.
+     *
+     * This is handy when checking if moving `node` into `other` would create a cycle and thus is invalid.
+     *
+     * This check walks the parents of `other` looking for `node`,
+     * and thus runs in time proportional to the depth of child in the tree.
+     */
+    contains(node: TreeNode, other: TreeNode): boolean;
 }
 
 /**
@@ -2010,6 +2060,11 @@ export declare interface TreeNodeApi {
      * Returns the {@link TreeStatus} of the given node.
      */
     readonly status: (node: TreeNode) => TreeStatus;
+    /**
+     * If the given node has an identifier specified by a field of kind "identifier" then this returns the compressed form of that identifier.
+     * Otherwise returns undefined.
+     */
+    shortId(node: TreeNode): number | undefined;
 }
 
 /**
@@ -2140,7 +2195,7 @@ export declare enum TreeStatus {
  * it could be mitigated by adding a `rootOrError` member and deprecating `root` to give users a warning if they might be missing the error checking.
  * @public
  */
-export declare interface TreeView<in out TRoot> extends IDisposable {
+export declare interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
     /**
      * The current root of the tree.
      *
@@ -2150,7 +2205,8 @@ export declare interface TreeView<in out TRoot> extends IDisposable {
      * To get notified about changes to this field (including to it being in an `error` state),
      * use {@link TreeViewEvents.rootChanged} via `view.events.on("rootChanged", callback)`.
      */
-    readonly root: TRoot;
+    get root(): TreeFieldFromImplicitField<TSchema>;
+    set root(newRoot: InsertableTreeFieldFromImplicitField<TSchema>);
     /**
      * Description of the error state, if any.
      * When this is undefined, the view schema and stored schema are compatible, and `root` can be used.
@@ -2193,12 +2249,6 @@ export declare interface TreeViewEvents {
      * This does NOT include changes to the content (fields/children) of the root node: for that case subscribe to events on the root node.
      */
     rootChanged(): void;
-    /**
-     * Fired when a revertible made on this view is disposed.
-     *
-     * @param revertible - The revertible that was disposed.
-     */
-    revertibleDisposed(revertible: Revertible): void;
     /**
      * Fired when:
      * - a local commit is applied outside of a transaction
@@ -2212,7 +2262,7 @@ export declare interface TreeViewEvents {
      * @param getRevertible - a function provided that allows users to get a revertible for the commit that was applied. If not provided,
      * this commit is not revertible.
      */
-    commitApplied(data: CommitMetadata, getRevertible?: () => Revertible): void;
+    commitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;
 }
 
 /**