(tree): remove internal tree types from public export

packages/dds/tree/api-report/tree.api.md

@@ -38,7 +38,7 @@ export type AllowedTypeSet = Any | ReadonlySet<FlexTreeNodeSchema>;
 
 // @internal
 export type AllowedTypesToFlexInsertableTree<T extends FlexAllowedTypes> = [
-T extends readonly LazyItem<FlexTreeNodeSchema>[] ? InsertableFlexNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>> : ContextuallyTypedNodeData
+T extends readonly LazyItem<FlexTreeNodeSchema>[] ? InsertableFlexNode<Assume<InternalFlexListTypes.FlexListToUnion<T>, FlexTreeNodeSchema>> : ContextuallyTypedNodeData
 ][_InlineTrick];
 
 // @internal
@@ -135,7 +135,7 @@ export const Any: "Any";
 export type Any = typeof Any;
 
 // @public
-export type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
+type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
     [FieldKind.Required]: T;
     [FieldKind.Optional]: T | undefined;
     [FieldKind.Identifier]: DefaultsAreOptional extends true ? T | undefined : T;
@@ -441,7 +441,7 @@ export type ExtractFromOpaque<TOpaque extends BrandedType<any, unknown>> = TOpaq
 export function extractFromOpaque<TOpaque extends BrandedType<any, unknown>>(value: TOpaque): ExtractFromOpaque<TOpaque>;
 
 // @public
-export type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result ? Result : Item;
+type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result ? Result : Item;
 
 // @internal (undocumented)
 export function fail(message: string): never;
@@ -593,7 +593,7 @@ export type FlexImplicitFieldSchema = FlexFieldSchema | FlexImplicitAllowedTypes
 export type FlexList<Item = unknown> = readonly LazyItem<Item>[];
 
 // @public
-export type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;
+type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;
 
 // @internal
 export type FlexMapFieldSchema = FlexFieldSchema<typeof FieldKinds.optional | typeof FieldKinds.sequence>;
@@ -839,7 +839,7 @@ export type FlexTreeTypedFieldInner<Kind extends FlexFieldKind, Types extends Fl
 export type FlexTreeTypedNode<TSchema extends FlexTreeNodeSchema> = TSchema extends LeafNodeSchema ? FlexTreeLeafNode<TSchema> : TSchema extends FlexMapNodeSchema ? FlexTreeMapNode<TSchema> : TSchema extends FlexFieldNodeSchema ? FlexTreeFieldNode<TSchema> : TSchema extends FlexObjectNodeSchema ? FlexTreeObjectNodeTyped<TSchema> : FlexTreeNode;
 
 // @internal
-export type FlexTreeTypedNodeUnion<T extends FlexAllowedTypes> = T extends FlexList<FlexTreeNodeSchema> ? FlexTreeTypedNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>> : FlexTreeNode;
+export type FlexTreeTypedNodeUnion<T extends FlexAllowedTypes> = T extends FlexList<FlexTreeNodeSchema> ? FlexTreeTypedNode<Assume<InternalFlexListTypes.FlexListToUnion<T>, FlexTreeNodeSchema>> : FlexTreeNode;
 
 // @internal
 export type FlexTreeUnboxField<TSchema extends FlexFieldSchema, Emptiness extends "maybeEmpty" | "notEmpty" = "maybeEmpty"> = FlexTreeUnboxFieldInner<TSchema["kind"], TSchema["allowedTypes"], Emptiness>;
@@ -1006,10 +1006,10 @@ export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSc
 export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
 
 // @public
-export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
+export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<InternalFlexListTypes.FlexListToUnion<TSchema>> : never;
 
 // @public
-export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
+export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<InternalFlexListTypes.FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
 
 // @public
 export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
@@ -1021,6 +1021,21 @@ export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = Un
     implicitlyConstructable: true;
 } ? NodeBuilderDataUnsafe<T> : never);
 
+declare namespace InternalFlexListTypes {
+    export {
+        FlexListToUnion,
+        ExtractItemType
+    }
+}
+export { InternalFlexListTypes }
+
+declare namespace InternalSimpleTreeTypes {
+    export {
+        ApplyKind
+    }
+}
+export { InternalSimpleTreeTypes }
+
 // @public
 export interface InternalTreeNode extends ErasedType<"@fluidframework/tree.InternalTreeNode"> {
 }
@@ -1938,10 +1953,10 @@ export interface TreeNodeApi {
 }
 
 // @public
-export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
+export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<InternalFlexListTypes.FlexListToUnion<TSchema>> : unknown;
 
 // @public
-export type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
+export type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<InternalFlexListTypes.FlexListToUnion<TSchema>> : unknown;
 
 // @public
 export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;

packages/dds/tree/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -21,11 +21,11 @@ import {
 	FlexFieldNodeSchema,
 	FlexFieldSchema,
 	FlexList,
-	FlexListToUnion,
 	FlexMapNodeSchema,
 	FlexObjectNodeFields,
 	FlexObjectNodeSchema,
 	FlexTreeNodeSchema,
+	InternalFlexListTypes,
 	LazyItem,
 	LeafNodeSchema,
 } from "../typed-schema/index.js";
@@ -1021,7 +1021,7 @@ export type FlexTreeTypedFieldInner<
  */
 export type FlexTreeTypedNodeUnion<T extends FlexAllowedTypes> =
 	T extends FlexList<FlexTreeNodeSchema>
-		? FlexTreeTypedNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>>
+		? FlexTreeTypedNode<Assume<InternalFlexListTypes.FlexListToUnion<T>, FlexTreeNodeSchema>>
 		: FlexTreeNode;
 
 /**

packages/dds/tree/src/feature-libraries/index.ts

@@ -153,15 +153,14 @@ export {
 	FlexMapFieldSchema,
 	SchemaCollection,
 	TreeNodeSchemaBase,
-	FlexListToUnion,
 	LazyItem,
+	InternalFlexListTypes,
 	isLazy,
 	NormalizeObjectNodeFields,
 	NormalizeField as NormalizeFieldSchema,
 	FlexObjectNodeFields,
 	intoStoredSchema,
 	intoStoredSchemaCollection,
-	ExtractItemType,
 	NormalizeLazyItem,
 	FlexList,
 } from "./typed-schema/index.js";

packages/dds/tree/src/feature-libraries/schema-aware/schemaAware.ts

@@ -15,11 +15,11 @@ import {
 	FlexAllowedTypes,
 	FlexFieldNodeSchema,
 	FlexFieldSchema,
-	FlexListToUnion,
 	FlexMapNodeSchema,
 	FlexObjectNodeFields,
 	FlexObjectNodeSchema,
 	FlexTreeNodeSchema,
+	InternalFlexListTypes,
 	LazyItem,
 	LeafNodeSchema,
 } from "../typed-schema/index.js";
@@ -102,7 +102,7 @@ export type ApplyMultiplicity<TMultiplicity extends Multiplicity, TypedChild> =
  */
 export type AllowedTypesToFlexInsertableTree<T extends FlexAllowedTypes> = [
 	T extends readonly LazyItem<FlexTreeNodeSchema>[]
-		? InsertableFlexNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>>
+		? InsertableFlexNode<Assume<InternalFlexListTypes.FlexListToUnion<T>, FlexTreeNodeSchema>>
 		: ContextuallyTypedNodeData,
 ][_InlineTrick];
 

packages/dds/tree/src/feature-libraries/typed-schema/index.ts

@@ -41,12 +41,7 @@ export {
 	schemaLintDefault,
 } from "./schemaCollection.js";
 
-export {
-	FlexList,
-	markEager,
-	FlexListToUnion,
-	LazyItem,
-	isLazy,
-	ExtractItemType,
-	NormalizeLazyItem,
-} from "./flexList.js";
+export { FlexList, markEager, LazyItem, isLazy, NormalizeLazyItem } from "./flexList.js";
+
+import * as InternalFlexListTypes from "./internalTypes.js";
+export { InternalFlexListTypes };

packages/dds/tree/src/feature-libraries/typed-schema/internalTypes.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// Used by public types, but not part of the desired API surface
+
+export { FlexListToUnion, ExtractItemType } from "./flexList.js";

packages/dds/tree/src/index.ts

@@ -225,7 +225,6 @@ export {
 	NormalizeFieldSchema,
 	FlexObjectNodeFields,
 	FlexMapFieldSchema,
-	ExtractItemType,
 	LazyItem,
 	PropertyNameFromFieldKey,
 	ReservedObjectNodeFieldPropertyNames,
@@ -290,13 +289,13 @@ export {
 	type,
 	WithType,
 	AllowedTypes,
-	ApplyKind,
 	FieldKind,
 	FieldSchema,
 	ImplicitAllowedTypes,
 	InsertableObjectFromSchemaRecord,
 	InsertableTreeFieldFromImplicitField,
 	InsertableTypedNode,
+	InternalSimpleTreeTypes,
 	NodeBuilderData,
 	NodeKind,
 	ObjectFromSchemaRecord,
@@ -384,7 +383,7 @@ export {
 	UnbrandedName,
 	EmptyObject,
 	FlexList,
-	FlexListToUnion,
+	InternalFlexListTypes,
 
 	// These field kind types really only need to show up via FieldKinds.name, and not as top level names in the package.
 	// These names also are collision prone.

packages/dds/tree/src/simple-tree/index.ts

@@ -27,7 +27,6 @@ export {
 	type,
 	WithType,
 	AllowedTypes,
-	ApplyKind,
 	FieldKind,
 	FieldSchema,
 	InsertableTreeFieldFromImplicitField,
@@ -37,6 +36,8 @@ export {
 	type FieldProps,
 	normalizeFieldSchema,
 } from "./schemaTypes.js";
+import * as InternalSimpleTreeTypes from "./internalTypes.js";
+export { InternalSimpleTreeTypes };
 export { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
 export { getFlexNode } from "./proxyBinding.js";
 export { treeNodeApi, TreeNodeApi, TreeChangeEvents } from "./treeNodeApi.js";

packages/dds/tree/src/simple-tree/internalTypes.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// Used by public types, but not part of the desired API surface
+
+export { ApplyKind } from "./schemaTypes.js";

packages/dds/tree/src/simple-tree/schemaTypes.ts

@@ -7,7 +7,12 @@ import { ErasedType, IFluidHandle } from "@fluidframework/core-interfaces";
 import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { FlexListToUnion, LazyItem, NodeKeyManager, isLazy } from "../feature-libraries/index.js";
+import {
+	InternalFlexListTypes,
+	LazyItem,
+	NodeKeyManager,
+	isLazy,
+} from "../feature-libraries/index.js";
 import { MakeNominal, brand, isReadonlyArray } from "../util/index.js";
 import { InternalTreeNode, Unhydrated } from "./types.js";
 import { FieldKey } from "../core/index.js";
@@ -442,7 +447,7 @@ export type TreeNodeFromImplicitAllowedTypes<
 > = TSchema extends TreeNodeSchema
 	? NodeFromSchema<TSchema>
 	: TSchema extends AllowedTypes
-	? NodeFromSchema<FlexListToUnion<TSchema>>
+	? NodeFromSchema<InternalFlexListTypes.FlexListToUnion<TSchema>>
 	: unknown;
 
 /**
@@ -454,7 +459,7 @@ export type InsertableTreeNodeFromImplicitAllowedTypes<
 > = TSchema extends TreeNodeSchema
 	? InsertableTypedNode<TSchema>
 	: TSchema extends AllowedTypes
-	? InsertableTypedNode<FlexListToUnion<TSchema>>
+	? InsertableTypedNode<InternalFlexListTypes.FlexListToUnion<TSchema>>
 	: never;
 
 /**

packages/dds/tree/src/simple-tree/typesUnsafe.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { FlexListToUnion, Unenforced } from "../feature-libraries/index.js";
+import { InternalFlexListTypes, Unenforced } from "../feature-libraries/index.js";
 import { RestrictiveReadonlyRecord } from "../util/index.js";
 
 import {
@@ -75,7 +75,7 @@ export type TreeNodeFromImplicitAllowedTypesUnsafe<
 	: TSchema extends TreeNodeSchema
 	? NodeFromSchema<TSchema>
 	: TSchema extends AllowedTypes
-	? NodeFromSchema<FlexListToUnion<TSchema>>
+	? NodeFromSchema<InternalFlexListTypes.FlexListToUnion<TSchema>>
 	: unknown;
 
 /**
@@ -85,7 +85,7 @@ export type TreeNodeFromImplicitAllowedTypesUnsafe<
 export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
 > = TSchema extends AllowedTypes
-	? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>>
+	? InsertableTypedNodeUnsafe<InternalFlexListTypes.FlexListToUnion<TSchema>>
 	: InsertableTypedNodeUnsafe<TSchema>;
 
 /**

packages/dds/tree/src/test/simple-tree/schemaFactoryRecursive.spec.ts

@@ -10,11 +10,11 @@ import { strict as assert } from "node:assert";
 import { createIdCompressor } from "@fluidframework/id-compressor/internal";
 import { MockFluidDataStoreRuntime } from "@fluidframework/test-runtime-utils/internal";
 
-import { FlexListToUnion } from "../../feature-libraries/index.js";
+import { InternalFlexListTypes } from "../../feature-libraries/index.js";
 import {
-	ApplyKind,
 	FieldSchema,
 	InsertableTreeNodeFromImplicitAllowedTypes,
+	InternalSimpleTreeTypes,
 	NodeFromSchema,
 	TreeConfiguration,
 	TreeNodeFromImplicitAllowedTypes,
@@ -119,11 +119,15 @@ describe("SchemaFactory Recursive methods", () => {
 
 			type XSchema = typeof ObjectRecursive.info.x;
 			type Field2 = XSchema extends FieldSchema<infer Kind, infer Types>
-				? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false>
+				? InternalSimpleTreeTypes.ApplyKind<
+						TreeNodeFromImplicitAllowedTypes<Types>,
+						Kind,
+						false
+				  >
 				: "zzz";
 			type XTypes = XSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? Types : "Q";
 			type Field3 = TreeNodeFromImplicitAllowedTypes<XTypes>;
-			type Field4 = FlexListToUnion<XTypes>;
+			type Field4 = InternalFlexListTypes.FlexListToUnion<XTypes>;
 			type _check1 = requireTrue<areSafelyAssignable<Field3, ObjectRecursive>>;
 			type _check2 = requireTrue<areSafelyAssignable<Field4, typeof ObjectRecursive>>;