@fluidframework/tree 2.4.0-297027 → 2.4.0-299374

package/src/simple-tree/index.ts

@@ -22,6 +22,7 @@ export {
 	tryDisposeTreeNode,
 	HydratedContext,
 	SimpleContextSlot,
+	getOrCreateInnerNode,
 } from "./core/index.js";
 export {
 	type ITree,
@@ -40,7 +41,6 @@ export {
 	enumFromStrings,
 	singletonSchema,
 	typedObjectValues,
-	type EmptyObject,
 	test_RecursiveObject,
 	test_RecursiveObject_base,
 	test_RecursiveObjectPojoMode,
@@ -67,7 +67,36 @@ export {
 	type JsonLeafSchemaType,
 	getJsonSchema,
 	getSimpleSchema,
+	type VerboseTreeNode,
+	type EncodeOptions,
+	type ParseOptions,
+	type VerboseTree,
+	extractPersistedSchema,
+	comparePersistedSchema,
+	type ConciseTree,
+	comparePersistedSchemaInternal,
 	ViewSchema,
+	type Unenforced,
+	type FieldHasDefaultUnsafe,
+	type ObjectFromSchemaRecordUnsafe,
+	type TreeObjectNodeUnsafe,
+	type TreeFieldFromImplicitFieldUnsafe,
+	type TreeNodeFromImplicitAllowedTypesUnsafe,
+	type FieldSchemaUnsafe,
+	type InsertableTreeNodeFromImplicitAllowedTypesUnsafe,
+	type TreeArrayNodeUnsafe,
+	type TreeMapNodeUnsafe,
+	type InsertableObjectFromSchemaRecordUnsafe,
+	type InsertableTreeFieldFromImplicitFieldUnsafe,
+	type InsertableTypedNodeUnsafe,
+	type NodeBuilderDataUnsafe,
+	type NodeFromSchemaUnsafe,
+	type ReadonlyMapInlined,
+	type TreeNodeSchemaClassUnsafe,
+	type TreeNodeSchemaUnsafe,
+	type AllowedTypesUnsafe,
+	type TreeNodeSchemaNonClassUnsafe,
+	type TreeViewAlpha,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,
@@ -89,34 +118,19 @@ export {
 	normalizeFieldSchema,
 	type ApplyKind,
 	type FieldSchemaMetadata,
+	type InsertableField,
+	type Insertable,
+	type UnsafeUnknownSchema,
 } from "./schemaTypes.js";
-export { getOrCreateInnerNode } from "./proxyBinding.js";
-export type {
-	FieldHasDefaultUnsafe,
-	ObjectFromSchemaRecordUnsafe,
-	TreeObjectNodeUnsafe,
-	TreeFieldFromImplicitFieldUnsafe,
-	TreeNodeFromImplicitAllowedTypesUnsafe,
-	FieldSchemaUnsafe,
-	InsertableTreeNodeFromImplicitAllowedTypesUnsafe,
-	TreeArrayNodeUnsafe,
-	TreeMapNodeUnsafe,
-	InsertableObjectFromSchemaRecordUnsafe,
-	InsertableTreeFieldFromImplicitFieldUnsafe,
-	InsertableTypedNodeUnsafe,
-	NodeBuilderDataUnsafe,
-	NodeFromSchemaUnsafe,
-	ReadonlyMapInlined,
-} from "./typesUnsafe.js";
 export {
 	getTreeNodeForField,
 	prepareContentForHydration,
 } from "./proxies.js";
-
 export {
 	TreeArrayNode,
 	IterableTreeArrayContent,
 	type TreeArrayNodeBase,
+	type ReadonlyArrayNode,
 } from "./arrayNode.js";
 export {
 	type FieldHasDefault,
@@ -126,7 +140,12 @@ export {
 	setField,
 } from "./objectNode.js";
 export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
-export { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
+export {
+	mapTreeFromNodeData,
+	type InsertableContent,
+	type FactoryContent,
+	type FactoryContentObject,
+} from "./toMapTree.js";
 export { toStoredSchema, getStoredSchema } from "./toFlexSchema.js";
 export {
 	numberSchema,
@@ -135,3 +154,4 @@ export {
 	handleSchema,
 	nullSchema,
 } from "./leafNodeSchema.js";
+export type { LazyItem, FlexList, FlexListToUnion, ExtractItemType } from "./flexList.js";

package/src/simple-tree/mapNode.ts

@@ -11,7 +11,6 @@ import {
 	getSchemaAndPolicy,
 } from "../feature-libraries/index.js";
 import { getTreeNodeForField, prepareContentForHydration } from "./proxies.js";
-import { getOrCreateInnerNode } from "./proxyBinding.js";
 import {
 	createFieldSchema,
 	FieldKind,
@@ -33,6 +32,7 @@ import {
 	typeSchemaSymbol,
 	type Context,
 	UnhydratedFlexTreeNode,
+	getOrCreateInnerNode,
 } from "./core/index.js";
 import {
 	mapTreeFromNodeData,

package/src/simple-tree/objectNode.ts

@@ -16,7 +16,6 @@ import {
 	getSchemaAndPolicy,
 } from "../feature-libraries/index.js";
 import { getTreeNodeForField, prepareContentForHydration } from "./proxies.js";
-import { getOrCreateInnerNode } from "./proxyBinding.js";
 import {
 	type ImplicitFieldSchema,
 	getStoredKey,
@@ -39,6 +38,7 @@ import {
 	type TreeNode,
 	type Context,
 	UnhydratedFlexTreeNode,
+	getOrCreateInnerNode,
 } from "./core/index.js";
 import { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
 import { type RestrictiveStringRecord, fail, type FlattenKeys } from "../util/index.js";

package/src/simple-tree/schemaTypes.ts

@@ -7,21 +7,18 @@ import type { ErasedType, IFluidHandle } from "@fluidframework/core-interfaces";
 import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import {
-	type LazyItem,
-	type NodeKeyManager,
-	isLazy,
-	type FlexListToUnion,
-} from "../feature-libraries/index.js";
+import type { NodeKeyManager } from "../feature-libraries/index.js";
 import { type MakeNominal, brand, isReadonlyArray } from "../util/index.js";
 import type {
 	Unhydrated,
 	NodeKind,
 	TreeNodeSchema,
 	TreeNodeSchemaClass,
+	TreeNode,
 } from "./core/index.js";
 import type { FieldKey } from "../core/index.js";
 import type { InsertableContent } from "./toMapTree.js";
+import { isLazy, type FlexListToUnion, type LazyItem } from "./flexList.js";
 
 /**
  * Returns true if the given schema is a {@link TreeNodeSchemaClass}, or otherwise false if it is a {@link TreeNodeSchemaNonClass}.
@@ -29,7 +26,7 @@ import type { InsertableContent } from "./toMapTree.js";
 export function isTreeNodeSchemaClass<
 	Name extends string,
 	Kind extends NodeKind,
-	TNode,
+	TNode extends TreeNode | TreeLeafValue,
 	TBuild,
 	ImplicitlyConstructable extends boolean,
 	Info,
@@ -385,7 +382,17 @@ export type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;
 export type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;
 
 /**
- * Converts ImplicitFieldSchema to the corresponding tree node's field type.
+ * Converts an `ImplicitFieldSchema` to a property type suitable for reading a field with this that schema.
+ *
+ * @typeparam TSchema - When non-exact schema are provided this errors on the side of returning too general of a type (a conservative union of all possibilities).
+ * This is ideal for "output APIs" - i.e. it converts the schema type to the runtime type that a user will _read_ from the tree.
+ * Examples of such "non-exact" schema include `ImplicitFieldSchema`, `ImplicitAllowedTypes`, and  TypeScript unions of schema types.
+ * @privateRemarks
+ * TODO:
+ * There are two known problematic usages of this type (which produce invalid/unsound results when given non-specific schema):
+ * 1. setters for fields (on object nodes the Tree.view.root).
+ * 2. Indirectly in InsertableTreeFieldFromImplicitField via InsertableTypedNode including NodeFromSchema.
+ * These cases should be mitigated by introducing a way to detect inexact schema and special casing them in these two places.
  * @public
  */
 export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> =
@@ -393,7 +400,7 @@ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = Fie
 		? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false>
 		: TSchema extends ImplicitAllowedTypes
 			? TreeNodeFromImplicitAllowedTypes<TSchema>
-			: unknown;
+			: TreeNode | TreeLeafValue | undefined;
 
 /**
  * Type of content that can be inserted into the tree for a field of the given schema.
@@ -405,7 +412,55 @@ export type InsertableTreeFieldFromImplicitField<
 	? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true>
 	: TSchema extends ImplicitAllowedTypes
 		? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>
-		: unknown;
+		: never;
+
+/**
+ * {@inheritdoc (UnsafeUnknownSchema:type)}
+ * @alpha
+ */
+export const UnsafeUnknownSchema: unique symbol = Symbol("UnsafeUnknownSchema");
+
+/**
+ * A special type which can be provided to some APIs as the schema type parameter when schema cannot easily be provided at compile time and an unsafe (instead of disabled) editing API is desired.
+ * @remarks
+ * When used this means the TypeScript typing should error on the side of completeness (allow all inputs that could be valid).
+ * This introduces the risk that out of schema data could be allowed at compile time, and only error at runtime.
+ *
+ * @privateRemarks
+ * This only applies to APIs which input data which is expected to be in schema, since APIs outputting have easy mechanisms to do so in a type safe way even when the schema is unknown.
+ * In most cases that amounts to returning `TreeNode | TreeLeafValue`.
+ *
+ * This can be contrasted with the default behavior of TypeScript, which is to require the intersection of the possible types for input APIs,
+ * which for unknown schema defining input trees results in the `never` type.
+ *
+ * Any APIs which use this must produce UsageErrors when out of schema data is encountered, and never produce unrecoverable errors,
+ * or silently accept invalid data.
+ * This is currently only type exported from the package: the symbol is just used as a way to get a named type.
+ * @alpha
+ */
+export type UnsafeUnknownSchema = typeof UnsafeUnknownSchema;
+
+/**
+ * Content which could be inserted into a tree.
+ * @remarks
+ * Extended version of {@link InsertableTreeNodeFromImplicitAllowedTypes} that also allows {@link (UnsafeUnknownSchema:type)}.
+ * @alpha
+ */
+export type Insertable<TSchema extends ImplicitAllowedTypes | UnsafeUnknownSchema> =
+	TSchema extends ImplicitAllowedTypes
+		? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>
+		: InsertableContent;
+
+/**
+ * Content which could be inserted into a field within a tree.
+ * @remarks
+ * Extended version of {@link InsertableTreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.
+ * @alpha
+ */
+export type InsertableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> =
+	TSchema extends ImplicitFieldSchema
+		? InsertableTreeFieldFromImplicitField<TSchema>
+		: InsertableContent | undefined;
 
 /**
  * Suitable for output.
@@ -457,6 +512,10 @@ export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<
 /**
  * Data which can be used as a node to be inserted.
  * Either an unhydrated node, or content to build a new node.
+ * @privateRemarks
+ * TODO:
+ * This should behave contravariantly, but it uses NodeFromSchema which behaves covariantly.
+ * This results in unsoundness where when the schema is less specific, more types are allowed instead of less.
  * @public
  */
 export type InsertableTypedNode<T extends TreeNodeSchema> =
@@ -475,7 +534,7 @@ export type InsertableTypedNode<T extends TreeNodeSchema> =
 export type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<
 	string,
 	NodeKind,
-	unknown,
+	TreeNode | TreeLeafValue,
 	infer TBuild
 >
 	? TBuild

package/src/simple-tree/toFlexSchema.ts

@@ -20,9 +20,6 @@ import {
 	type TreeTypeSet,
 } from "../core/index.js";
 import { FieldKinds, type FlexFieldKind } from "../feature-libraries/index.js";
-// TODO: once flex schema is gone, this code can move into simple-tree
-// eslint-disable-next-line import/no-internal-modules
-import { normalizeFlexListEager } from "../feature-libraries/typed-schema/index.js";
 import { brand, fail, isReadonlyArray } from "../util/index.js";
 import { NodeKind, type TreeNodeSchema } from "./core/index.js";
 import {
@@ -34,6 +31,7 @@ import {
 import { walkFieldSchema } from "./walkFieldSchema.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
 import { isObjectNodeSchema } from "./objectNodeTypes.js";
+import { normalizeFlexListEager } from "./flexList.js";
 
 /**
  * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.

package/src/simple-tree/toMapTree.ts

@@ -262,14 +262,14 @@ function mapValueWithFallbacks(
 				// Our serialized data format does not support -0.
 				// Map such input to +0.
 				return 0;
-			} else if (Number.isNaN(value) || !Number.isFinite(value)) {
+			} else if (!Number.isFinite(value)) {
 				// Our serialized data format does not support NaN nor +/-∞.
 				// If the schema supports `null`, fall back to that. Otherwise, throw.
 				// This is intended to match JSON's behavior for such values.
 				if (allowedTypes.has(nullSchema)) {
 					return null;
 				} else {
-					throw new TypeError(`Received unsupported numeric value: ${value}.`);
+					throw new UsageError(`Received unsupported numeric value: ${value}.`);
 				}
 			} else {
 				return value;
@@ -287,7 +287,7 @@ function mapValueWithFallbacks(
 			}
 		}
 		default:
-			throw new TypeError(`Received unsupported leaf value: ${value}.`);
+			throw new UsageError(`Received unsupported leaf value: ${value}.`);
 	}
 }
 
@@ -726,6 +726,7 @@ function tryGetInnerNode(target: unknown): InnerNode | undefined {
  * Content which can be used to build a node.
  * @remarks
  * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
+ * @system @alpha
  */
 export type FactoryContent =
 	| IFluidHandle
@@ -744,12 +745,14 @@ export type FactoryContent =
  * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
  *
  * Supports object and map nodes.
+ * @system @alpha
  */
-type FactoryContentObject = {
+export type FactoryContentObject = {
 	readonly [P in string]?: InsertableContent;
 };
 
 /**
  * Content which can be inserted into a tree.
+ * @system @alpha
  */
 export type InsertableContent = Unhydrated<TreeNode> | FactoryContent;

package/src/simple-tree/treeNodeValid.ts

@@ -18,11 +18,12 @@ import {
 	type Context,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { type FlexTreeNode, isFlexTreeNode, markEager } from "../feature-libraries/index.js";
+import { type FlexTreeNode, isFlexTreeNode } from "../feature-libraries/index.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { fail } from "../util/index.js";
 
 import { getSimpleNodeSchemaFromInnerNode } from "./core/index.js";
+import { markEager } from "./flexList.js";
 
 /**
  * Class which all {@link TreeNode}s must extend.

package/src/treeFactory.ts

@@ -81,6 +81,7 @@ export const SharedTree = configuredSharedTree({});
  * });
  * ```
  * @privateRemarks
+ * This should be legacy, but has to be internal due to limitations of API tagging preventing it from being both alpha and alpha+legacy.
  * TODO:
  * Expose Ajv validator for better error message quality somehow.
  * Maybe as part of a test utils or dev-tool package?

package/src/util/utils.ts

@@ -219,9 +219,10 @@ export function count(iterable: Iterable<unknown>): number {
 
 /**
  * Use for Json compatible data.
- *
- * Note that this does not robustly forbid non json comparable data via type checking,
+ * @remarks
+ * This does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
+ * @alpha
  */
 export type JsonCompatible =
 	| string
@@ -234,16 +235,17 @@ export type JsonCompatible =
 
 /**
  * Use for Json object compatible data.
- *
- * Note that this does not robustly forbid non json comparable data via type checking,
+ * @remarks
+ * This does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
+ * @alpha
  */
 export type JsonCompatibleObject = { [P in string]?: JsonCompatible };
 
 /**
  * Use for readonly view of Json compatible data.
- *
- * Note that this does not robustly forbid non json comparable data via type checking,
+ * @remarks
+ * This does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
  */
 export type JsonCompatibleReadOnly =
@@ -257,8 +259,8 @@ export type JsonCompatibleReadOnly =
 
 /**
  * Use for readonly view of Json compatible data.
- *
- * Note that this does not robustly forbid non json comparable data via type checking,
+ * @remarks
+ * This does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
  */
 export type JsonCompatibleReadOnlyObject = { readonly [P in string]?: JsonCompatibleReadOnly };

package/dist/feature-libraries/flex-tree/unboxed.d.ts

@@ -1,12 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ITreeSubscriptionCursor } from "../../core/index.js";
-import type { Context } from "./context.js";
-import type { FlexTreeUnknownUnboxed } from "./flexTreeTypes.js";
-/**
- * Returns the flex tree node, of the value if it has one.
- */
-export declare function unboxedFlexNode(context: Context, cursor: ITreeSubscriptionCursor): FlexTreeUnknownUnboxed;
-//# sourceMappingURL=unboxed.d.ts.map

package/dist/feature-libraries/flex-tree/unboxed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unboxed.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/unboxed.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAGjE;;GAEG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,uBAAuB,GAC7B,sBAAsB,CAMxB"}

package/dist/feature-libraries/flex-tree/unboxed.js

@@ -1,20 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unboxedFlexNode = void 0;
-const lazyNode_js_1 = require("./lazyNode.js");
-/**
- * Returns the flex tree node, of the value if it has one.
- */
-function unboxedFlexNode(context, cursor) {
-    const value = cursor.value;
-    if (value !== undefined) {
-        return value;
-    }
-    return (0, lazyNode_js_1.makeTree)(context, cursor);
-}
-exports.unboxedFlexNode = unboxedFlexNode;
-//# sourceMappingURL=unboxed.js.map

package/dist/feature-libraries/flex-tree/unboxed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unboxed.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/unboxed.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAMH,+CAAyC;AAEzC;;GAEG;AACH,SAAgB,eAAe,CAC9B,OAAgB,EAChB,MAA+B;IAE/B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC3B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACd,CAAC;IACD,OAAO,IAAA,sBAAQ,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC;AAClC,CAAC;AATD,0CASC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ITreeSubscriptionCursor } from \"../../core/index.js\";\n\nimport type { Context } from \"./context.js\";\nimport type { FlexTreeUnknownUnboxed } from \"./flexTreeTypes.js\";\nimport { makeTree } from \"./lazyNode.js\";\n\n/**\n * Returns the flex tree node, of the value if it has one.\n */\nexport function unboxedFlexNode(\n\tcontext: Context,\n\tcursor: ITreeSubscriptionCursor,\n): FlexTreeUnknownUnboxed {\n\tconst value = cursor.value;\n\tif (value !== undefined) {\n\t\treturn value;\n\t}\n\treturn makeTree(context, cursor);\n}\n"]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"flexList.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/flexList.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,gFAAgF;AAChF,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,MAAM,IAAI,CAErE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CASpC;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,CAAC,IAAI,GAAG,OAAO,IAAI,SAAS,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;AAEjE;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAQ7D;AAED;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,IAAI,GAAG,OAAO,IAAI,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;AAE3D;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,IAAI,SAAS,QAAQ,IAAI,IAAI,SAAS,MAAM,MAAM,MAAM,GACjF,MAAM,GACN,IAAI,CAAC;AAER;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,QAAQ,IAAI,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"flexList.js","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/flexList.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,iDAAiD;AACjD,MAAM,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAU/C,gFAAgF;AAChF,SAAgB,MAAM,CAAO,IAAoB;IAChD,OAAO,OAAO,IAAI,KAAK,UAAU,IAAK,IAA6B,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC;AAC7F,CAAC;AAFD,wBAEC;AAED;;;;;;GAMG;AACH,SAAgB,SAAS,CAAI,CAAI;IAChC,OAAO,MAAM,CAAC,CAAC,CAAC;QACf,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE;YACxC,KAAK,EAAE,IAAI;YACX,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,KAAK;YACjB,QAAQ,EAAE,KAAK;SACf,CAAC;QACH,CAAC,CAAC,CAAC,CAAC;AACN,CAAC;AATD,8BASC;AAcD;;GAEG;AACH,SAAgB,sBAAsB,CAAI,CAAc;IACvD,MAAM,IAAI,GAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAkB,EAAE,EAAE;QAC9C,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACnB,OAAO,KAAK,EAAE,CAAC;QAChB,CAAC;QACD,OAAO,KAAK,CAAC;IACd,CAAC,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AACb,CAAC;AARD,wDAQC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/** A symbol used to identify a `MarkedEager`. */\nconst flexListEager = Symbol(\"FlexList Eager\");\n\n/**\n * An object that has been marked as eager (as opposed to lazy) when used as an item in a `FlexList`.\n * It will be considered to be an eager item in a `FlexList` even if it is a function.\n */\ninterface MarkedEager {\n\t[flexListEager]: true;\n}\n\n/** Returns true iff the given item is a function and is not a `MarkedEager`. */\nexport function isLazy<Item>(item: LazyItem<Item>): item is () => Item {\n\treturn typeof item === \"function\" && (item as Partial<MarkedEager>)[flexListEager] !== true;\n}\n\n/**\n * Mark the given object as an eager item in a `FlexList`.\n * @remarks\n * This only has an effect on function objects that would otherwise be considered to be lazy items in a `FlexList`.\n * @param t - The object to mark as eager.\n * @returns `t`, marked as eager if applicable.\n */\nexport function markEager<T>(t: T): T {\n\treturn isLazy(t)\n\t\t? Object.defineProperty(t, flexListEager, {\n\t\t\t\tvalue: true,\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: false,\n\t\t\t\twritable: false,\n\t\t\t})\n\t\t: t;\n}\n\n/**\n * A flexible way to list values.\n * Each item in the list can either be an \"eager\" **value** or a \"lazy\" **function that returns a value** (the latter allows cyclic references to work).\n * @privateRemarks\n * By default, items that are of type `\"function\"` will be considered lazy and all other items will be considered eager.\n * To force a `\"function\"` item to be treated as an eager item, call `markEager` before putting it in the list.\n * This is necessary e.g. when the eager list items are function types and the lazy items are functions that _return_ function types.\n * `FlexList`s are processed by `normalizeFlexList` and `normalizeFlexListEager`.\n * @system @public\n */\nexport type FlexList<Item = unknown> = readonly LazyItem<Item>[];\n\n/**\n * Given a `FlexList` of eager and lazy items, return an equivalent list where all items are eager.\n */\nexport function normalizeFlexListEager<T>(t: FlexList<T>): T[] {\n\tconst data: T[] = t.map((value: LazyItem<T>) => {\n\t\tif (isLazy(value)) {\n\t\t\treturn value();\n\t\t}\n\t\treturn value;\n\t});\n\treturn data;\n}\n\n/**\n * An \"eager\" or \"lazy\" Item in a `FlexList`.\n * Lazy items are wrapped in a function to allow referring to themselves before they are declared.\n * This makes recursive and co-recursive items possible.\n * @public\n */\nexport type LazyItem<Item = unknown> = Item | (() => Item);\n\n/**\n * Get the `Item` type from a `LazyItem<Item>`.\n * @system @public\n */\nexport type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result\n\t? Result\n\t: Item;\n\n/**\n * Normalize FlexList type to a union.\n * @system @public\n */\nexport type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;\n"]}

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

@@ -1,7 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-export { type Unenforced } from "./typedTreeSchema.js";
-export { type FlexList, markEager, type LazyItem, isLazy, type FlexListToUnion, type ExtractItemType, normalizeFlexListEager, } from "./flexList.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,EACN,KAAK,QAAQ,EACb,SAAS,EACT,KAAK,QAAQ,EACb,MAAM,EACN,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,sBAAsB,GACtB,MAAM,eAAe,CAAC"}

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

@@ -1,12 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeFlexListEager = exports.isLazy = exports.markEager = void 0;
-var flexList_js_1 = require("./flexList.js");
-Object.defineProperty(exports, "markEager", { enumerable: true, get: function () { return flexList_js_1.markEager; } });
-Object.defineProperty(exports, "isLazy", { enumerable: true, get: function () { return flexList_js_1.isLazy; } });
-Object.defineProperty(exports, "normalizeFlexListEager", { enumerable: true, get: function () { return flexList_js_1.normalizeFlexListEager; } });
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAIH,6CAQuB;AANtB,wGAAA,SAAS,OAAA;AAET,qGAAA,MAAM,OAAA;AAGN,qHAAA,sBAAsB,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { type Unenforced } from \"./typedTreeSchema.js\";\n\nexport {\n\ttype FlexList,\n\tmarkEager,\n\ttype LazyItem,\n\tisLazy,\n\ttype FlexListToUnion,\n\ttype ExtractItemType,\n\tnormalizeFlexListEager,\n} from \"./flexList.js\";\n"]}

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

@@ -1,14 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * 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}.
- *
- * 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.
- * @public
- */
-export type Unenforced<_DesiredExtendsConstraint> = unknown;
-//# sourceMappingURL=typedTreeSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"typedTreeSchema.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/typedTreeSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,CAAC,yBAAyB,IAAI,OAAO,CAAC"}

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

@@ -1,7 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=typedTreeSchema.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"typedTreeSchema.js","sourceRoot":"","sources":["../../../src/feature-libraries/typed-schema/typedTreeSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * 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}.\n *\n * These extends constraints only serve as documentation:\n * to avoid breaking compilation, this type has to not actually enforce anything, and thus is just `unknown`.\n * Therefore the type safety is the responsibility of the user of the API.\n * @public\n */\nexport type Unenforced<_DesiredExtendsConstraint> = unknown;\n"]}

package/dist/simple-tree/proxyBinding.d.ts

@@ -1,15 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { InnerNode, TreeNode } from "./core/index.js";
-/**
- * Retrieves the flex node associated with the given target via {@link setInnerNode}.
- * @remarks
- * For {@link Unhydrated} nodes, this returns the MapTreeNode.
- *
- * For hydrated nodes it returns a FlexTreeNode backed by the forest.
- * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
- */
-export declare function getOrCreateInnerNode(treeNode: TreeNode, allowFreed?: boolean): InnerNode;
-//# sourceMappingURL=proxyBinding.d.ts.map

package/dist/simple-tree/proxyBinding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxyBinding.d.ts","sourceRoot":"","sources":["../../src/simple-tree/proxyBinding.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG3D;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,UAAQ,GAAG,SAAS,CAGtF"}

package/dist/simple-tree/proxyBinding.js

@@ -1,22 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrCreateInnerNode = void 0;
-const index_js_1 = require("./core/index.js");
-/**
- * Retrieves the flex node associated with the given target via {@link setInnerNode}.
- * @remarks
- * For {@link Unhydrated} nodes, this returns the MapTreeNode.
- *
- * For hydrated nodes it returns a FlexTreeNode backed by the forest.
- * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
- */
-function getOrCreateInnerNode(treeNode, allowFreed = false) {
-    const kernel = (0, index_js_1.getKernel)(treeNode);
-    return kernel.getOrCreateInnerNode(allowFreed);
-}
-exports.getOrCreateInnerNode = getOrCreateInnerNode;
-//# sourceMappingURL=proxyBinding.js.map

package/dist/simple-tree/proxyBinding.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxyBinding.js","sourceRoot":"","sources":["../../src/simple-tree/proxyBinding.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,8CAA4C;AAE5C;;;;;;;GAOG;AACH,SAAgB,oBAAoB,CAAC,QAAkB,EAAE,UAAU,GAAG,KAAK;IAC1E,MAAM,MAAM,GAAG,IAAA,oBAAS,EAAC,QAAQ,CAAC,CAAC;IACnC,OAAO,MAAM,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;AAChD,CAAC;AAHD,oDAGC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { InnerNode, TreeNode } from \"./core/index.js\";\nimport { getKernel } from \"./core/index.js\";\n\n/**\n * Retrieves the flex node associated with the given target via {@link setInnerNode}.\n * @remarks\n * For {@link Unhydrated} nodes, this returns the MapTreeNode.\n *\n * For hydrated nodes it returns a FlexTreeNode backed by the forest.\n * Note that for \"marinated\" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.\n */\nexport function getOrCreateInnerNode(treeNode: TreeNode, allowFreed = false): InnerNode {\n\tconst kernel = getKernel(treeNode);\n\treturn kernel.getOrCreateInnerNode(allowFreed);\n}\n"]}

package/dist/simple-tree/typesUnsafe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typesUnsafe.d.ts","sourceRoot":"","sources":["../../src/simple-tree/typesUnsafe.ts"],"names":[],"mappings":"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"}

package/dist/simple-tree/typesUnsafe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typesUnsafe.js","sourceRoot":"","sources":["../../src/simple-tree/typesUnsafe.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAuRH,sDAAsD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { FlexListToUnion, Unenforced } from \"../feature-libraries/index.js\";\nimport type { RestrictiveStringRecord, _InlineTrick } from \"../util/index.js\";\n\nimport type {\n\tAllowedTypes,\n\tApplyKind,\n\tFieldKind,\n\tFieldSchema,\n\tImplicitAllowedTypes,\n\tImplicitFieldSchema,\n\tNodeFromSchema,\n\tTreeNodeFromImplicitAllowedTypes,\n} from \"./schemaTypes.js\";\nimport type {\n\tNodeKind,\n\tTreeNodeSchema,\n\tWithType,\n\tTreeNode,\n\tUnhydrated,\n} from \"./core/index.js\";\nimport type { TreeArrayNodeBase, TreeArrayNode } from \"./arrayNode.js\";\n\n/*\n * TODO:\n * Below are a bunch of \"unsafe\" versions of types from \"schemaTypes.ts\".\n * These types duplicate the ones in \"schemaTypes.ts\", except with some of the extends clauses unenforced.\n * This is not great for type safety or maintainability.\n * Eventually it would be great to do at least one of the following:\n * 1. Find a way to avoid needing these entirely, possibly by improving TSC's recursive type support.\n * 2. Deduplicate the safe and unsafe types (possibly by having the safe one call the unsafe ones, or some other trick).\n * 3. Add type tests that check that the two copies of these types produce identical results.\n */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * {@link Unenforced} version of `ObjectFromSchemaRecord`.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type ObjectFromSchemaRecordUnsafe<\n\tT extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>,\n> = {\n\t-readonly [Property in keyof T]: TreeFieldFromImplicitFieldUnsafe<T[Property]>;\n};\n\n/**\n * {@link Unenforced} version of {@link TreeObjectNode}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type TreeObjectNodeUnsafe<\n\tT extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>,\n\tTypeName extends string = string,\n> = TreeNode & ObjectFromSchemaRecordUnsafe<T> & WithType<TypeName, NodeKind.Object>;\n\n/**\n * {@link Unenforced} version of {@link TreeFieldFromImplicitField}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> =\n\tTSchema extends FieldSchemaUnsafe<infer Kind, infer Types>\n\t\t? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false>\n\t\t: TSchema extends ImplicitAllowedTypes\n\t\t\t? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema>\n\t\t\t: unknown;\n\n/**\n * {@link Unenforced} version of {@link TreeNodeFromImplicitAllowedTypes}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type TreeNodeFromImplicitAllowedTypesUnsafe<\n\tTSchema extends Unenforced<ImplicitAllowedTypes>,\n> = TSchema extends ImplicitAllowedTypes\n\t? TreeNodeFromImplicitAllowedTypes<TSchema>\n\t: TSchema extends TreeNodeSchema\n\t\t? NodeFromSchema<TSchema>\n\t\t: TSchema extends AllowedTypes\n\t\t\t? NodeFromSchema<FlexListToUnion<TSchema>>\n\t\t\t: unknown;\n\n/**\n * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<\n\tTSchema extends Unenforced<ImplicitAllowedTypes>,\n> = TSchema extends AllowedTypes\n\t? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>>\n\t: InsertableTypedNodeUnsafe<TSchema>;\n\n/**\n * {@link Unenforced} version of {@link InsertableTypedNode}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [\n\t| Unhydrated<NodeFromSchemaUnsafe<T>>\n\t| (T extends { implicitlyConstructable: true } ? NodeBuilderDataUnsafe<T> : never),\n][_InlineTrick];\n\n/**\n * {@link Unenforced} version of {@link NodeFromSchema}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =\n\tT extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;\n\n/**\n * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =\n\tT extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;\n\n/**\n * {@link Unenforced} version of {@link (TreeArrayNode:interface)}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @sealed @public\n */\nexport interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>>\n\textends TreeArrayNodeBase<\n\t\tTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,\n\t\tInsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,\n\t\tTreeArrayNode\n\t> {}\n\n/**\n * {@link Unenforced} version of {@link TreeMapNode}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @sealed @public\n */\nexport interface TreeMapNodeUnsafe<T extends Unenforced<ImplicitAllowedTypes>>\n\textends ReadonlyMapInlined<string, T>,\n\t\tTreeNode {\n\t/**\n\t * {@inheritdoc TreeMapNode.set}\n\t */\n\tset(\n\t\tkey: string,\n\t\tvalue: InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T> | undefined,\n\t): void;\n\n\t/**\n\t * {@inheritdoc TreeMapNode.delete}\n\t */\n\tdelete(key: string): void;\n}\n\n/**\n * Copy of TypeScript's ReadonlyMap, but with `TreeNodeFromImplicitAllowedTypesUnsafe<T>` inlined into it.\n * Using this instead of ReadonlyMap in TreeMapNodeUnsafe is necessary to make recursive map schema not generate compile errors in the d.ts files when exported.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @privateRemarks\n * This is the same as `ReadonlyMap<K, TreeNodeFromImplicitAllowedTypesUnsafe<T>>` (Checked in test),\n * except that it avoids the above mentioned compile error.\n * Authored by manually inlining ReadonlyMap from from the TypeScript lib which can be found by navigating to the definition of `ReadonlyMap`.\n * @system @sealed @public\n */\nexport interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {\n\t/** Returns an iterable of entries in the map. */\n\t[Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;\n\n\t/**\n\t * Returns an iterable of key, value pairs for every entry in the map.\n\t */\n\tentries(): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;\n\n\t/**\n\t * Returns an iterable of keys in the map\n\t */\n\tkeys(): IterableIterator<K>;\n\n\t/**\n\t * Returns an iterable of values in the map\n\t */\n\tvalues(): IterableIterator<TreeNodeFromImplicitAllowedTypesUnsafe<T>>;\n\n\tforEach(\n\t\tcallbackfn: (\n\t\t\tvalue: TreeNodeFromImplicitAllowedTypesUnsafe<T>,\n\t\t\tkey: K,\n\t\t\tmap: ReadonlyMap<K, TreeNodeFromImplicitAllowedTypesUnsafe<T>>,\n\t\t) => void,\n\t\tthisArg?: any,\n\t): void;\n\tget(key: K): TreeNodeFromImplicitAllowedTypesUnsafe<T> | undefined;\n\thas(key: K): boolean;\n\treadonly size: number;\n}\n\n/**\n * {@link Unenforced} version of `FieldHasDefault`.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @sealed @public\n */\nexport type FieldHasDefaultUnsafe<T extends Unenforced<ImplicitFieldSchema>> =\n\tT extends FieldSchemaUnsafe<\n\t\tFieldKind.Optional | FieldKind.Identifier,\n\t\tUnenforced<ImplicitAllowedTypes>\n\t>\n\t\t? true\n\t\t: false;\n\n/**\n * {@link Unenforced} version of `InsertableObjectFromSchemaRecord`.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type InsertableObjectFromSchemaRecordUnsafe<\n\tT extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>,\n> = {\n\t// Field might not have a default, so make it required:\n\treadonly [Property in keyof T as FieldHasDefaultUnsafe<T[Property]> extends false\n\t\t? Property\n\t\t: never]: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property]>;\n} & {\n\t// Field might have a default, so allow optional.\n\t// Note that if the field could be either, this returns boolean, causing both fields to exist, resulting in required.\n\treadonly [Property in keyof T as FieldHasDefaultUnsafe<T[Property]> extends true\n\t\t? Property\n\t\t: never]?: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property]>;\n};\n\n/**\n * {@link Unenforced} version of {@link InsertableTreeFieldFromImplicitField}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @system @public\n */\nexport type InsertableTreeFieldFromImplicitFieldUnsafe<\n\tTSchema extends Unenforced<ImplicitFieldSchema>,\n> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types>\n\t? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true>\n\t: InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;\n\n/**\n * {@link Unenforced} version of {@link FieldSchema}.\n * @remarks\n * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.\n * @public\n */\nexport interface FieldSchemaUnsafe<\n\tout Kind extends FieldKind,\n\tout Types extends Unenforced<ImplicitAllowedTypes>,\n> extends FieldSchema<Kind, any> {\n\t/**\n\t * {@inheritDoc FieldSchema.kind}\n\t */\n\treadonly kind: Kind;\n\t/**\n\t * {@inheritDoc FieldSchema.allowedTypes}\n\t */\n\treadonly allowedTypes: Types;\n\t/**\n\t * {@inheritDoc FieldSchema.allowedTypeSet}\n\t */\n\treadonly allowedTypeSet: ReadonlySet<TreeNodeSchema>;\n}\n\n/* eslint-enable @typescript-eslint/no-explicit-any */\n"]}