fluid-framework 2.0.0-dev-rc.1.0.0.224419 → 2.0.0-dev-rc.1.0.0.225277

package/api-extractor-esm.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../common/build/build-common/api-extractor-base-esm.json"
+}

package/api-report/fluid-framework.api.md

@@ -88,6 +88,7 @@ import { SharedStringSegment } from '@fluidframework/sequence';
 import { StableId } from '@fluidframework/runtime-definitions';
 import type { Static } from '@sinclair/typebox';
 import { SubSequence } from '@fluidframework/sequence';
+import { TreeNode as TreeNode_2 } from '..';
 import { TreeNodeSchema as TreeNodeSchema_2 } from './schemaTypes';
 import { TreeNodeSchemaClass as TreeNodeSchemaClass_2 } from './schemaTypes';
 import type { TSchema } from '@sinclair/typebox';
@@ -1840,18 +1841,18 @@ export interface SchemaEvents {
 // @beta @sealed
 export class SchemaFactory<TScope extends string = string, TName extends number | string = string> {
     constructor(scope: TScope);
-    array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.List<${string}>`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
+    array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.Array<${string}>`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
     array<const Name extends TName, const T extends ImplicitAllowedTypes_2>(name: Name, allowedTypes: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
     readonly boolean: TreeNodeSchema<"com.fluidframework.leaf.boolean", NodeKind.Leaf, boolean, boolean>;
     fixRecursiveReference<T extends AllowedTypes_2>(...types: T): void;
     readonly handle: TreeNodeSchema<"com.fluidframework.leaf.handle", NodeKind.Leaf, IFluidHandle<FluidObject & IFluidLoadable>, IFluidHandle<FluidObject & IFluidLoadable>>;
     map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.Map<${string}>`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>, true>;
     map<Name extends TName, const T extends ImplicitAllowedTypes_2>(name: Name, allowedTypes: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
-    namedArray<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
-    namedMap<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
+    namedArray_internal<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
+    namedMap_internal<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
     readonly null: TreeNodeSchema<"com.fluidframework.leaf.null", NodeKind.Leaf, null, null>;
     readonly number: TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
-    object<const Name extends TName, const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>(name: Name, t: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Object, ObjectFromSchemaRecord<T>, InsertableObjectFromSchemaRecord<T>, true>;
+    object<const Name extends TName, const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>(name: Name, t: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Object, object & TreeNode & ObjectFromSchemaRecord<T>, object & InsertableObjectFromSchemaRecord<T>, true>;
     optional<const T extends ImplicitAllowedTypes_2>(t: T): FieldSchema<FieldKind_2.Optional, T>;
     // (undocumented)
     readonly scope: TScope;
@@ -2021,7 +2022,7 @@ export { SharedStringFactory }
 
 export { SharedStringSegment }
 
-// @internal
+// @beta
 export class SharedTree implements ITree {
     // (undocumented)
     get attributes(): IChannelAttributes;
@@ -2030,7 +2031,7 @@ export class SharedTree implements ITree {
     // (undocumented)
     getAttachSummary(fullTree?: boolean | undefined, trackState?: boolean | undefined, telemetryContext?: ITelemetryContext | undefined): ISummaryTreeWithStats;
     // (undocumented)
-    static getFactory(): TreeFactory;
+    static getFactory(): IChannelFactory;
     // (undocumented)
     getGCData(fullGC?: boolean | undefined): IGarbageCollectionData;
     // (undocumented)
@@ -2109,10 +2110,10 @@ export class test_RecursiveObject extends test_RecursiveObject_base {
 }
 
 // @internal
-export const test_RecursiveObject_base: TreeNodeSchemaClass_2<"Test Recursive Domain.testObject", NodeKind.Object, ObjectFromSchemaRecord_2<    {
+export const test_RecursiveObject_base: TreeNodeSchemaClass_2<"Test Recursive Domain.testObject", NodeKind.Object, object & TreeNode_2 & ObjectFromSchemaRecord_2<    {
 readonly recursive: FieldSchema_2<FieldKind_3.Optional, readonly [() => typeof test_RecursiveObject]>;
 readonly number: TreeNodeSchema_2<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
-}>, InsertableObjectFromSchemaRecord_2<    {
+}>, object & InsertableObjectFromSchemaRecord_2<    {
 readonly recursive: FieldSchema_2<FieldKind_3.Optional, readonly [() => typeof test_RecursiveObject]>;
 readonly number: TreeNodeSchema_2<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
 }>, true>;
@@ -2145,7 +2146,7 @@ export interface TreeApi {
 }
 
 // @beta
-export interface TreeArrayNode<T extends ImplicitAllowedTypes_2 = ImplicitAllowedTypes_2> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<T>, InsertableTreeNodeFromImplicitAllowedTypes<T>, TreeArrayNode> {
+export interface TreeArrayNode<T extends ImplicitAllowedTypes_2 = ImplicitAllowedTypes_2> extends TreeNode, TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<T>, InsertableTreeNodeFromImplicitAllowedTypes<T>, TreeArrayNode> {
 }
 
 // @beta
@@ -2154,7 +2155,7 @@ export const TreeArrayNode: {
 };
 
 // @beta
-interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T> {
+interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
     insertAt(index: number, ...value: (TNew | IterableTreeListContent<TNew>)[]): void;
     insertAtEnd(...value: (TNew | IterableTreeListContent<TNew>)[]): void;
     insertAtStart(...value: (TNew | IterableTreeListContent<TNew>)[]): void;
@@ -2269,7 +2270,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes_2> extends TreeMapNo
 }
 
 // @beta
-export interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<string, TOut> {
+export interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<string, TOut>, TreeNode {
     delete(key: string): void;
     set(key: string, value: TIn | undefined): void;
 }
@@ -2282,7 +2283,7 @@ export const enum TreeNavigationResult {
 }
 
 // @beta
-export class TreeNode {
+export abstract class TreeNode {
 }
 
 // @beta

package/dist/fluid-framework-alpha.d.ts

@@ -90,6 +90,7 @@ import { SharedStringSegment } from '@fluidframework/sequence';
 import { StableId } from '@fluidframework/runtime-definitions';
 import type { Static } from '@sinclair/typebox';
 import { SubSequence } from '@fluidframework/sequence';
+import { TreeNode as TreeNode_2 } from '..';
 import { TreeNodeSchema as TreeNodeSchema_2 } from './schemaTypes';
 import { TreeNodeSchemaClass as TreeNodeSchemaClass_2 } from './schemaTypes';
 import type { TSchema } from '@sinclair/typebox';
@@ -1873,7 +1874,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      *
      * @param name - Unique identifier for this schema within this factory's scope.
      */
-    object<const Name extends TName, const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>(name: Name, t: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Object, ObjectFromSchemaRecord<T>, InsertableObjectFromSchemaRecord<T>, true>;
+    object<const Name extends TName, const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>(name: Name, t: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Object, object & TreeNode & ObjectFromSchemaRecord<T>, object & InsertableObjectFromSchemaRecord<T>, true>;
     /**
      * Define a structurally typed {@link TreeNodeSchema} for a {@link TreeMapNodeBase}.
      *
@@ -1895,7 +1896,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      * factory.object("Foo", {myMap: factory.map(factory.number)});
      * ```
      * @privateRemarks
-     * See note on list.
+     * See note on array.
      */
     map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.Map<${string}>`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>, true>;
     /**
@@ -1914,33 +1915,33 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      *
      * @param name - Unique identifier for this schema within this factory's scope.
      *
-     * @remarks See remarks on {@link SchemaFactory.namedArray}.
+     * @remarks See remarks on {@link SchemaFactory.namedArray_internal}.
      */
-    namedMap<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
+    namedMap_internal<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
     /**
      * Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
      *
      * @remarks
-     * The identifier for this List is defined as a function of the provided types.
+     * The identifier for this Array is defined as a function of the provided types.
      * It is still scoped to this SchemaFactory, but multiple calls with the same arguments will return the same schema object, providing somewhat structural typing.
      * This does not support recursive types.
      *
-     * If using these structurally named lists, other types in this schema builder should avoid names of the form `List<${string}>`.
+     * If using these structurally named arrays, other types in this schema builder should avoid names of the form `Array<${string}>`.
      *
      * @example
      * The returned schema should be used as a schema directly:
      * ```typescript
-     * const MyList = factory.list(factory.number);
-     * type MyList = NodeFromSchema<typeof MyList>;
+     * const MyArray = factory.array(factory.number);
+     * type MyArray = NodeFromSchema<typeof MyArray>;
      * ```
      * Or inline:
      * ```typescript
-     * factory.object("Foo", {myList: factory.list(factory.number)});
+     * factory.object("Foo", {myArray: factory.array(factory.number)});
      * ```
      * @privateRemarks
      * The name produced at the type level here is not as specific as it could be, however doing type level sorting and escaping is a real mess.
      * There are cases where not having this full type provided will be less than ideal since TypeScript's structural types.
-     * For example attempts to narrow unions of structural lists by name won't work.
+     * For example attempts to narrow unions of structural arrays by name won't work.
      * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,
      * though there may still be some problematic cases even after that work is done.
      *
@@ -1948,7 +1949,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls o this different subclasses)
      * when working with structural typing.
      */
-    array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.List<${string}>`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
+    array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.Array<${string}>`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
     /**
      * Define (and add to this library) a {@link FieldNodeSchema} for a {@link (TreeArrayNode:interface)}.
      *
@@ -1956,7 +1957,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      *
      * @example
      * ```typescript
-     * class NamedList extends factory.list("name", factory.number) {}
+     * class NamedArray extends factory.array("name", factory.number) {}
      * ```
      */
     array<const Name extends TName, const T extends ImplicitAllowedTypes_2>(name: Name, allowedTypes: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
@@ -1966,16 +1967,16 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      * @param name - Unique identifier for this schema within this factory's scope.
      *
      * @remarks
-     * This is not intended to be used directly, use the overload of `list` which takes a name instead.
+     * This is not intended to be used directly, use the overload of `array` which takes a name instead.
      * This is only public to work around a compiler limitation.
      *
      * @privateRemarks
      * TODO: this should be made private or protected.
      * Doing so breaks due to:
-     * `src/class-tree/schemaFactoryRecursive.ts:42:9 - error TS2310: Type 'List' recursively references itself as a base type.`
+     * `src/class-tree/schemaFactoryRecursive.ts:42:9 - error TS2310: Type 'Array' recursively references itself as a base type.`
      * Once recursive APIs are better sorted out and integrated into this class, switch this back to private.
      */
-    namedArray<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
+    namedArray_internal<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
     /**
      * Make a field optional instead of the default which is required.
      */
@@ -2384,7 +2385,26 @@ export { SharedStringFactory }
 
 export { SharedStringSegment }
 
-/* Excluded from this release type: SharedTree */
+/**
+ * SharedTree is a hierarchical data structure for collaboratively editing JSON-like trees
+ * of objects, arrays, and other data types.
+ *
+ * @beta
+ */
+export declare class SharedTree implements ITree {
+    static getFactory(): IChannelFactory;
+    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TreeFieldFromImplicitField<TRoot>>;
+    private useFactory;
+    get id(): string;
+    get attributes(): IChannelAttributes;
+    get handle(): IFluidHandle;
+    get IFluidLoadable(): IFluidLoadable;
+    getAttachSummary(fullTree?: boolean | undefined, trackState?: boolean | undefined, telemetryContext?: ITelemetryContext | undefined): ISummaryTreeWithStats;
+    summarize(fullTree?: boolean | undefined, trackState?: boolean | undefined, telemetryContext?: ITelemetryContext | undefined, incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined): Promise<ISummaryTreeWithStats>;
+    isAttached(): boolean;
+    connect(services: IChannelServices): void;
+    getGCData(fullGC?: boolean | undefined): IGarbageCollectionData;
+}
 
 /* Excluded from this release type: SharedTreeContentSnapshot */
 
@@ -2471,7 +2491,7 @@ export declare interface TreeApi {
  * A {@link TreeNode} which implements 'readonly T[]' and the list mutation APIs.
  * @beta
  */
-export declare interface TreeArrayNode<T extends ImplicitAllowedTypes_2 = ImplicitAllowedTypes_2> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<T>, InsertableTreeNodeFromImplicitAllowedTypes<T>, TreeArrayNode> {
+export declare interface TreeArrayNode<T extends ImplicitAllowedTypes_2 = ImplicitAllowedTypes_2> extends TreeNode, TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<T>, InsertableTreeNodeFromImplicitAllowedTypes<T>, TreeArrayNode> {
 }
 
 /**
@@ -2496,7 +2516,7 @@ export declare const TreeArrayNode: {
  * A generic List type, used to defined types like {@link (TreeArrayNode:interface)}.
  * @beta
  */
-declare interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T> {
+declare interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
     /**
      * Inserts new item(s) at a specified location.
      * @param index - The index at which to insert `value`.
@@ -2687,7 +2707,7 @@ export declare interface TreeMapNode<T extends ImplicitAllowedTypes_2> extends T
  *
  * @beta
  */
-export declare interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<string, TOut> {
+export declare interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<string, TOut>, TreeNode {
     /**
      * Adds or updates an entry in the map with a specified `key` and a `value`.
      *
@@ -2721,12 +2741,25 @@ export declare interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<s
  * A non-{@link LeafNodeSchema|leaf} SharedTree node. Includes objects, lists, and maps.
  *
  * @remarks
- * Base type which all nodes extend.
+ * Base type which all nodes implement.
+ *
+ * This can be used as a type to indicate/document values which should be tree nodes,
+ * but currently does not provide strong type checking for this.
+ * Additionally runtime use of this class object (for example when used with `instanceof` or subclassed), is not supported:
+ * it may be replaced with an interface or union in the future.
  * @privateRemarks
- * Adding a member which all nodes have, like a type symbol, would produce much strong typing for this.
+ * Adding a member which all nodes have, like a type symbol, would produce much stronger typing for this.
+ * This is only a class to enable stronger typing in a future change,
+ * but other future changes may want to replace it with a branded interface if the runtime oddities related to this are not cleaned up.
+ *
+ * Currently not all node implications include this in their prototype chain (some hide it with a proxy), and thus cause `instanceof` to fail.
+ * This results in the runtime and compile time behavior of `instanceof` differing.
+ * TypeScript 5.3 allows altering the compile time behavior of `instanceof`.
+ * The runtime behavior can be changed by implementing `Symbol.hasInstance`.
+ * One of those approaches could be used to resolve this inconsistency if TreeNode is kept as a class.
  * @beta
  */
-export declare class TreeNode {
+export declare abstract class TreeNode {
 }
 
 /**

package/dist/fluid-framework-beta.d.ts

@@ -90,6 +90,7 @@ import { SharedStringSegment } from '@fluidframework/sequence';
 import { StableId } from '@fluidframework/runtime-definitions';
 import type { Static } from '@sinclair/typebox';
 import { SubSequence } from '@fluidframework/sequence';
+import { TreeNode as TreeNode_2 } from '..';
 import { TreeNodeSchema as TreeNodeSchema_2 } from './schemaTypes';
 import { TreeNodeSchemaClass as TreeNodeSchemaClass_2 } from './schemaTypes';
 import type { TSchema } from '@sinclair/typebox';
@@ -1372,7 +1373,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      *
      * @param name - Unique identifier for this schema within this factory's scope.
      */
-    object<const Name extends TName, const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>(name: Name, t: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Object, ObjectFromSchemaRecord<T>, InsertableObjectFromSchemaRecord<T>, true>;
+    object<const Name extends TName, const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>(name: Name, t: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Object, object & TreeNode & ObjectFromSchemaRecord<T>, object & InsertableObjectFromSchemaRecord<T>, true>;
     /**
      * Define a structurally typed {@link TreeNodeSchema} for a {@link TreeMapNodeBase}.
      *
@@ -1394,7 +1395,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      * factory.object("Foo", {myMap: factory.map(factory.number)});
      * ```
      * @privateRemarks
-     * See note on list.
+     * See note on array.
      */
     map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.Map<${string}>`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>, true>;
     /**
@@ -1413,33 +1414,33 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      *
      * @param name - Unique identifier for this schema within this factory's scope.
      *
-     * @remarks See remarks on {@link SchemaFactory.namedArray}.
+     * @remarks See remarks on {@link SchemaFactory.namedArray_internal}.
      */
-    namedMap<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
+    namedMap_internal<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Map, TreeMapNode<T>, ReadonlyMap<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
     /**
      * Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
      *
      * @remarks
-     * The identifier for this List is defined as a function of the provided types.
+     * The identifier for this Array is defined as a function of the provided types.
      * It is still scoped to this SchemaFactory, but multiple calls with the same arguments will return the same schema object, providing somewhat structural typing.
      * This does not support recursive types.
      *
-     * If using these structurally named lists, other types in this schema builder should avoid names of the form `List<${string}>`.
+     * If using these structurally named arrays, other types in this schema builder should avoid names of the form `Array<${string}>`.
      *
      * @example
      * The returned schema should be used as a schema directly:
      * ```typescript
-     * const MyList = factory.list(factory.number);
-     * type MyList = NodeFromSchema<typeof MyList>;
+     * const MyArray = factory.array(factory.number);
+     * type MyArray = NodeFromSchema<typeof MyArray>;
      * ```
      * Or inline:
      * ```typescript
-     * factory.object("Foo", {myList: factory.list(factory.number)});
+     * factory.object("Foo", {myArray: factory.array(factory.number)});
      * ```
      * @privateRemarks
      * The name produced at the type level here is not as specific as it could be, however doing type level sorting and escaping is a real mess.
      * There are cases where not having this full type provided will be less than ideal since TypeScript's structural types.
-     * For example attempts to narrow unions of structural lists by name won't work.
+     * For example attempts to narrow unions of structural arrays by name won't work.
      * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,
      * though there may still be some problematic cases even after that work is done.
      *
@@ -1447,7 +1448,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls o this different subclasses)
      * when working with structural typing.
      */
-    array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.List<${string}>`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
+    array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<`${TScope}.Array<${string}>`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
     /**
      * Define (and add to this library) a {@link FieldNodeSchema} for a {@link (TreeArrayNode:interface)}.
      *
@@ -1455,7 +1456,7 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      *
      * @example
      * ```typescript
-     * class NamedList extends factory.list("name", factory.number) {}
+     * class NamedArray extends factory.array("name", factory.number) {}
      * ```
      */
     array<const Name extends TName, const T extends ImplicitAllowedTypes_2>(name: Name, allowedTypes: T): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true>;
@@ -1465,16 +1466,16 @@ export declare class SchemaFactory<TScope extends string = string, TName extends
      * @param name - Unique identifier for this schema within this factory's scope.
      *
      * @remarks
-     * This is not intended to be used directly, use the overload of `list` which takes a name instead.
+     * This is not intended to be used directly, use the overload of `array` which takes a name instead.
      * This is only public to work around a compiler limitation.
      *
      * @privateRemarks
      * TODO: this should be made private or protected.
      * Doing so breaks due to:
-     * `src/class-tree/schemaFactoryRecursive.ts:42:9 - error TS2310: Type 'List' recursively references itself as a base type.`
+     * `src/class-tree/schemaFactoryRecursive.ts:42:9 - error TS2310: Type 'Array' recursively references itself as a base type.`
      * Once recursive APIs are better sorted out and integrated into this class, switch this back to private.
      */
-    namedArray<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
+    namedArray_internal<Name extends TName | string, const T extends ImplicitAllowedTypes_2, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<`${TScope}.${Name}`, NodeKind.Array, TreeArrayNode<T>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable>;
     /**
      * Make a field optional instead of the default which is required.
      */
@@ -1681,7 +1682,26 @@ export { SharedObjectClass }
 
 /* Excluded from this release type: SharedStringSegment */
 
-/* Excluded from this release type: SharedTree */
+/**
+ * SharedTree is a hierarchical data structure for collaboratively editing JSON-like trees
+ * of objects, arrays, and other data types.
+ *
+ * @beta
+ */
+export declare class SharedTree implements ITree {
+    static getFactory(): IChannelFactory;
+    schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TreeFieldFromImplicitField<TRoot>>;
+    private useFactory;
+    get id(): string;
+    get attributes(): IChannelAttributes;
+    get handle(): IFluidHandle;
+    get IFluidLoadable(): IFluidLoadable;
+    getAttachSummary(fullTree?: boolean | undefined, trackState?: boolean | undefined, telemetryContext?: ITelemetryContext | undefined): ISummaryTreeWithStats;
+    summarize(fullTree?: boolean | undefined, trackState?: boolean | undefined, telemetryContext?: ITelemetryContext | undefined, incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined): Promise<ISummaryTreeWithStats>;
+    isAttached(): boolean;
+    connect(services: IChannelServices): void;
+    getGCData(fullGC?: boolean | undefined): IGarbageCollectionData;
+}
 
 /* Excluded from this release type: SharedTreeContentSnapshot */
 
@@ -1768,7 +1788,7 @@ export declare interface TreeApi {
  * A {@link TreeNode} which implements 'readonly T[]' and the list mutation APIs.
  * @beta
  */
-export declare interface TreeArrayNode<T extends ImplicitAllowedTypes_2 = ImplicitAllowedTypes_2> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<T>, InsertableTreeNodeFromImplicitAllowedTypes<T>, TreeArrayNode> {
+export declare interface TreeArrayNode<T extends ImplicitAllowedTypes_2 = ImplicitAllowedTypes_2> extends TreeNode, TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<T>, InsertableTreeNodeFromImplicitAllowedTypes<T>, TreeArrayNode> {
 }
 
 /**
@@ -1793,7 +1813,7 @@ export declare const TreeArrayNode: {
  * A generic List type, used to defined types like {@link (TreeArrayNode:interface)}.
  * @beta
  */
-declare interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T> {
+declare interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
     /**
      * Inserts new item(s) at a specified location.
      * @param index - The index at which to insert `value`.
@@ -1984,7 +2004,7 @@ export declare interface TreeMapNode<T extends ImplicitAllowedTypes_2> extends T
  *
  * @beta
  */
-export declare interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<string, TOut> {
+export declare interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<string, TOut>, TreeNode {
     /**
      * Adds or updates an entry in the map with a specified `key` and a `value`.
      *
@@ -2018,12 +2038,25 @@ export declare interface TreeMapNodeBase<TOut, TIn = TOut> extends ReadonlyMap<s
  * A non-{@link LeafNodeSchema|leaf} SharedTree node. Includes objects, lists, and maps.
  *
  * @remarks
- * Base type which all nodes extend.
+ * Base type which all nodes implement.
+ *
+ * This can be used as a type to indicate/document values which should be tree nodes,
+ * but currently does not provide strong type checking for this.
+ * Additionally runtime use of this class object (for example when used with `instanceof` or subclassed), is not supported:
+ * it may be replaced with an interface or union in the future.
  * @privateRemarks
- * Adding a member which all nodes have, like a type symbol, would produce much strong typing for this.
+ * Adding a member which all nodes have, like a type symbol, would produce much stronger typing for this.
+ * This is only a class to enable stronger typing in a future change,
+ * but other future changes may want to replace it with a branded interface if the runtime oddities related to this are not cleaned up.
+ *
+ * Currently not all node implications include this in their prototype chain (some hide it with a proxy), and thus cause `instanceof` to fail.
+ * This results in the runtime and compile time behavior of `instanceof` differing.
+ * TypeScript 5.3 allows altering the compile time behavior of `instanceof`.
+ * The runtime behavior can be changed by implementing `Symbol.hasInstance`.
+ * One of those approaches could be used to resolve this inconsistency if TreeNode is kept as a class.
  * @beta
  */
-export declare class TreeNode {
+export declare abstract class TreeNode {
 }
 
 /**

package/dist/fluid-framework-public.d.ts

@@ -90,6 +90,7 @@ import { SharedStringSegment } from '@fluidframework/sequence';
 import { StableId } from '@fluidframework/runtime-definitions';
 import type { Static } from '@sinclair/typebox';
 import { SubSequence } from '@fluidframework/sequence';
+import { TreeNode as TreeNode_2 } from '..';
 import { TreeNodeSchema as TreeNodeSchema_2 } from './schemaTypes';
 import { TreeNodeSchemaClass as TreeNodeSchemaClass_2 } from './schemaTypes';
 import type { TSchema } from '@sinclair/typebox';