@fluidframework/tree 2.3.0-288113 → 2.4.0-294316

package/src/feature-libraries/typed-schema/typedTreeSchema.ts

@@ -21,7 +21,6 @@ import {
 	identifierFieldKindIdentifier,
 } from "../../core/index.js";
 import {
-	type Assume,
 	type MakeNominal,
 	type Named,
 	compareSets,
@@ -29,6 +28,7 @@ import {
 	oneFromSet,
 	type requireAssignableTo,
 	filterIterable,
+	brand,
 } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
 import type { FlexFieldKind, FullSchemaPolicy } from "../modular-schema/index.js";
@@ -42,12 +42,6 @@ export interface FlexObjectNodeFields {
 	readonly [key: string]: FlexFieldSchema;
 }
 
-/**
- */
-export type NormalizeObjectNodeFields<T extends FlexObjectNodeFields> = {
-	readonly [Property in keyof T]: NormalizeField<T[Property]>;
-};
-
 /**
  * A placeholder to use in {@link https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-constraints | extends constraints} when using the real type breaks compilation of some recursive types due to {@link https://github.com/microsoft/TypeScript/issues/55758 | a design limitation of TypeScript}.
  *
@@ -67,14 +61,11 @@ export type Unenforced<_DesiredExtendsConstraint> = unknown;
  * This can not be enforced using TypeScript since doing so breaks recursive type support.
  * See note on SchemaBuilder.fieldRecursive.
  */
-export abstract class TreeNodeSchemaBase<
-	const out Name extends string = string,
-	const out Specification = unknown,
-> {
+export abstract class TreeNodeSchemaBase<const out Specification = unknown> {
 	protected _typeCheck!: MakeNominal;
 	protected constructor(
 		public readonly builder: Named<string>,
-		public readonly name: TreeNodeSchemaIdentifier<Name>,
+		public readonly name: TreeNodeSchemaIdentifier,
 		public readonly info: Specification,
 		public readonly stored: TreeNodeStoredSchema,
 	) {}
@@ -83,23 +74,17 @@ export abstract class TreeNodeSchemaBase<
 
 /**
  */
-export class FlexMapNodeSchema<
-	const out Name extends string = string,
-	const out Specification extends Unenforced<FlexMapFieldSchema> = FlexMapFieldSchema,
-> extends TreeNodeSchemaBase<Name, Specification> {
+export class FlexMapNodeSchema extends TreeNodeSchemaBase {
 	public get mapFields(): FlexMapFieldSchema {
 		return this.info as FlexMapFieldSchema;
 	}
 
 	protected _typeCheck2?: MakeNominal;
-	public static create<
-		const Name extends string,
-		const Specification extends FlexMapFieldSchema,
-	>(
+	public static create<const Name extends string>(
 		builder: Named<string>,
 		name: TreeNodeSchemaIdentifier<Name>,
-		specification: Specification,
-	): FlexMapNodeSchema<Name, Specification> {
+		specification: FlexMapFieldSchema,
+	): FlexMapNodeSchema {
 		return new FlexMapNodeSchema(
 			builder,
 			name,
@@ -115,26 +100,10 @@ export class FlexMapNodeSchema<
 
 /**
  */
-export class LeafNodeSchema<
-	const out Name extends string = string,
-	const out Specification extends Unenforced<ValueSchema> = ValueSchema,
-> extends TreeNodeSchemaBase<Name, Specification> {
-	public get leafValue(): ValueSchema {
-		return this.info as ValueSchema;
-	}
-
+export class LeafNodeSchema extends TreeNodeSchemaBase<ValueSchema> {
 	protected _typeCheck2?: MakeNominal;
-	public static create<const Name extends string, const Specification extends ValueSchema>(
-		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		specification: Specification,
-	): LeafNodeSchema<Name, Specification> {
-		return new LeafNodeSchema(
-			builder,
-			name,
-			specification,
-			new LeafNodeStoredSchema(specification),
-		);
+	public constructor(builder: Named<string>, name: string, specification: ValueSchema) {
+		super(builder, brand(name), specification, new LeafNodeStoredSchema(specification));
 	}
 
 	public override getFieldSchema(field: FieldKey): FlexFieldSchema {
@@ -144,28 +113,18 @@ export class LeafNodeSchema<
 
 /**
  */
-export class FlexObjectNodeSchema<
-	const out Name extends string = string,
-	const out Specification extends Unenforced<FlexObjectNodeFields> = FlexObjectNodeFields,
-> extends TreeNodeSchemaBase<Name, Specification> {
+export class FlexObjectNodeSchema extends TreeNodeSchemaBase {
 	protected _typeCheck2?: MakeNominal;
 	public readonly identifierFieldKeys: readonly FieldKey[] = [];
 
-	public static create<
-		const Name extends string,
-		const Specification extends FlexObjectNodeFields,
-	>(
+	public static create(
 		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		specification: Specification,
-	): FlexObjectNodeSchema<Name, Specification> {
-		const objectNodeFieldsObject: NormalizeObjectNodeFields<Specification> =
-			normalizeStructFields<Specification>(specification);
-		const objectNodeFields: ObjectToMap<
-			NormalizeObjectNodeFields<Specification>,
-			FieldKey,
-			FlexFieldSchema
-		> = objectToMapTyped(objectNodeFieldsObject);
+		name: TreeNodeSchemaIdentifier,
+		specification: FlexObjectNodeFields,
+	): FlexObjectNodeSchema {
+		const objectNodeFieldsObject = normalizeStructFields(specification);
+		const objectNodeFields: ObjectToMap<FlexObjectNodeFields, FieldKey, FlexFieldSchema> =
+			objectToMapTyped(objectNodeFieldsObject);
 		return new FlexObjectNodeSchema(
 			builder,
 			name,
@@ -177,11 +136,9 @@ export class FlexObjectNodeSchema<
 
 	private constructor(
 		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		info: Specification,
-		public readonly objectNodeFieldsObject: NormalizeObjectNodeFields<
-			Assume<Specification, FlexObjectNodeFields>
-		>,
+		name: TreeNodeSchemaIdentifier,
+		info: FlexObjectNodeFields,
+		public readonly objectNodeFieldsObject: FlexObjectNodeFields,
 		// Allows reading fields through the normal map.
 		// Stricter typing caused Specification to no longer be covariant, so has been removed.
 		public readonly objectNodeFields: ReadonlyMap<FieldKey, FlexFieldSchema>,
@@ -211,16 +168,9 @@ export class FlexObjectNodeSchema<
  */
 export type FlexTreeNodeSchema = TreeNodeSchemaBase;
 
-/**
- * Convert FieldSchemaSpecification | undefined into TreeFieldSchema.
- */
-export type NormalizeField<T extends FlexFieldSchema | undefined> = T extends FlexFieldSchema
-	? T
-	: FlexFieldSchema<typeof FieldKinds.forbidden, []>;
-
 function normalizeStructFields<T extends FlexObjectNodeFields>(
 	fields: T,
-): NormalizeObjectNodeFields<T> {
+): FlexObjectNodeFields {
 	const out: Record<string, FlexFieldSchema> = {};
 	// eslint-disable-next-line no-restricted-syntax
 	for (const key in fields) {
@@ -229,27 +179,18 @@ function normalizeStructFields<T extends FlexObjectNodeFields>(
 			out[key] = normalizeField(element);
 		}
 	}
-	return out as NormalizeObjectNodeFields<T>;
+	return out;
 }
 
-function normalizeField<T extends FlexFieldSchema | undefined>(t: T): NormalizeField<T> {
+function normalizeField(t: FlexFieldSchema | undefined): FlexFieldSchema {
 	if (t === undefined) {
-		return FlexFieldSchema.empty as unknown as NormalizeField<T>;
+		return FlexFieldSchema.empty;
 	}
 
 	assert(t instanceof FlexFieldSchema, 0x6ae /* invalid TreeFieldSchema */);
-	return t as NormalizeField<T>;
+	return t;
 }
 
-/**
- * Allow any node (as long as it meets the schema for its own type).
- */
-export const Any = "Any" as const;
-/**
- * Allow any node (as long as it meets the schema for its own type).
- */
-export type Any = typeof Any;
-
 /**
  * Tree type, but can be wrapped in a function to allow referring to types before they are declared.
  * This makes recursive and co-recursive types possible.
@@ -258,17 +199,8 @@ export type LazyTreeNodeSchema = FlexTreeNodeSchema | (() => FlexTreeNodeSchema)
 
 /**
  * Types for use in fields.
- *
- * "Any" is boxed in an array to allow use as variadic parameter.
  */
-export type FlexAllowedTypes = readonly [Any] | readonly LazyItem<FlexTreeNodeSchema>[];
-
-/**
- * Checks if an {@link FlexAllowedTypes} is {@link (Any:type)}.
- */
-export function allowedTypesIsAny(t: FlexAllowedTypes): t is readonly [Any] {
-	return t.length === 1 && t[0] === Any;
-}
+export type FlexAllowedTypes = readonly LazyItem<FlexTreeNodeSchema>[];
 
 /**
  * Subset of TreeFieldSchema thats legal in maps.
@@ -292,10 +224,7 @@ export type FlexMapFieldSchema = FlexFieldSchema<
  *
  * @sealed
  */
-export class FlexFieldSchema<
-	out TKind extends FlexFieldKind = FlexFieldKind,
-	const out TTypes extends Unenforced<FlexAllowedTypes> = FlexAllowedTypes,
-> {
+export class FlexFieldSchema<out TKind extends FlexFieldKind = FlexFieldKind> {
 	/**
 	 * Schema for a field which must always be empty.
 	 */
@@ -306,23 +235,10 @@ export class FlexFieldSchema<
 	 * @privateRemarks
 	 * Alias for the constructor, but with extends clause for the `Types` parameter that {@link FlexFieldSchema} can not have (due to recursive type issues).
 	 */
-	public static create<TKind extends FlexFieldKind, const Types extends FlexAllowedTypes>(
+	public static create<TKind extends FlexFieldKind>(
 		kind: TKind,
-		allowedTypes: Types,
-	): FlexFieldSchema<TKind, Types> {
-		return new FlexFieldSchema(kind, allowedTypes);
-	}
-
-	/**
-	 * Constructs a TreeFieldSchema, but missing the extends clause which breaks most recursive types.
-	 * @remarks
-	 * `Types` here must extend `AllowedTypes`, but this cannot be enforced with an "extends" clause: see {@link Unenforced} for details.
-	 * Prefer {@link FlexFieldSchema.create} when possible.
-	 */
-	public static createUnsafe<
-		TKind extends FlexFieldKind,
-		const Types extends Unenforced<FlexAllowedTypes>,
-	>(kind: TKind, allowedTypes: Types): FlexFieldSchema<TKind, Types> {
+		allowedTypes: FlexAllowedTypes,
+	): FlexFieldSchema<TKind> {
 		return new FlexFieldSchema(kind, allowedTypes);
 	}
 
@@ -344,14 +260,12 @@ export class FlexFieldSchema<
 	 */
 	private constructor(
 		public readonly kind: TKind,
-		public readonly allowedTypes: TTypes,
+		public readonly allowedTypes: FlexAllowedTypes,
 	) {
 		// Since this class can't have the desired extends clause, do some extra runtime validation:
 		assert(Array.isArray(allowedTypes), 0x7bc /* Invalid allowedTypes */);
 		for (const allowedType of allowedTypes) {
-			if (allowedType === Any) {
-				assert(allowedTypes.length === 1, 0x7bd /* Invalid Any in allowedTypes */);
-			} else if (typeof allowedType !== "function") {
+			if (typeof allowedType !== "function") {
 				assert(
 					allowedType instanceof TreeNodeSchemaBase,
 					0x7be /* Invalid entry in allowedTypes */,
@@ -365,7 +279,7 @@ export class FlexFieldSchema<
 			return {
 				names: allowedTypesToTypeSet(input),
 				schema,
-				monomorphicChildType: schema !== Any ? oneFromSet(schema) : undefined,
+				monomorphicChildType: oneFromSet(schema),
 			};
 		});
 
@@ -444,15 +358,12 @@ export class FlexFieldSchema<
  * See {@link TreeTypeSet} for a stored-schema compatible version using the {@link TreeNodeSchemaIdentifier}.
  * See {@link FlexAllowedTypes} for a compile time optimized version.
  */
-export type AllowedTypeSet = Any | ReadonlySet<FlexTreeNodeSchema>;
+export type AllowedTypeSet = ReadonlySet<FlexTreeNodeSchema>;
 
 /**
  * Convert {@link FlexAllowedTypes} to {@link TreeTypeSet}.
  */
 export function allowedTypesSchemaSet(t: FlexAllowedTypes): AllowedTypeSet {
-	if (allowedTypesIsAny(t)) {
-		return Any;
-	}
 	const list: FlexTreeNodeSchema[] = t.map((value: LazyItem<FlexTreeNodeSchema>) => {
 		if (typeof value === "function") {
 			return value();
@@ -467,9 +378,6 @@ export function allowedTypesSchemaSet(t: FlexAllowedTypes): AllowedTypeSet {
  */
 export function allowedTypesToTypeSet(t: FlexAllowedTypes): TreeTypeSet {
 	const list = allowedTypesSchemaSet(t);
-	if (list === Any) {
-		return undefined;
-	}
 	const names = Array.from(list, (type) => {
 		assert(type instanceof TreeNodeSchemaBase, 0x7bf /* invalid allowed type */);
 		return type.name;

package/src/feature-libraries/typed-schema/view.ts

@@ -19,27 +19,18 @@ import {
 	isNeverTree,
 } from "../modular-schema/index.js";
 
-import {
-	type FlexFieldSchema,
-	type FlexTreeSchema,
-	intoStoredSchema,
-} from "./typedTreeSchema.js";
-
 /**
  * A collection of View information for schema, including policy.
  */
-export class ViewSchema<out TSchema extends FlexFieldSchema = FlexFieldSchema> {
+export class ViewSchema {
 	/**
-	 * Cached conversion of `schema` into a stored schema.
+	 * @param storedSchema - Cached conversion of view schema into a stored schema.
 	 */
-	public readonly storedSchema: TreeStoredSchema;
 	public constructor(
 		public readonly policy: FullSchemaPolicy,
 		public readonly adapters: Adapters,
-		public readonly schema: FlexTreeSchema<TSchema>,
-	) {
-		this.storedSchema = intoStoredSchema(schema);
-	}
+		public readonly storedSchema: TreeStoredSchema,
+	) {}
 
 	/**
 	 * Determines the compatibility of a stored document

package/src/index.ts

@@ -28,6 +28,7 @@ export {
 	ObjectNodeStoredSchema,
 	MapNodeStoredSchema,
 	LeafNodeStoredSchema,
+	type RevertibleFactory,
 } from "./core/index.js";
 export { type Brand } from "./util/index.js";
 
@@ -36,13 +37,6 @@ export {
 	type IsListener,
 	type Listenable,
 	type Off,
-	// Alpha APIs for using event library to implement events externally.
-	// If stabilizing these APIs, they should probably move out of the tree package first.
-	createEmitter,
-	EventEmitter,
-	type IEmitter,
-	type HasListeners,
-	type NoListenersCallback,
 } from "./events/index.js";
 
 export {
@@ -57,7 +51,6 @@ export {
 	type SharedTreeOptions,
 	ForestType,
 	type SharedTreeContentSnapshot,
-	type RevertibleFactory,
 	type SharedTreeFormatOptions,
 	SharedTreeFormatVersion,
 	Tree,
@@ -89,6 +82,7 @@ export {
 	type TreeLeafValue,
 	FieldKind,
 	FieldSchema,
+	type FieldSchemaMetadata,
 	type ImplicitAllowedTypes,
 	type InsertableTreeFieldFromImplicitField,
 	type InsertableTypedNode,
@@ -132,6 +126,9 @@ export {
 	test_RecursiveObject,
 	test_RecursiveObject_base,
 	test_RecursiveObjectPojoMode,
+	// Beta APIs
+	TreeBeta,
+	type TreeChangeEventsBeta,
 	// Back to normal types
 	type JsonTreeSchema,
 	type JsonSchemaId,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.3.0-288113";
+export const pkgVersion = "2.4.0-294316";

package/src/shared-tree/checkoutFlexTreeView.ts

@@ -0,0 +1,89 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import {
+	type Context,
+	type FlexTreeField,
+	type FlexTreeSchema,
+	type NodeKeyManager,
+	getTreeContext,
+	type FlexTreeHydratedContext,
+} from "../feature-libraries/index.js";
+import { tryDisposeTreeNode } from "../simple-tree/index.js";
+import { disposeSymbol } from "../util/index.js";
+
+import type { ITreeCheckout, ITreeCheckoutFork } from "./treeCheckout.js";
+
+/**
+ * An editable view of a (version control style) branch of a shared tree.
+ */
+export class CheckoutFlexTreeView<out TCheckout extends ITreeCheckout = ITreeCheckout> {
+	/**
+	 * Context for controlling the FlexTree nodes produced from {@link FlexTreeView.flexTree}.
+	 *
+	 * @remarks
+	 * This is an owning reference: disposing of this view disposes its context.
+	 */
+	public readonly context: Context;
+
+	/**
+	 * Get a typed view of the tree content using the flex-tree API.
+	 */
+	public readonly flexTree: FlexTreeField;
+
+	public constructor(
+		/**
+		 * Access non-view schema specific aspects of this branch.
+		 *
+		 * @remarks
+		 * This is a non-owning reference: disposing of this view does not impact the branch.
+		 */
+		public readonly checkout: TCheckout,
+		public readonly schema: FlexTreeSchema,
+		public readonly nodeKeyManager: NodeKeyManager,
+		private readonly onDispose?: () => void,
+	) {
+		this.context = getTreeContext(schema, this.checkout, nodeKeyManager);
+		contextToTreeViewMap.set(this.context, this);
+		this.flexTree = this.context.root;
+	}
+
+	public [disposeSymbol](): void {
+		for (const anchorNode of this.checkout.forest.anchors) {
+			tryDisposeTreeNode(anchorNode);
+		}
+
+		this.context[disposeSymbol]();
+		this.onDispose?.();
+	}
+
+	/**
+	 * Spawn a new view which is based off of the current state of this view.
+	 * Any mutations of the new view will not apply to this view until the new view is merged back into this view via `merge()`.
+	 */
+	public fork(): CheckoutFlexTreeView<ITreeCheckout & ITreeCheckoutFork> {
+		const branch = this.checkout.fork();
+		return new CheckoutFlexTreeView(branch, this.schema, this.nodeKeyManager);
+	}
+}
+
+/**
+ * Maps the context of every {@link CheckoutFlexTreeView} to the view.
+ * In practice, this allows the view or checkout to be obtained from a flex node by first getting the context from the flex node and then using this map.
+ */
+const contextToTreeViewMap = new WeakMap<FlexTreeHydratedContext, CheckoutFlexTreeView>();
+
+/**
+ * Retrieve the {@link CheckoutFlexTreeView | view} for the given {@link FlexTreeHydratedContext | context}.
+ * @remarks Every {@link CheckoutFlexTreeView} is associated with its context upon creation.
+ */
+export function getCheckoutFlexTreeView(
+	context: FlexTreeHydratedContext,
+): CheckoutFlexTreeView {
+	const view = contextToTreeViewMap.get(context);
+	assert(view !== undefined, 0xa41 /* Expected view to be registered for context */);
+	return view;
+}

package/src/shared-tree/index.ts

@@ -22,23 +22,18 @@ export {
 	type CheckoutEvents,
 	type ITransaction,
 	type ITreeCheckoutFork,
-	type RevertibleFactory,
 } from "./treeCheckout.js";
 
 export {
 	type SchematizeConfiguration,
 	type TreeContent,
+	type TreeStoredContent,
 	type InitializeAndSchematizeConfiguration,
 	type SchemaConfiguration,
 	buildTreeConfiguration,
 } from "./schematizeTree.js";
 
-export {
-	type FlexTreeView,
-	CheckoutFlexTreeView,
-	type ITreeViewFork,
-	type FlexTreeViewGeneric,
-} from "./treeView.js";
+export { CheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
 
 export type { ISharedTreeEditor, ISchemaEditor } from "./sharedTreeEditBuilder.js";
 

package/src/shared-tree/schematizeTree.ts

@@ -22,7 +22,6 @@ import {
 	allowsRepoSuperset,
 	cursorForMapTreeField,
 	defaultSchemaPolicy,
-	intoStoredSchema,
 	mapTreeFromCursor,
 } from "../feature-libraries/index.js";
 import { fail, isReadonlyArray } from "../util/index.js";
@@ -46,7 +45,7 @@ export function initializeContent(
 		storedSchema: ITreeCheckout["storedSchema"];
 		updateSchema: ITreeCheckout["updateSchema"];
 	},
-	newSchema: FlexTreeSchema,
+	newSchema: TreeStoredSchema,
 	setInitialTree: () => void,
 ): void {
 	assert(
@@ -54,8 +53,7 @@ export function initializeContent(
 		0x743 /* cannot initialize after a schema is set */,
 	);
 
-	const schema = intoStoredSchema(newSchema);
-	const rootSchema = schema.rootFieldSchema;
+	const rootSchema = newSchema.rootFieldSchema;
 	const rootKind = rootSchema.kind;
 
 	// To keep the data in schema during the update, first define a schema that tolerates the current (empty) tree as well as the final (initial) tree.
@@ -65,12 +63,12 @@ export function initializeContent(
 		rootKind === FieldKinds.optional.identifier
 	) {
 		// These kinds are known to tolerate empty, so use the schema as is:
-		incrementalSchemaUpdate = schema;
+		incrementalSchemaUpdate = newSchema;
 	} else {
 		assert(rootKind === FieldKinds.required.identifier, 0x5c8 /* Unexpected kind */);
 		// Replace value kind with optional kind in root field schema:
 		incrementalSchemaUpdate = {
-			nodeSchema: schema.nodeSchema,
+			nodeSchema: newSchema.nodeSchema,
 			rootFieldSchema: {
 				kind: FieldKinds.optional.identifier,
 				types: rootSchema.types,
@@ -84,7 +82,7 @@ export function initializeContent(
 	// 	"Incremental Schema update should support the existing empty tree",
 	// );
 	assert(
-		allowsRepoSuperset(defaultSchemaPolicy, schema, incrementalSchemaUpdate),
+		allowsRepoSuperset(defaultSchemaPolicy, newSchema, incrementalSchemaUpdate),
 		0x5c9 /* Incremental Schema during update should be a allow a superset of the final schema */,
 	);
 	// Update to intermediate schema
@@ -93,8 +91,8 @@ export function initializeContent(
 	setInitialTree();
 
 	// If intermediate schema is not final desired schema, update to the final schema:
-	if (incrementalSchemaUpdate !== schema) {
-		schemaRepository.updateSchema(schema);
+	if (incrementalSchemaUpdate !== newSchema) {
+		schemaRepository.updateSchema(newSchema);
 	}
 }
 
@@ -182,7 +180,7 @@ function normalizeNewFieldContent(
  * If the proposed schema (from `treeContent`) is not compatible with the emptry tree, this function handles using an intermediate schema
  * which supports the empty tree as well as the final tree content.
  */
-export function initialize(checkout: ITreeCheckout, treeContent: TreeContent): void {
+export function initialize(checkout: ITreeCheckout, treeContent: TreeStoredContent): void {
 	checkout.transaction.start();
 	try {
 		initializeContent(checkout, treeContent.schema, () => {
@@ -231,7 +229,7 @@ export function ensureSchema(
 	viewSchema: ViewSchema,
 	allowedSchemaModifications: AllowedUpdateType,
 	checkout: ITreeCheckout,
-	treeContent: TreeContent | undefined,
+	treeContent: TreeStoredContent | undefined,
 ): boolean {
 	let possibleModifications = allowedSchemaModifications;
 	if (treeContent === undefined) {
@@ -248,7 +246,7 @@ export function ensureSchema(
 			return false;
 		}
 		case UpdateType.SchemaCompatible: {
-			checkout.updateSchema(intoStoredSchema(viewSchema.schema));
+			checkout.updateSchema(viewSchema.storedSchema);
 			return true;
 		}
 		case UpdateType.Initialize: {
@@ -289,6 +287,19 @@ export interface TreeContent<TRoot extends FlexFieldSchema = FlexFieldSchema>
 	readonly initialTree: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined;
 }
 
+/**
+ * Content that can populate a `SharedTree`.
+ */
+export interface TreeStoredContent {
+	readonly schema: TreeStoredSchema;
+
+	/**
+	 * Default tree content to initialize the tree with iff the tree is uninitialized
+	 * (meaning it does not even have any schema set at all).
+	 */
+	readonly initialTree: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined;
+}
+
 /**
  * Options used to schematize a `SharedTree`.
  */