@fluidframework/tree 2.2.0 → 2.3.0

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -8,10 +8,11 @@ import {
 	type ExclusiveMapTree,
 	type FieldKey,
 	type FieldUpPath,
+	type TreeFieldStoredSchema,
+	type TreeNodeSchemaIdentifier,
 	type TreeValue,
 	anchorSlot,
 } from "../../core/index.js";
-import type { Assume, FlattenKeys } from "../../util/index.js";
 import type {
 	FieldKinds,
 	SequenceFieldEditBuilder,
@@ -19,19 +20,7 @@ import type {
 	OptionalFieldEditBuilder,
 } from "../default-schema/index.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
-import type {
-	Any,
-	FlexAllowedTypes,
-	FlexFieldSchema,
-	FlexList,
-	FlexListToUnion,
-	FlexMapNodeSchema,
-	FlexObjectNodeFields,
-	FlexObjectNodeSchema,
-	FlexTreeNodeSchema,
-	LazyItem,
-	LeafNodeSchema,
-} from "../typed-schema/index.js";
+import type { FlexTreeNodeSchema } from "../typed-schema/index.js";
 
 import type { FlexTreeContext } from "./context.js";
 
@@ -46,7 +35,7 @@ export const flexTreeSlot = anchorSlot<FlexTreeNode>();
  */
 export const flexTreeMarker = Symbol("flexTreeMarker");
 
-export function isFlexTreeEntity(t: unknown): t is FlexTreeEntity {
+function isFlexTreeEntity(t: unknown): t is FlexTreeEntity {
 	return typeof t === "object" && t !== null && flexTreeMarker in t;
 }
 
@@ -75,7 +64,7 @@ export enum FlexTreeEntityKind {
  * Design and document iterator invalidation rules and ordering rules.
  * Providing a custom iterator type with place anchor semantics would be a good approach.
  */
-export interface FlexTreeEntity<out TSchema = unknown> {
+export interface FlexTreeEntity {
 	/**
 	 * Indicates that an object is a specific kind of flex tree FlexTreeEntity.
 	 * This makes it possible to both down cast FlexTreeEntities safely as well as validate if an object is or is not a FlexTreeEntity.
@@ -83,24 +72,9 @@ export interface FlexTreeEntity<out TSchema = unknown> {
 	readonly [flexTreeMarker]: FlexTreeEntityKind;
 
 	/**
-	 * Schema for this entity.
-	 * If well-formed, it must follow this schema.
-	 */
-	readonly schema: TSchema;
-
-	/**
-	 * A common context of a "forest" of FlexTrees.
-	 * @remarks This is `undefined` for unhydrated nodes or fields that have not yet been inserted into the tree.
+	 * A common context of FlexTrees.
 	 */
-	readonly context?: FlexTreeContext;
-
-	/**
-	 * Iterate through all nodes/fields in this field/node.
-	 *
-	 * @remarks
-	 * No mutations to the current view of the shared tree are permitted during iteration.
-	 */
-	boxedIterator(): IterableIterator<FlexTreeEntity>;
+	readonly context: FlexTreeContext;
 }
 
 /**
@@ -125,6 +99,20 @@ export enum TreeStatus {
 
 	/**
 	 * Is created but has not yet been inserted into the tree.
+	 * @remarks
+	 * See also {@link Unhydrated}.
+	 *
+	 * Nodes in the new state have some limitations:
+	 *
+	 * - Events are not currently triggered for changes. Fixes for this are planned.
+	 *
+	 * - Reading identifiers from nodes which were left unspecified (defaulted) when creating the tree will error.
+	 * This is because allocating unique identifiers in a compressible manner requires knowing which tree the nodes will be inserted into.
+	 *
+	 * - Transactions do not work: transactions apply to a single {@link TreeView}, and `New` nodes are not part of one.
+	 *
+	 * - `Tree.shortId` (when the identifier was explicitly specified and thus works at all) will just return the full identifier as a string,
+	 * but might return a compressed form as a number once hydrated.
 	 */
 	New = 3,
 }
@@ -145,7 +133,7 @@ export enum TreeStatus {
  * the schema aware API may be more ergonomic.
  * All editing is actually done via {@link FlexTreeField}s: the nodes are immutable other than that they contain mutable fields.
  */
-export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
+export interface FlexTreeNode extends FlexTreeEntity {
 	readonly [flexTreeMarker]: FlexTreeEntityKind.Node;
 
 	/**
@@ -177,7 +165,7 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	/**
 	 * Type guard for narrowing / down-casting to a specific schema.
 	 */
-	is<TSchema extends FlexTreeNodeSchema>(schema: TSchema): this is FlexTreeTypedNode<TSchema>;
+	is(schema: FlexTreeNodeSchema): boolean;
 
 	boxedIterator(): IterableIterator<FlexTreeField>;
 
@@ -190,6 +178,28 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	 * a separate Anchor (and thus ref count) must be allocated to keep it alive.
 	 */
 	readonly anchorNode: AnchorNode;
+
+	/**
+	 * Returns an iterable of keys for non-empty fields.
+	 *
+	 * @remarks
+	 * All fields under a map implicitly exist, but `keys` will yield only the keys of fields which contain one or more nodes.
+	 *
+	 * No guarantees are made regarding the order of the keys returned.
+	 */
+	keys(): IterableIterator<FieldKey>;
+
+	/**
+	 * Schema for this entity.
+	 * If well-formed, it must follow this schema.
+	 */
+	readonly schema: TreeNodeSchemaIdentifier;
+
+	/**
+	 * Schema for this entity.
+	 * If well-formed, it must follow this schema.
+	 */
+	readonly flexSchema: FlexTreeNodeSchema;
 }
 
 /**
@@ -210,7 +220,7 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
  * All content in the tree is accessible without down-casting, but if the schema is known,
  * the schema aware API may be more ergonomic.
  */
-export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
+export interface FlexTreeField extends FlexTreeEntity {
 	readonly [flexTreeMarker]: FlexTreeEntityKind.Field;
 
 	/**
@@ -233,7 +243,7 @@ export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
 	/**
 	 * Type guard for narrowing / down-casting to a specific schema.
 	 */
-	is<TSchema extends FlexFieldSchema>(schema: TSchema): this is FlexTreeTypedField<TSchema>;
+	is<TKind extends FlexFieldKind>(kind: TKind): this is FlexTreeTypedField<TKind>;
 
 	boxedIterator(): IterableIterator<FlexTreeNode>;
 
@@ -248,277 +258,19 @@ export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
 	 * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.
 	 */
 	boxedAt(index: number): FlexTreeNode | undefined;
-}
-
-// #region Node Kinds
-
-/**
- * A {@link FlexTreeNode} that behaves like a `Map<string, Field>` for a specific `Field` type.
- *
- * @remarks
- * Unlike TypeScript Map type, {@link FlexTreeMapNode.get} always provides a reference to any field looked up, even if it has never been set.
- *
- * This means that, for example, a `MapNode` of {@link FlexTreeSequenceField} fields will return an empty sequence when a previously unused key is looked up,
- * and that sequence can be used to insert new items into the field.
- * Additionally empty fields (those containing no nodes) are not distinguished from fields which do not exist.
- * This differs from JavaScript Maps which have a subtle distinction between storing undefined as a value in the map and deleting an entry from the map.
- */
-export interface FlexTreeMapNode<in out TSchema extends FlexMapNodeSchema>
-	extends FlexTreeNode {
-	readonly schema: TSchema;
-
-	/**
-	 * Get the field for `key`.
-	 * @param key - which map entry to look up.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, so `get` can be called with any key and will always return a field.
-	 * Even if the field is empty, it will still be returned, and can be edited to insert content into the map.
-	 */
-	getBoxed(key: string): FlexTreeTypedField<TSchema["info"]>;
-
-	/**
-	 * Returns an iterable of keys in the map.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, but `keys` will yield only the keys of fields which contain one or more nodes.
-	 *
-	 * No guarantees are made regarding the order of the keys returned.
-	 */
-	keys(): IterableIterator<FieldKey>;
-
-	/**
-	 * Returns an iterable of values in the map.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, but `values` will yield only the fields containing one or more nodes.
-	 *
-	 * No guarantees are made regarding the order of the values returned.
-	 */
-	values(): IterableIterator<FlexTreeUnboxField<TSchema["info"], "notEmpty">>;
-
-	/**
-	 * Returns an iterable of key, value pairs for every entry in the map.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, but `entries` will yield only the entries whose fields contain one or more nodes.
-	 *
-	 * This iteration provided by `entries()` is equivalent to that provided by direct iteration of the {@link FlexTreeMapNode} (a.k.a. `[Symbol.Iterator]()`).
-	 *
-	 * No guarantees are made regarding the order of the entries returned.
-	 */
-	entries(): IterableIterator<[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]>;
 
 	/**
-	 * Executes a provided function once per each key/value pair in the map.
-	 * @param callbackFn - The function to run for each map entry
-	 * @param thisArg - If present, `callbackFn` will be bound to `thisArg`
-	 *
-	 * @privateRemarks
-	 * TODO: This should run over fields in insertion order if we want to match the javascript foreach spec.
-	 */
-	forEach(
-		callbackFn: (
-			value: FlexTreeUnboxField<TSchema["info"], "notEmpty">,
-			key: FieldKey,
-			map: FlexTreeMapNode<TSchema>,
-		) => void,
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		thisArg?: any,
-	): void;
-
-	/**
-	 * Iterate through all fields in the map.
-	 *
-	 * @remarks
-	 * No mutations to the current view of the shared tree are permitted during iteration.
-	 * To iterate over the unboxed values of the map, use `Symbol.Iterator()`.
+	 * Gets the FieldUpPath of a field.
 	 */
-	boxedIterator(): IterableIterator<FlexTreeTypedField<TSchema["info"]>>;
-
-	[Symbol.iterator](): IterableIterator<
-		[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]
-	>;
-}
-
-/**
- * A {@link FlexTreeNode} that behaves like an "object" or "struct", providing properties to access its fields.
- *
- * ObjectNodes consist of a finite collection of fields, each with their own (distinct) key and {@link FlexFieldSchema}.
- *
- * @remarks
- * ObjectNodes require complex typing, and have been split into two parts for implementation purposes.
- * See {@link FlexTreeObjectNodeTyped} for the schema aware extensions to this that provide access to the fields.
- *
- * These "Objects" resemble "Structs" from a wide variety of programming languages
- * (Including Algol 68, C, Go, Rust, C# etc.).
- * ObjectNodes also somewhat resemble JavaScript objects: this analogy is less precise (objects don't have a fixed schema for example),
- * but for consistency with other systems in the JavaScript ecosystem (like JSON) is "ObjectNodes" nodes are named "Objects".
- *
- * Another common name for this abstraction is [record](https://en.wikipedia.org/wiki/Record_(computer_science)).
- * The name "Record" is avoided (in favor of Object) here because it has less precise connotations for most TypeScript developers.
- * For example, TypeScript has a built in `Record` type, but it requires all of the fields to have the same type,
- * putting its semantics half way between this library's "Object" schema and {@link FlexTreeMapNode}.
- */
-export interface FlexTreeObjectNode extends FlexTreeNode {
-	readonly schema: FlexObjectNodeSchema;
-}
-
-/**
- * Leaf holding a value.
- *
- * @remarks
- * Leaves are immutable and have no children.
- * Leaf unboxes its content, so in schema aware APIs which do unboxing, the Leaf itself will be skipped over and its value will be returned directly.
- */
-export interface FlexTreeLeafNode<in out TSchema extends LeafNodeSchema> extends FlexTreeNode {
-	readonly schema: TSchema;
+	getFieldPath(): FieldUpPath;
 
 	/**
-	 * Value stored on this node.
+	 * Schema for this entity.
+	 * If well-formed, it must follow this schema.
 	 */
-	readonly value: TreeValue<TSchema["info"]>;
+	readonly schema: TreeFieldStoredSchema;
 }
 
-/**
- * An {@link FlexTreeObjectNode} with schema aware accessors for its fields.
- *
- * @privateRemarks
- *
- * The corresponding implementation logic for this lives in `LazyTree.ts` under `buildStructClass`.
- * If you change the signature here, you will need to update that logic to match.
- */
-export type FlexTreeObjectNodeTyped<TSchema extends FlexObjectNodeSchema> =
-	FlexObjectNodeSchema extends TSchema
-		? FlexTreeObjectNode
-		: FlexTreeObjectNode & FlexTreeObjectNodeFields<TSchema["info"]>;
-
-/**
- * Properties to access an object node's fields. See {@link FlexTreeObjectNodeTyped}.
- *
- * @privateRemarks
- * TODO: Support custom field keys.
- */
-export type FlexTreeObjectNodeFields<TFields extends FlexObjectNodeFields> =
-	FlexTreeObjectNodeFieldsInner<
-		FlattenKeys<
-			{
-				// When the key does not need to be escaped, map it from the input TFields in a way that doesn't break navigate to declaration
-				[key in keyof TFields as key extends PropertyNameFromFieldKey<key & string>
-					? key
-					: never]: TFields[key];
-			} & {
-				[key in keyof TFields as key extends PropertyNameFromFieldKey<key & string>
-					? never
-					: PropertyNameFromFieldKey<key & string>]: TFields[key];
-			}
-		>
-	>;
-
-/**
- * Properties to access an object node's fields. See {@link FlexTreeObjectNodeTyped}.
- *
- * @privateRemarks
- * TODO: Do we keep assignment operator + "setFoo" methods, or just use methods?
- * Inconsistency in the API experience could confusing for consumers.
- */
-export type FlexTreeObjectNodeFieldsInner<TFields extends FlexObjectNodeFields> = FlattenKeys<
-	{
-		// boxed fields (TODO: maybe remove these when same as non-boxed version?)
-		readonly [key in keyof TFields as `boxed${Capitalize<key & string>}`]: FlexTreeTypedField<
-			TFields[key]
-		>;
-	} & {
-		// Add getter only (make property readonly) when the field is **not** of a kind that has a logical set operation.
-		// If we could map to getters and setters separately, we would preferably do that, but we can't.
-		// See https://github.com/microsoft/TypeScript/issues/43826 for more details on this limitation.
-		readonly [key in keyof TFields as TFields[key]["kind"] extends AssignableFieldKinds
-			? never
-			: key]: FlexTreeUnboxField<TFields[key]>;
-	} & {
-		// Add setter (make property writable) when the field is of a kind that has a logical set operation.
-		// If we could map to getters and setters separately, we would preferably do that, but we can't.
-		// See https://github.com/microsoft/TypeScript/issues/43826 for more details on this limitation.
-		-readonly [key in keyof TFields as TFields[key]["kind"] extends AssignableFieldKinds
-			? key
-			: never]: FlexTreeUnboxField<TFields[key]>;
-	} & {
-		// Setter method (when the field is of a kind that has a logical set operation).
-		readonly [key in keyof TFields as TFields[key]["kind"] extends AssignableFieldKinds
-			? `set${Capitalize<key & string>}`
-			: never]: (content: FlexibleNodeContent) => void;
-	}
->;
-
-/**
- * Reserved object node field property names to avoid collisions with the rest of the object node API.
- */
-export const reservedObjectNodeFieldPropertyNames = [
-	"anchorNode",
-	"constructor",
-	"context",
-	"is",
-	"parentField",
-	"schema",
-	"tryGetField",
-	"type",
-	"value",
-	"boxedIterator",
-	"iterator",
-	"getBoxed",
-] as const;
-
-/**
- * Reserved object node field property names prefixes.
- * These are reserved to avoid collisions with properties derived from field other field names.
- *
- * Field names starting with these must be followed by a lowercase letter, or be escaped.
- */
-export const reservedObjectNodeFieldPropertyNamePrefixes = [
-	"set",
-	"boxed",
-	"field",
-	"Field",
-] as const;
-
-/**
- * {@link reservedObjectNodeFieldPropertyNamePrefixes} as a type union.
- */
-export type ReservedObjectNodeFieldPropertyNames =
-	(typeof reservedObjectNodeFieldPropertyNames)[number];
-
-/**
- * {@link reservedObjectNodeFieldPropertyNamePrefixes} as a type union.
- */
-export type ReservedObjectNodeFieldPropertyNamePrefixes =
-	(typeof reservedObjectNodeFieldPropertyNamePrefixes)[number];
-
-/**
- * Convert an object node's field key into an escaped string usable as a property name.
- *
- * @privateRemarks
- * TODO:
- * Collisions are still possible.
- * For example fields named "foo" and "Foo" would both produce a setter "setFoo".
- * Consider naming schemes to avoid this, ensure that there is a good workaround for these cases.
- * Another approach would be to support custom field names (separate from keys),
- * and do the escaping (if needed) when creating the flex tree schema (both when manually creating them and when doing so automatically):
- * this would enable better intellisense for escaped fields, as well as allow the feature of custom field property names.
- */
-export type PropertyNameFromFieldKey<T extends string> =
-	T extends ReservedObjectNodeFieldPropertyNames
-		? `field${Capitalize<T>}`
-		: T extends `${ReservedObjectNodeFieldPropertyNamePrefixes}${Capitalize<string>}`
-			? `field${Capitalize<T>}`
-			: T;
-
-/**
- * Field kinds that allow value assignment.
- */
-export type AssignableFieldKinds = typeof FieldKinds.optional | typeof FieldKinds.required;
-
-// #endregion
-
 // #region Field Kinds
 
 /**
@@ -531,22 +283,6 @@ export type FlexibleFieldContent = ExclusiveMapTree[];
  */
 export type FlexibleNodeContent = ExclusiveMapTree;
 
-/**
- * Tree for inserting a subsequence of nodes.
- *
- * Used to insert a batch of 0 or more nodes into some location in a {@link FlexTreeSequenceField}.
- */
-export type FlexibleNodeSubSequence = ExclusiveMapTree[];
-
-/**
- * Type to ensures two types overlap in at least one way.
- * It evaluates to the input type if this is true, and never otherwise.
- * Examples:
- * CheckTypesOverlap\<number | boolean, number | object\> = number | boolean
- * CheckTypesOverlap\<number | boolean, string | object\> = never
- */
-export type CheckTypesOverlap<T, TCheck> = [Extract<T, TCheck> extends never ? never : T][0];
-
 /**
  * {@link FlexTreeField} that stores a sequence of children.
  *
@@ -563,8 +299,7 @@ export type CheckTypesOverlap<T, TCheck> = [Extract<T, TCheck> extends never ? n
  * Add anchor API that can actually hold onto locations in a sequence.
  * Currently only nodes can be held onto with anchors, and this does not replicate the behavior implemented for editing.
  */
-export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
-	extends FlexTreeField {
+export interface FlexTreeSequenceField extends FlexTreeField {
 	/**
 	 * Gets a node of this field by its index with unboxing.
 	 * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.
@@ -575,40 +310,25 @@ export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
 	 * @remarks
 	 * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.
 	 */
-	at(index: number): FlexTreeUnboxNodeUnion<TTypes> | undefined;
+	at(index: number): FlexTreeUnknownUnboxed | undefined;
 
 	/**
 	 * {@inheritdoc FlexTreeField.boxedAt}
 	 */
-	boxedAt(index: number): FlexTreeTypedNodeUnion<TTypes> | undefined;
-
-	/**
-	 * Calls the provided callback function on each child of this sequence, and returns an array that contains the results.
-	 * @param callbackfn - A function that accepts the child and its index.
-	 */
-	map<U>(callbackfn: (value: FlexTreeUnboxNodeUnion<TTypes>, index: number) => U): U[];
+	boxedAt(index: number): FlexTreeNode | undefined;
 
 	/**
 	 * Calls the provided callback function on each child of this sequence, and returns an array that contains the results.
 	 * @param callbackfn - A function that accepts the child and its index.
 	 */
-	mapBoxed<U>(callbackfn: (value: FlexTreeTypedNodeUnion<TTypes>, index: number) => U): U[];
-
-	readonly length: number;
+	map<U>(callbackfn: (value: FlexTreeUnknownUnboxed, index: number) => U): U[];
 
 	/**
 	 * Get an editor for this sequence.
 	 */
 	readonly editor: SequenceFieldEditBuilder<FlexibleFieldContent>;
 
-	boxedIterator(): IterableIterator<FlexTreeTypedNodeUnion<TTypes>>;
-
-	/**
-	 * Gets the FieldUpPath of a field.
-	 */
-	getFieldPath(): FieldUpPath;
-
-	[Symbol.iterator](): IterableIterator<FlexTreeUnboxNodeUnion<TTypes>>;
+	boxedIterator(): IterableIterator<FlexTreeNode>;
 }
 
 /**
@@ -617,9 +337,8 @@ export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
  * @remarks
  * Unboxes its content, so in schema aware APIs which do unboxing, the RequiredField itself will be skipped over and its content will be returned directly.
  */
-export interface FlexTreeRequiredField<in out TTypes extends FlexAllowedTypes>
-	extends FlexTreeField {
-	get content(): FlexTreeUnboxNodeUnion<TTypes>;
+export interface FlexTreeRequiredField extends FlexTreeField {
+	get content(): FlexTreeUnknownUnboxed;
 
 	readonly editor: ValueFieldEditBuilder<FlexibleNodeContent>;
 }
@@ -637,9 +356,8 @@ export interface FlexTreeRequiredField<in out TTypes extends FlexAllowedTypes>
  * Better centralize the documentation about what kinds of merge semantics are available for field kinds.
  * Maybe link editor?
  */
-export interface FlexTreeOptionalField<in out TTypes extends FlexAllowedTypes>
-	extends FlexTreeField {
-	get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined;
+export interface FlexTreeOptionalField extends FlexTreeField {
+	get content(): FlexTreeUnknownUnboxed | undefined;
 
 	readonly editor: OptionalFieldEditBuilder<FlexibleNodeContent>;
 }
@@ -651,125 +369,18 @@ export interface FlexTreeOptionalField<in out TTypes extends FlexAllowedTypes>
 /**
  * Schema aware specialization of {@link FlexTreeField}.
  */
-export type FlexTreeTypedField<TSchema extends FlexFieldSchema> = FlexTreeTypedFieldInner<
-	TSchema["kind"],
-	TSchema["allowedTypes"]
->;
-
-/**
- * Helper for implementing {@link FlexTreeTypedField}.
- */
-export type FlexTreeTypedFieldInner<
-	Kind extends FlexFieldKind,
-	Types extends FlexAllowedTypes,
-> = Kind extends typeof FieldKinds.sequence
-	? FlexTreeSequenceField<Types>
-	: Kind extends typeof FieldKinds.required
-		? FlexTreeRequiredField<Types>
-		: Kind extends typeof FieldKinds.optional
-			? FlexTreeOptionalField<Types>
-			: FlexTreeField;
-
-/**
- * Schema aware specialization of {@link FlexTreeNode} for a given {@link FlexAllowedTypes}.
- */
-export type FlexTreeTypedNodeUnion<T extends FlexAllowedTypes> =
-	T extends FlexList<FlexTreeNodeSchema>
-		? FlexTreeTypedNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>>
-		: FlexTreeNode;
-
-/**
- * Schema aware specialization of {@link FlexTreeNode} for a given {@link FlexTreeNodeSchema}.
- */
-export type FlexTreeTypedNode<TSchema extends FlexTreeNodeSchema> =
-	TSchema extends LeafNodeSchema
-		? FlexTreeLeafNode<TSchema>
-		: TSchema extends FlexMapNodeSchema
-			? FlexTreeMapNode<TSchema>
-			: TSchema extends FlexObjectNodeSchema
-				? FlexTreeObjectNodeTyped<TSchema>
-				: FlexTreeNode;
+export type FlexTreeTypedField<Kind extends FlexFieldKind> =
+	Kind extends typeof FieldKinds.sequence
+		? FlexTreeSequenceField
+		: Kind extends typeof FieldKinds.required
+			? FlexTreeRequiredField
+			: Kind extends typeof FieldKinds.optional
+				? FlexTreeOptionalField
+				: FlexTreeField;
 
 // #endregion
 
-// #region Unbox
-
-/**
- * Schema aware unboxed field.
- * @remarks
- * Unboxes fields to their content if appropriate for the kind.
- * Recursively unboxes that content (then its content etc.) as well if the node union does unboxing.
- */
-export type FlexTreeUnboxField<
-	TSchema extends FlexFieldSchema,
-	// If "notEmpty", then optional fields will unbox to their content (not their content | undefined)
-	Emptiness extends "maybeEmpty" | "notEmpty" = "maybeEmpty",
-> = FlexTreeUnboxFieldInner<TSchema["kind"], TSchema["allowedTypes"], Emptiness>;
-
-/**
- * Helper for implementing FlexTreeUnboxField.
- */
-export type FlexTreeUnboxFieldInner<
-	Kind extends FlexFieldKind,
-	TTypes extends FlexAllowedTypes,
-	Emptiness extends "maybeEmpty" | "notEmpty",
-> = Kind extends typeof FieldKinds.sequence
-	? FlexTreeSequenceField<TTypes>
-	: Kind extends typeof FieldKinds.required
-		? FlexTreeUnboxNodeUnion<TTypes>
-		: Kind extends typeof FieldKinds.optional
-			? FlexTreeUnboxNodeUnion<TTypes> | (Emptiness extends "notEmpty" ? never : undefined)
-			: // TODO: forbidden
-				unknown;
-
-/**
- * Schema aware unboxed union of tree types.
- * @remarks
- * Unboxes when not polymorphic.
- * Recursively unboxes that content as well if the node kind does unboxing.
- */
-export type FlexTreeUnboxNodeUnion<TTypes extends FlexAllowedTypes> = TTypes extends readonly [
-	LazyItem<infer InnerType>,
-]
-	? InnerType extends FlexTreeNodeSchema
-		? FlexTreeUnboxNode<InnerType>
-		: InnerType extends Any
-			? FlexTreeNode
-			: // This case should not occur. If the result ever ends up unknown, look at places like this to debug.
-				unknown
-	: boolean extends IsArrayOfOne<TTypes>
-		? FlexTreeUnknownUnboxed // Unknown if this will unbox. This should mainly happen when TTypes is AllowedTypes.
-		: FlexTreeTypedNodeUnion<TTypes>; // Known to not be a single type, so known not to unbox.
-
-/**
- * `true` if T is known to be an array of one item.
- * `false` if T is known not to be an array of one item.
- * `boolean` if it is unknown if T is an array of one item or not.
- */
-export type IsArrayOfOne<T extends readonly unknown[]> = T["length"] extends 1
-	? true
-	: 1 extends T["length"]
-		? boolean
-		: false;
-
-/**
- * Schema aware unboxed tree type.
- * @remarks
- * Unboxes if the node kind does unboxing.
- * Recursively unboxes that content as well if it does unboxing.
- */
-export type FlexTreeUnboxNode<TSchema extends FlexTreeNodeSchema> =
-	TSchema extends LeafNodeSchema
-		? TreeValue<TSchema["info"]>
-		: TSchema extends FlexMapNodeSchema
-			? FlexTreeMapNode<TSchema>
-			: TSchema extends FlexObjectNodeSchema
-				? FlexTreeObjectNodeTyped<TSchema>
-				: FlexTreeUnknownUnboxed;
-
 /**
  * Unboxed tree type for unknown schema cases.
  */
 export type FlexTreeUnknownUnboxed = TreeValue | FlexTreeNode;
-
-// #endregion