@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/typed-schema/typeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,SAAS,EAAE,MAAM,SAAS,MAAM,GAAG,MAAM,EAAE,QAAQ,IAAI,WAAW,CACzF,MAAM,EACN,QAAQ,CACR,GAAG;IACH,GAAG,CAAC,IAAI,SAAS,MAAM,SAAS,EAAE,GAAG,EAAE,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;CAC9D,CAAC;AAGF,wBAAgB,gBAAgB,CAC/B,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC1C,MAAM,SAAS,MAAM,EACrB,QAAQ,EACP,SAAS,EAAE,SAAS,GAAG,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,CAEhE;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,MAAM,CAAC,EAAE,GACzF,MAAM,GACN,KAAK,CAAC"}

package/dist/feature-libraries/typed-schema/typeUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToMapTyped = void 0;
+const util_1 = require("../../util");
+// TODO: test + document
+function objectToMapTyped(objectMap) {
+    return (0, util_1.objectToMap)(objectMap);
+}
+exports.objectToMapTyped = objectToMapTyped;
+//# sourceMappingURL=typeUtils.js.map

package/dist/feature-libraries/typed-schema/typeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.js","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/typeUtils.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,qCAAyC;AAgBzC,wBAAwB;AACxB,SAAgB,gBAAgB,CAI9B,SAAoB;IACrB,OAAO,IAAA,kBAAW,EAAC,SAAS,CAAwD,CAAC;AACtF,CAAC;AAND,4CAMC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { objectToMap } from \"../../util\";\n\n/**\n * Utilities for manipulating types.\n */\n\n/**\n * Convert a object type into the type of a ReadonlyMap from field name to value.\n */\nexport type ObjectToMap<ObjectMap, MapKey extends number | string, MapValue> = ReadonlyMap<\n\tMapKey,\n\tMapValue\n> & {\n\tget<TKey extends keyof ObjectMap>(key: TKey): ObjectMap[TKey];\n};\n\n// TODO: test + document\nexport function objectToMapTyped<\n\tObjectMap extends Record<MapKey, MapValue>,\n\tMapKey extends string,\n\tMapValue,\n>(objectMap: ObjectMap): ObjectToMap<ObjectMap, MapKey, MapValue> {\n\treturn objectToMap(objectMap) as unknown as ObjectToMap<ObjectMap, MapKey, MapValue>;\n}\n\n/**\n * Convert a Array type into the type of ReadonlySet.\n *\n * Same as `keyof ListToKeys<T, unknown>` but work for values that are not valid keys.\n * @beta\n */\nexport type ArrayToUnion<T extends readonly unknown[]> = T extends readonly (infer TValue)[]\n\t? TValue\n\t: never;\n"]}

package/dist/feature-libraries/typed-schema/typedTreeSchema.d.ts

@@ -0,0 +1,294 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Adapters, FieldKey, TreeNodeStoredSchema, TreeFieldStoredSchema, TreeNodeSchemaIdentifier, TreeTypeSet, ValueSchema, TreeStoredSchema, StoredSchemaCollection } from "../../core";
+import { MakeNominal, Named, Assume } from "../../util";
+import { FieldKinds } from "../default-schema";
+import { FieldKind, FullSchemaPolicy } from "../modular-schema";
+import { LazyItem } from "./flexList";
+/**
+ * @internal
+ */
+export interface Fields {
+    readonly [key: string]: TreeFieldSchema;
+}
+/**
+ * @internal
+ */
+export type NormalizeObjectNodeFields<T extends Fields> = {
+    readonly [Property in keyof T]: NormalizeField<T[Property]>;
+};
+/**
+ * A placeholder to use in extends constraints when using the real type breaks compilation of some recursive types due to [a design limitation of TypeScript](https://github.com/microsoft/TypeScript/issues/55758).
+ *
+ * These extends constraints only serve as documentation:
+ * to avoid breaking compilation, this type has to not actually enforce anything, and thus is just `unknown`.
+ * Therefore the type safety is the responsibility of the user of the API.
+ * @internal
+ */
+export type Unenforced<_DesiredExtendsConstraint> = unknown;
+/**
+ * T must extend TreeSchemaSpecification.
+ * This can not be enforced using TypeScript since doing so breaks recursive type support.
+ * See note on SchemaBuilder.fieldRecursive.
+ * @internal
+ */
+export declare abstract class TreeNodeSchemaBase<const out Name extends string = string, const out Specification = unknown> {
+    readonly builder: Named<string>;
+    readonly name: TreeNodeSchemaIdentifier<Name>;
+    readonly info: Specification;
+    readonly stored: TreeNodeStoredSchema;
+    protected _typeCheck?: MakeNominal;
+    protected constructor(builder: Named<string>, name: TreeNodeSchemaIdentifier<Name>, info: Specification, stored: TreeNodeStoredSchema);
+    abstract getFieldSchema(field: FieldKey): TreeFieldSchema;
+}
+/**
+ * @internal
+ */
+export declare class MapNodeSchema<const out Name extends string = string, const out Specification extends Unenforced<MapFieldSchema> = MapFieldSchema> extends TreeNodeSchemaBase<Name, Specification> {
+    get mapFields(): MapFieldSchema;
+    protected _typeCheck2?: MakeNominal;
+    static create<const Name extends string, const Specification extends MapFieldSchema>(builder: Named<string>, name: TreeNodeSchemaIdentifier<Name>, specification: Specification): MapNodeSchema<Name, Specification>;
+    getFieldSchema(field: FieldKey): MapFieldSchema;
+}
+/**
+ * @internal
+ */
+export declare class LeafNodeSchema<const out Name extends string = string, const out Specification extends Unenforced<ValueSchema> = ValueSchema> extends TreeNodeSchemaBase<Name, Specification> {
+    get leafValue(): ValueSchema;
+    protected _typeCheck2?: MakeNominal;
+    static create<const Name extends string, const Specification extends ValueSchema>(builder: Named<string>, name: TreeNodeSchemaIdentifier<Name>, specification: Specification): LeafNodeSchema<Name, Specification>;
+    getFieldSchema(field: FieldKey): TreeFieldSchema;
+}
+/**
+ * @internal
+ */
+export declare class ObjectNodeSchema<const out Name extends string = string, const out Specification extends Unenforced<Fields> = Fields> extends TreeNodeSchemaBase<Name, Specification> {
+    readonly objectNodeFieldsObject: NormalizeObjectNodeFields<Assume<Specification, Fields>>;
+    readonly objectNodeFields: ReadonlyMap<FieldKey, TreeFieldSchema>;
+    protected _typeCheck2?: MakeNominal;
+    static create<const Name extends string, const Specification extends Fields>(builder: Named<string>, name: TreeNodeSchemaIdentifier<Name>, specification: Specification): ObjectNodeSchema<Name, Specification>;
+    private constructor();
+    getFieldSchema(field: FieldKey): TreeFieldSchema;
+}
+/**
+ * TODO: replace (or subclass) this with more specific types, like "List".
+ * @internal
+ */
+export declare class FieldNodeSchema<Name extends string = string, Specification extends Unenforced<TreeFieldSchema> = TreeFieldSchema> extends TreeNodeSchemaBase<Name, Specification> {
+    protected _typeCheck2?: MakeNominal;
+    static create<const Name extends string, const Specification extends TreeFieldSchema>(builder: Named<string>, name: TreeNodeSchemaIdentifier<Name>, specification: Specification): FieldNodeSchema<Name, Specification>;
+    private constructor();
+    getFieldSchema(field?: FieldKey): TreeFieldSchema;
+}
+/**
+ * @internal
+ * @privateRemarks
+ * This could be an exhaustive union, or just the common base type.
+ * Using just the base type prevents exhaustive matching, which has both pros and cons.
+ *
+ * For now this is using just the base type since the union is causing issues with schema aware typing, likely due to it being a union and thus distributing over extends clauses.
+ */
+export type TreeNodeSchema = TreeNodeSchemaBase;
+/**
+ * Convert FieldSchemaSpecification | undefined into TreeFieldSchema.
+ * @internal
+ */
+export type NormalizeField<T extends TreeFieldSchema | undefined> = T extends TreeFieldSchema ? T : TreeFieldSchema<typeof FieldKinds.forbidden, []>;
+/**
+ * Allow any node (as long as it meets the schema for its own type).
+ * @internal
+ */
+export declare const Any: "Any";
+/**
+ * Allow any node (as long as it meets the schema for its own type).
+ * @internal
+ */
+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.
+ * @internal
+ */
+export type LazyTreeNodeSchema = TreeNodeSchema | (() => TreeNodeSchema);
+/**
+ * Types for use in fields.
+ *
+ * "Any" is boxed in an array to allow use as variadic parameter.
+ * @internal
+ */
+export type AllowedTypes = readonly [Any] | readonly LazyItem<TreeNodeSchema>[];
+/**
+ * Checks if an {@link AllowedTypes} is {@link (Any:type)}.
+ * @internal
+ */
+export declare function allowedTypesIsAny(t: AllowedTypes): t is readonly [Any];
+/**
+ * Subset of TreeFieldSchema thats legal in maps.
+ * This requires empty to be a valid value for the map.
+ * @internal
+ */
+export type MapFieldSchema = TreeFieldSchema<typeof FieldKinds.optional | typeof FieldKinds.sequence>;
+/**
+ * All policy for a specific field,
+ * including functionality that does not have to be kept consistent across versions or deterministic.
+ *
+ * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
+ *
+ * @remarks
+ * `Types` here must extend `AllowedTypes`, but this cannot be enforced with an "extends" clause: see {@link Unenforced} for details.
+ *
+ * @typeParam TKind - The kind of field.
+ * @typeParam TTypes - The types allowed by the field.
+ *
+ * @sealed
+ * @internal
+ */
+export declare class TreeFieldSchema<out TKind extends FieldKind = FieldKind, const out TTypes extends Unenforced<AllowedTypes> = AllowedTypes> implements TreeFieldStoredSchema {
+    readonly kind: TKind;
+    readonly allowedTypes: TTypes;
+    /**
+     * Schema for a field which must always be empty.
+     */
+    static readonly empty: TreeFieldSchema<import("../default-schema").Forbidden, readonly []>;
+    /**
+     * Constructs a TreeFieldSchema.
+     * @privateRemarks
+     * Alias for the constructor, but with extends clause for the `Types` parameter that {@link TreeFieldSchema} can not have (due to recursive type issues).
+     */
+    static create<TKind extends FieldKind, const Types extends AllowedTypes>(kind: TKind, allowedTypes: Types): TreeFieldSchema<TKind, Types>;
+    /**
+     * 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 TreeFieldSchema.create} when possible.
+     */
+    static createUnsafe<TKind extends FieldKind, const Types extends Unenforced<AllowedTypes>>(kind: TKind, allowedTypes: Types): TreeFieldSchema<TKind, Types>;
+    protected _typeCheck?: MakeNominal;
+    /**
+     * This is computed lazily since types can be recursive, which makes evaluating this have to happen after all the schema are defined.
+     */
+    private readonly lazyTypes;
+    /**
+     * @param kind - The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind} of this field.
+     * Determine the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     * @param allowedTypes - What types of tree nodes are allowed in this field.
+     */
+    private constructor();
+    /**
+     * Types which are allowed in this field (by {@link TreeNodeSchemaIdentifier}), in a format optimized for stored schema.
+     * This is the same set of types in {@link TreeFieldSchema.allowedTypes}, just in a different format.
+     */
+    get types(): TreeTypeSet;
+    /**
+     * Types which are allowed in this field.
+     * This is the same set of types in {@link TreeFieldSchema.allowedTypes}, just as a set with laziness removed.
+     * @privateRemarks
+     * TODO:
+     * 3 ways to access the allowed types are now exposed.
+     * Reducing this and/or renaming the more friendly options to take the shorter name (`types`)
+     * would be a good idea.
+     */
+    get allowedTypeSet(): AllowedTypeSet;
+    /**
+     * If exactly one type of child is allowed in this field, it is provided here.
+     * @remarks
+     * Some code paths (like unboxing and compressed tree encoding) special case schema with exactly one allowed type.
+     * This field allows for simple and optimized handling of this case.
+     */
+    get monomorphicChildType(): TreeNodeSchema | undefined;
+    /**
+     * Compare this schema to another.
+     *
+     * @returns true iff the schema are identical.
+     */
+    equals(other: TreeFieldSchema): boolean;
+}
+/**
+ * Types for use in fields.
+ * This representation is optimized for runtime use in view-schema.
+ *
+ * @remarks
+ * See {@link TreeTypeSet} for a stored-schema compatible version using the {@link TreeNodeSchemaIdentifier}.
+ * See {@link AllowedTypes} for a compile time optimized version.
+ * @internal
+ */
+export type AllowedTypeSet = Any | ReadonlySet<TreeNodeSchema>;
+/**
+ * Convert {@link AllowedTypes} to {@link TreeTypeSet}.
+ * @internal
+ */
+export declare function allowedTypesSchemaSet(t: AllowedTypes): AllowedTypeSet;
+/**
+ * Convert {@link AllowedTypes} to {@link TreeTypeSet}.
+ * @internal
+ */
+export declare function allowedTypesToTypeSet(t: AllowedTypes): TreeTypeSet;
+/**
+ * Schema data that can be be used to view a document.
+ * Strongly typed over its rootFieldSchema.
+ *
+ * @remarks
+ * The type of the rootFieldSchema is used to implement SchemaAware APIs.
+ * Cases that do not require being compile time schema aware can omit the explicit type for it.
+ *
+ * @internal
+ */
+export interface FlexTreeSchema<out T extends TreeFieldSchema = TreeFieldSchema> extends SchemaCollection {
+    /**
+     * Schema for the root field which contains the whole tree.
+     */
+    readonly rootFieldSchema: T;
+    /**
+     * Extra configuration for how this schema is handled at runtime.
+     */
+    readonly policy: FullSchemaPolicy;
+    /**
+     * Compatibility information how how to interact with content who's stored schema is not directly compatible with this schema.
+     */
+    readonly adapters: Adapters;
+}
+/**
+ * Converts a {@link FlexTreeSchema} into a {@link TreeStoredSchema}.
+ */
+export declare function intoStoredSchema(treeSchema: FlexTreeSchema): TreeStoredSchema;
+/**
+ * Converts a {@link SchemaCollection} into a {@link StoredSchemaCollection}.
+ */
+export declare function intoStoredSchemaCollection(treeSchema: SchemaCollection): StoredSchemaCollection;
+/**
+ * Schema data that can be be used to view a document.
+ * @internal
+ *
+ * @privateRemarks
+ * It is convenient that this can be used as a StoredSchemaCollection with no conversion.
+ * There there isn't a design requirement for this however, so this extends clause can be removed later if needed.
+ */
+export interface SchemaCollection {
+    /**
+     * {@inheritdoc SchemaCollection}
+     */
+    readonly nodeSchema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>;
+}
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link MapNodeSchema}.
+ * @internal
+ */
+export declare function schemaIsMap(schema: TreeNodeSchema): schema is MapNodeSchema;
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link LeafNodeSchema}.
+ * @internal
+ */
+export declare function schemaIsLeaf(schema: TreeNodeSchema): schema is LeafNodeSchema;
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link FieldNodeSchema}.
+ * @internal
+ */
+export declare function schemaIsFieldNode(schema: TreeNodeSchema): schema is FieldNodeSchema;
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link ObjectNodeSchema}.
+ * @internal
+ */
+export declare function schemaIsObjectNode(schema: TreeNodeSchema): schema is ObjectNodeSchema;
+//# sourceMappingURL=typedTreeSchema.d.ts.map

package/dist/feature-libraries/typed-schema/typedTreeSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedTreeSchema.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/typedTreeSchema.ts"],"names":[],"mappings":"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"}

package/dist/feature-libraries/typed-schema/typedTreeSchema.js

@@ -0,0 +1,334 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaIsObjectNode = exports.schemaIsFieldNode = exports.schemaIsLeaf = exports.schemaIsMap = exports.intoStoredSchemaCollection = exports.intoStoredSchema = exports.allowedTypesToTypeSet = exports.allowedTypesSchemaSet = exports.TreeFieldSchema = exports.allowedTypesIsAny = exports.Any = exports.FieldNodeSchema = exports.ObjectNodeSchema = exports.LeafNodeSchema = exports.MapNodeSchema = exports.TreeNodeSchemaBase = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const core_1 = require("../../core");
+const util_1 = require("../../util");
+const default_schema_1 = require("../default-schema");
+const typeUtils_1 = require("./typeUtils");
+{
+}
+/**
+ * T must extend TreeSchemaSpecification.
+ * This can not be enforced using TypeScript since doing so breaks recursive type support.
+ * See note on SchemaBuilder.fieldRecursive.
+ * @internal
+ */
+class TreeNodeSchemaBase {
+    constructor(builder, name, info, stored) {
+        this.builder = builder;
+        this.name = name;
+        this.info = info;
+        this.stored = stored;
+    }
+}
+exports.TreeNodeSchemaBase = TreeNodeSchemaBase;
+/**
+ * @internal
+ */
+class MapNodeSchema extends TreeNodeSchemaBase {
+    get mapFields() {
+        return this.info;
+    }
+    static create(builder, name, specification) {
+        return new MapNodeSchema(builder, name, specification, new core_1.MapNodeStoredSchema(specification));
+    }
+    getFieldSchema(field) {
+        return this.info;
+    }
+}
+exports.MapNodeSchema = MapNodeSchema;
+/**
+ * @internal
+ */
+class LeafNodeSchema extends TreeNodeSchemaBase {
+    get leafValue() {
+        return this.info;
+    }
+    static create(builder, name, specification) {
+        return new LeafNodeSchema(builder, name, specification, new core_1.LeafNodeStoredSchema(specification));
+    }
+    getFieldSchema(field) {
+        return TreeFieldSchema.empty;
+    }
+}
+exports.LeafNodeSchema = LeafNodeSchema;
+/**
+ * @internal
+ */
+class ObjectNodeSchema extends TreeNodeSchemaBase {
+    static create(builder, name, specification) {
+        const objectNodeFieldsObject = normalizeStructFields(specification);
+        const objectNodeFields = (0, typeUtils_1.objectToMapTyped)(objectNodeFieldsObject);
+        return new ObjectNodeSchema(builder, name, specification, objectNodeFieldsObject, objectNodeFields);
+    }
+    constructor(builder, name, info, objectNodeFieldsObject, 
+    // Allows reading fields through the normal map.
+    // Stricter typing caused Specification to no longer be covariant, so has been removed.
+    objectNodeFields) {
+        super(builder, name, info, new core_1.ObjectNodeStoredSchema(objectNodeFields));
+        this.objectNodeFieldsObject = objectNodeFieldsObject;
+        this.objectNodeFields = objectNodeFields;
+    }
+    getFieldSchema(field) {
+        return this.objectNodeFields.get(field) ?? TreeFieldSchema.empty;
+    }
+}
+exports.ObjectNodeSchema = ObjectNodeSchema;
+/**
+ * TODO: replace (or subclass) this with more specific types, like "List".
+ * @internal
+ */
+class FieldNodeSchema extends TreeNodeSchemaBase {
+    static create(builder, name, specification) {
+        return new FieldNodeSchema(builder, name, specification);
+    }
+    constructor(builder, name, info) {
+        const objectNodeFields = new Map([[core_1.EmptyKey, info]]);
+        super(builder, name, info, new core_1.ObjectNodeStoredSchema(objectNodeFields));
+    }
+    getFieldSchema(field) {
+        return (field ?? core_1.EmptyKey) === core_1.EmptyKey
+            ? this.info
+            : TreeFieldSchema.empty;
+    }
+}
+exports.FieldNodeSchema = FieldNodeSchema;
+function normalizeStructFields(fields) {
+    const out = {};
+    // eslint-disable-next-line no-restricted-syntax
+    for (const key in fields) {
+        if (Object.prototype.hasOwnProperty.call(fields, key)) {
+            const element = fields[key];
+            out[key] = normalizeField(element);
+        }
+    }
+    return out;
+}
+function normalizeField(t) {
+    if (t === undefined) {
+        return TreeFieldSchema.empty;
+    }
+    (0, core_utils_1.assert)(t instanceof TreeFieldSchema, 0x6ae /* invalid TreeFieldSchema */);
+    return t;
+}
+/**
+ * Allow any node (as long as it meets the schema for its own type).
+ * @internal
+ */
+exports.Any = "Any";
+/**
+ * Checks if an {@link AllowedTypes} is {@link (Any:type)}.
+ * @internal
+ */
+function allowedTypesIsAny(t) {
+    return t.length === 1 && t[0] === exports.Any;
+}
+exports.allowedTypesIsAny = allowedTypesIsAny;
+/**
+ * All policy for a specific field,
+ * including functionality that does not have to be kept consistent across versions or deterministic.
+ *
+ * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
+ *
+ * @remarks
+ * `Types` here must extend `AllowedTypes`, but this cannot be enforced with an "extends" clause: see {@link Unenforced} for details.
+ *
+ * @typeParam TKind - The kind of field.
+ * @typeParam TTypes - The types allowed by the field.
+ *
+ * @sealed
+ * @internal
+ */
+class TreeFieldSchema {
+    /**
+     * Constructs a TreeFieldSchema.
+     * @privateRemarks
+     * Alias for the constructor, but with extends clause for the `Types` parameter that {@link TreeFieldSchema} can not have (due to recursive type issues).
+     */
+    static create(kind, allowedTypes) {
+        return new TreeFieldSchema(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 TreeFieldSchema.create} when possible.
+     */
+    static createUnsafe(kind, allowedTypes) {
+        return new TreeFieldSchema(kind, allowedTypes);
+    }
+    /**
+     * @param kind - The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind} of this field.
+     * Determine the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+     * @param allowedTypes - What types of tree nodes are allowed in this field.
+     */
+    constructor(kind, allowedTypes) {
+        this.kind = kind;
+        this.allowedTypes = allowedTypes;
+        // Since this class can't have the desired extends clause, do some extra runtime validation:
+        (0, core_utils_1.assert)(Array.isArray(allowedTypes), 0x7bc /* Invalid allowedTypes */);
+        for (const allowedType of allowedTypes) {
+            if (allowedType === exports.Any) {
+                (0, core_utils_1.assert)(allowedTypes.length === 1, 0x7bd /* Invalid Any in allowedTypes */);
+            }
+            else if (typeof allowedType !== "function") {
+                (0, core_utils_1.assert)(allowedType instanceof TreeNodeSchemaBase, 0x7be /* Invalid entry in allowedTypes */);
+            }
+        }
+        this.lazyTypes = new core_utils_1.Lazy(() => {
+            const input = this.allowedTypes;
+            const schema = allowedTypesSchemaSet(input);
+            return {
+                names: allowedTypesToTypeSet(input),
+                schema,
+                monomorphicChildType: schema !== exports.Any ? (0, util_1.oneFromSet)(schema) : undefined,
+            };
+        });
+    }
+    /**
+     * Types which are allowed in this field (by {@link TreeNodeSchemaIdentifier}), in a format optimized for stored schema.
+     * This is the same set of types in {@link TreeFieldSchema.allowedTypes}, just in a different format.
+     */
+    get types() {
+        return this.lazyTypes.value.names;
+    }
+    /**
+     * Types which are allowed in this field.
+     * This is the same set of types in {@link TreeFieldSchema.allowedTypes}, just as a set with laziness removed.
+     * @privateRemarks
+     * TODO:
+     * 3 ways to access the allowed types are now exposed.
+     * Reducing this and/or renaming the more friendly options to take the shorter name (`types`)
+     * would be a good idea.
+     */
+    get allowedTypeSet() {
+        return this.lazyTypes.value.schema;
+    }
+    /**
+     * If exactly one type of child is allowed in this field, it is provided here.
+     * @remarks
+     * Some code paths (like unboxing and compressed tree encoding) special case schema with exactly one allowed type.
+     * This field allows for simple and optimized handling of this case.
+     */
+    get monomorphicChildType() {
+        return this.lazyTypes.value.monomorphicChildType;
+    }
+    /**
+     * Compare this schema to another.
+     *
+     * @returns true iff the schema are identical.
+     */
+    equals(other) {
+        if (other.kind !== this.kind) {
+            return false;
+        }
+        if (other.types === undefined) {
+            return this.types === undefined;
+        }
+        if (this.types === undefined) {
+            return false;
+        }
+        return (0, util_1.compareSets)({
+            a: this.types,
+            b: other.types,
+            aExtra: () => false,
+            bExtra: () => false,
+        });
+    }
+}
+exports.TreeFieldSchema = TreeFieldSchema;
+/**
+ * Schema for a field which must always be empty.
+ */
+TreeFieldSchema.empty = TreeFieldSchema.create(default_schema_1.FieldKinds.forbidden, []);
+/**
+ * Convert {@link AllowedTypes} to {@link TreeTypeSet}.
+ * @internal
+ */
+function allowedTypesSchemaSet(t) {
+    if (allowedTypesIsAny(t)) {
+        return exports.Any;
+    }
+    const list = t.map((value) => {
+        if (typeof value === "function") {
+            return value();
+        }
+        return value;
+    });
+    return new Set(list);
+}
+exports.allowedTypesSchemaSet = allowedTypesSchemaSet;
+/**
+ * Convert {@link AllowedTypes} to {@link TreeTypeSet}.
+ * @internal
+ */
+function allowedTypesToTypeSet(t) {
+    const list = allowedTypesSchemaSet(t);
+    if (list === exports.Any) {
+        return undefined;
+    }
+    const names = Array.from(list, (type) => {
+        (0, core_utils_1.assert)(type instanceof TreeNodeSchemaBase, 0x7bf /* invalid allowed type */);
+        return type.name;
+    });
+    return new Set(names);
+}
+exports.allowedTypesToTypeSet = allowedTypesToTypeSet;
+/**
+ * Converts a {@link FlexTreeSchema} into a {@link TreeStoredSchema}.
+ */
+function intoStoredSchema(treeSchema) {
+    return {
+        rootFieldSchema: treeSchema.rootFieldSchema,
+        ...intoStoredSchemaCollection(treeSchema),
+    };
+}
+exports.intoStoredSchema = intoStoredSchema;
+/**
+ * Converts a {@link SchemaCollection} into a {@link StoredSchemaCollection}.
+ */
+function intoStoredSchemaCollection(treeSchema) {
+    return {
+        nodeSchema: new Map((0, util_1.mapIterable)(treeSchema.nodeSchema.entries(), ([k, v]) => [k, v.stored])),
+    };
+}
+exports.intoStoredSchemaCollection = intoStoredSchemaCollection;
+// These schema type narrowing functions are preferred over `instanceof` due to being easier to migrate to class based schema.
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link MapNodeSchema}.
+ * @internal
+ */
+function schemaIsMap(schema) {
+    return schema instanceof MapNodeSchema;
+}
+exports.schemaIsMap = schemaIsMap;
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link LeafNodeSchema}.
+ * @internal
+ */
+function schemaIsLeaf(schema) {
+    return schema instanceof LeafNodeSchema;
+}
+exports.schemaIsLeaf = schemaIsLeaf;
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link FieldNodeSchema}.
+ * @internal
+ */
+function schemaIsFieldNode(schema) {
+    return schema instanceof FieldNodeSchema;
+}
+exports.schemaIsFieldNode = schemaIsFieldNode;
+/**
+ * Checks if a {@link TreeNodeSchema} is a {@link ObjectNodeSchema}.
+ * @internal
+ */
+function schemaIsObjectNode(schema) {
+    return schema instanceof ObjectNodeSchema;
+}
+exports.schemaIsObjectNode = schemaIsObjectNode;
+//# sourceMappingURL=typedTreeSchema.js.map