fluid-framework 2.0.0-dev-rc.3.0.0.254513 → 2.0.0-dev-rc.3.0.0.254866

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

@@ -4,16 +4,14 @@
 
 ```ts
 
+import { FieldSchemaUnsafe as FieldSchemaUnsafe_2 } from './typesUnsafe.js';
 import { FluidObject } from '@fluidframework/core-interfaces';
 import { IChannel } from '@fluidframework/datastore-definitions';
 import type { IErrorBase } from '@fluidframework/core-interfaces';
 import { IEvent } from '@fluidframework/core-interfaces';
 import { IEventProvider } from '@fluidframework/core-interfaces';
-import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
 import { IFluidHandle } from '@fluidframework/core-interfaces';
 import { IFluidLoadable } from '@fluidframework/core-interfaces';
-import { ISharedObject } from '@fluidframework/shared-object-base';
-import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
 import { ISharedObjectKind } from '@fluidframework/shared-object-base';
 
 // @public
@@ -151,6 +149,13 @@ export class FieldSchema<out Kind extends FieldKind = FieldKind, out Types exten
     protected _typeCheck?: MakeNominal;
 }
 
+// @public
+export interface FieldSchemaUnsafe<out Kind extends FieldKind, out Types extends Unenforced<ImplicitAllowedTypes>> extends FieldSchema<Kind, any> {
+    readonly allowedTypes: Types;
+    readonly allowedTypeSet: ReadonlySet<TreeNodeSchema>;
+    readonly kind: Kind;
+}
+
 // @public
 export type FlexList<Item = unknown> = readonly LazyItem<Item>[];
 
@@ -216,17 +221,33 @@ export type InsertableObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord
     readonly [Property in keyof T]: InsertableTreeFieldFromImplicitField<T[Property]>;
 };
 
+// @public
+export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>> = {
+    readonly [Property in keyof T]: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property]>;
+};
+
 // @public
 export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
 
+// @public
+export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
+
 // @public
 export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
 
+// @public
+export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
+
 // @public
 export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
     implicitlyConstructable: true;
 } ? NodeBuilderData<T> : never) | Unhydrated<NodeFromSchema<T>>;
 
+// @public
+export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = Unhydrated<NodeFromSchemaUnsafe<T>> | (T extends {
+    implicitlyConstructable: true;
+} ? NodeBuilderDataUnsafe<T> : never);
+
 // @public
 export interface IServiceAudience<M extends IMember> extends IEventProvider<IServiceAudienceEvents<M>> {
     getMembers(): ReadonlyMap<string, M>;
@@ -246,18 +267,6 @@ export interface IServiceAudienceEvents<M extends IMember> extends IEvent {
 // @public
 export type IsEvent<Event> = Event extends (...args: any[]) => any ? true : false;
 
-// @public @sealed
-export interface ISharedMap extends ISharedObject<ISharedMapEvents>, Map<string, any> {
-    get<T = any>(key: string): T | undefined;
-    set<T = unknown>(key: string, value: T): this;
-}
-
-// @public @sealed
-export interface ISharedMapEvents extends ISharedObjectEvents {
-    (event: "valueChanged", listener: (changed: IValueChanged, local: boolean, target: IEventThisPlaceHolder) => void): any;
-    (event: "clear", listener: (local: boolean, target: IEventThisPlaceHolder) => void): any;
-}
-
 // @public
 export interface ISubscribable<E extends Events<E>> {
     on<K extends keyof Events<E>>(eventName: K, listener: E[K]): () => void;
@@ -273,12 +282,6 @@ export interface ITree extends IChannel {
     schematize<TRoot extends ImplicitFieldSchema>(config: TreeConfiguration<TRoot>): TreeView<TRoot>;
 }
 
-// @public @sealed
-export interface IValueChanged {
-    readonly key: string;
-    readonly previousValue: any;
-}
-
 // @public
 export type LazyItem<Item = unknown> = Item | (() => Item);
 
@@ -303,9 +306,15 @@ export type Myself<M extends IMember = IMember> = M & {
 // @public
 export type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
 
+// @public
+export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
+
 // @public
 export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
 
+// @public
+export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
+
 // @public
 export enum NodeKind {
     Array = 1,
@@ -319,6 +328,11 @@ export type ObjectFromSchemaRecord<T extends RestrictiveReadonlyRecord<string, I
     -readonly [Property in keyof T]: TreeFieldFromImplicitField<T[Property]>;
 };
 
+// @public
+export type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>> = {
+    -readonly [Property in keyof T]: TreeFieldFromImplicitFieldUnsafe<T[Property]>;
+};
+
 // @public
 export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
     readonly [P in symbol | string]: P extends K ? T : never;
@@ -346,19 +360,26 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
     constructor(scope: TScope);
     array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<ScopedSchemaName<TScope, `Array<${string}>`>, NodeKind.Array, TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, `Array<${string}>`>>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true, T>;
     array<const Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Array, TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, Name>>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, true, T>;
+    arrayRecursive<const Name extends TName, const T extends Unenforced<ImplicitAllowedTypes>>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Array, TreeArrayNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>, {
+        [Symbol.iterator](): Iterator<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>;
+    }, false, T>;
     readonly boolean: TreeNodeSchema<"com.fluidframework.leaf.boolean", NodeKind.Leaf, boolean, boolean>;
-    // @deprecated
-    fixRecursiveReference<T extends AllowedTypes>(...types: T): void;
-    readonly handle: TreeNodeSchema<"com.fluidframework.leaf.handle", NodeKind.Leaf, IFluidHandle<FluidObject<unknown> & IFluidLoadable>, IFluidHandle<FluidObject<unknown> & IFluidLoadable>>;
+    readonly handle: TreeNodeSchema<"com.fluidframework.leaf.handle", NodeKind.Leaf, IFluidHandle<FluidObject & IFluidLoadable>, IFluidHandle<FluidObject & IFluidLoadable>>;
     get identifier(): FieldSchema<FieldKind.Identifier>;
     map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchema<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, true, T>;
     map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, true, T>;
-    namedArray_internal<Name extends TName | string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Array, TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, string>>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable, T>;
-    namedMap_internal<Name extends TName | string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean>(name: Name, allowedTypes: T, customizable: boolean, implicitlyConstructable: ImplicitlyConstructable): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>, Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>, ImplicitlyConstructable, T>;
+    mapRecursive<Name extends TName, const T extends Unenforced<ImplicitAllowedTypes>>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>, {
+        [Symbol.iterator](): Iterator<[
+        string,
+        InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>
+        ]>;
+    }, false, T>;
     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, fields: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNode<T, ScopedSchemaName<TScope, Name>>, object & InsertableObjectFromSchemaRecord<T>, true, T>;
+    objectRecursive<const Name extends TName, const T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>>(name: Name, t: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & InsertableObjectFromSchemaRecordUnsafe<T>, false, T>;
     optional<const T extends ImplicitAllowedTypes>(t: T, props?: FieldProps): FieldSchema<FieldKind.Optional, T>;
+    optionalRecursive<const T extends Unenforced<readonly (() => TreeNodeSchema)[]>>(t: T): FieldSchemaUnsafe_2<FieldKind.Optional, T>;
     required<const T extends ImplicitAllowedTypes>(t: T, props?: FieldProps): FieldSchema<FieldKind.Required, T>;
     // (undocumented)
     readonly scope: TScope;
@@ -373,12 +394,6 @@ export interface SchemaIncompatible {
 // @public
 export type ScopedSchemaName<TScope extends string | undefined, TName extends number | string> = TScope extends undefined ? `${TName}` : `${TScope}.${TName}`;
 
-// @public @deprecated
-export const SharedMap: ISharedObjectKind<ISharedMap>;
-
-// @public @deprecated
-export type SharedMap = ISharedMap;
-
 // @public
 export const SharedTree: ISharedObjectKind<ITree>;
 
@@ -422,6 +437,10 @@ export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends Readonl
     removeRange(start?: number, end?: number): void;
 }
 
+// @public
+export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
+}
+
 // @public
 export interface TreeChangeEvents {
     nodeChanged(): void;
@@ -440,6 +459,9 @@ export class TreeConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFie
 // @public
 export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
 
+// @public
+export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
+
 // @public
 export type TreeLeafValue = number | string | boolean | IFluidHandle | null;
 
@@ -449,6 +471,12 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
     set(key: string, value: InsertableTreeNodeFromImplicitAllowedTypes<T> | undefined): void;
 }
 
+// @public
+export interface TreeMapNodeUnsafe<T extends Unenforced<ImplicitAllowedTypes>> extends ReadonlyMap<string, TreeNodeFromImplicitAllowedTypesUnsafe<T>>, TreeNode {
+    delete(key: string): void;
+    set(key: string, value: InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T> | undefined): void;
+}
+
 // @public
 export abstract class TreeNode implements WithType {
     abstract get [type](): string;
@@ -468,6 +496,9 @@ export interface TreeNodeApi {
 // @public
 export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<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;
+
 // @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>;
 
@@ -496,6 +527,9 @@ export interface TreeNodeSchemaNonClass<out Name extends string = string, out Ki
 // @public
 export type TreeObjectNode<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName>;
 
+// @public
+export type TreeObjectNodeUnsafe<T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecordUnsafe<T> & WithType<TypeName>;
+
 // @public
 export enum TreeStatus {
     Deleted = 2,
@@ -522,9 +556,23 @@ export interface TreeViewEvents {
 // @public
 export const type: unique symbol;
 
+// @public
+export type Unenforced<_DesiredExtendsConstraint> = unknown;
+
 // @public
 export type Unhydrated<T> = T;
 
+// @public
+export type ValidateRecursiveSchema<T extends TreeNodeSchemaClass<string, NodeKind.Array | NodeKind.Map | NodeKind.Object, TreeNode & WithType<T["identifier"]>, {
+    [NodeKind.Object]: T["info"] extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema> ? InsertableObjectFromSchemaRecord<T["info"]> : unknown;
+    [NodeKind.Array]: T["info"] extends ImplicitAllowedTypes ? Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T["info"]>> : unknown;
+    [NodeKind.Map]: T["info"] extends ImplicitAllowedTypes ? Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T["info"]>]> : unknown;
+}[T["kind"]], false, {
+    [NodeKind.Object]: RestrictiveReadonlyRecord<string, ImplicitFieldSchema>;
+    [NodeKind.Array]: ImplicitAllowedTypes;
+    [NodeKind.Map]: ImplicitAllowedTypes;
+}[T["kind"]]>> = true;
+
 // @public
 export interface WithType<TName extends string = string> {
     get [type](): TName;

package/dist/alpha.d.ts

@@ -0,0 +1,109 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/*
+ * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+ * Generated by "flub generate entrypoints" in @fluidframework/build-tools.
+ */
+export {
+	// public APIs
+	AllowedTypes, 
+	ApplyKind, 
+	AttachState, 
+	CommitKind, 
+	CommitMetadata, 
+	ConnectionState, 
+	ConnectionStateType, 
+	ContainerAttachProps, 
+	ContainerSchema, 
+	DataObjectClass, 
+	DriverErrorTypes, 
+	Events, 
+	ExtractItemType, 
+	FieldKind, 
+	FieldProps, 
+	FieldSchema, 
+	FieldSchemaUnsafe, 
+	FlexList, 
+	FlexListToUnion, 
+	IConnection, 
+	ICriticalContainerError, 
+	IDisposable, 
+	IFluidContainer, 
+	IFluidContainerEvents, 
+	IMember, 
+	IServiceAudience, 
+	IServiceAudienceEvents, 
+	ISubscribable, 
+	ITree, 
+	ImplicitAllowedTypes, 
+	ImplicitFieldSchema, 
+	InitialObjects, 
+	InsertableObjectFromSchemaRecord, 
+	InsertableObjectFromSchemaRecordUnsafe, 
+	InsertableTreeFieldFromImplicitField, 
+	InsertableTreeFieldFromImplicitFieldUnsafe, 
+	InsertableTreeNodeFromImplicitAllowedTypes, 
+	InsertableTreeNodeFromImplicitAllowedTypesUnsafe, 
+	InsertableTypedNode, 
+	InsertableTypedNodeUnsafe, 
+	IsEvent, 
+	IterableTreeArrayContent, 
+	LazyItem, 
+	LoadableObjectClass, 
+	LoadableObjectClassRecord, 
+	MakeNominal, 
+	MemberChangedListener, 
+	Myself, 
+	NodeBuilderData, 
+	NodeBuilderDataUnsafe, 
+	NodeFromSchema, 
+	NodeFromSchemaUnsafe, 
+	NodeKind, 
+	ObjectFromSchemaRecord, 
+	ObjectFromSchemaRecordUnsafe, 
+	RestrictiveReadonlyRecord, 
+	Revertible, 
+	RevertibleFactory, 
+	RevertibleStatus, 
+	SchemaFactory, 
+	SchemaIncompatible, 
+	ScopedSchemaName, 
+	SharedTree, 
+	Tree, 
+	TreeApi, 
+	TreeArrayNode, 
+	TreeArrayNodeBase, 
+	TreeArrayNodeUnsafe, 
+	TreeChangeEvents, 
+	TreeConfiguration, 
+	TreeFieldFromImplicitField, 
+	TreeFieldFromImplicitFieldUnsafe, 
+	TreeLeafValue, 
+	TreeMapNode, 
+	TreeMapNodeUnsafe, 
+	TreeNode, 
+	TreeNodeApi, 
+	TreeNodeFromImplicitAllowedTypes, 
+	TreeNodeFromImplicitAllowedTypesUnsafe, 
+	TreeNodeSchema, 
+	TreeNodeSchemaClass, 
+	TreeNodeSchemaCore, 
+	TreeNodeSchemaNonClass, 
+	TreeObjectNode, 
+	TreeObjectNodeUnsafe, 
+	TreeStatus, 
+	TreeView, 
+	TreeViewEvents, 
+	Unenforced, 
+	Unhydrated, 
+	ValidateRecursiveSchema, 
+	WithType, 
+	disposeSymbol, 
+	type,
+ 
+	// alpha APIs
+	ContainerErrorTypes
+} from "./index.js";

package/dist/beta.d.ts

@@ -0,0 +1,106 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/*
+ * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+ * Generated by "flub generate entrypoints" in @fluidframework/build-tools.
+ */
+export {
+	// public APIs
+	AllowedTypes, 
+	ApplyKind, 
+	AttachState, 
+	CommitKind, 
+	CommitMetadata, 
+	ConnectionState, 
+	ConnectionStateType, 
+	ContainerAttachProps, 
+	ContainerSchema, 
+	DataObjectClass, 
+	DriverErrorTypes, 
+	Events, 
+	ExtractItemType, 
+	FieldKind, 
+	FieldProps, 
+	FieldSchema, 
+	FieldSchemaUnsafe, 
+	FlexList, 
+	FlexListToUnion, 
+	IConnection, 
+	ICriticalContainerError, 
+	IDisposable, 
+	IFluidContainer, 
+	IFluidContainerEvents, 
+	IMember, 
+	IServiceAudience, 
+	IServiceAudienceEvents, 
+	ISubscribable, 
+	ITree, 
+	ImplicitAllowedTypes, 
+	ImplicitFieldSchema, 
+	InitialObjects, 
+	InsertableObjectFromSchemaRecord, 
+	InsertableObjectFromSchemaRecordUnsafe, 
+	InsertableTreeFieldFromImplicitField, 
+	InsertableTreeFieldFromImplicitFieldUnsafe, 
+	InsertableTreeNodeFromImplicitAllowedTypes, 
+	InsertableTreeNodeFromImplicitAllowedTypesUnsafe, 
+	InsertableTypedNode, 
+	InsertableTypedNodeUnsafe, 
+	IsEvent, 
+	IterableTreeArrayContent, 
+	LazyItem, 
+	LoadableObjectClass, 
+	LoadableObjectClassRecord, 
+	MakeNominal, 
+	MemberChangedListener, 
+	Myself, 
+	NodeBuilderData, 
+	NodeBuilderDataUnsafe, 
+	NodeFromSchema, 
+	NodeFromSchemaUnsafe, 
+	NodeKind, 
+	ObjectFromSchemaRecord, 
+	ObjectFromSchemaRecordUnsafe, 
+	RestrictiveReadonlyRecord, 
+	Revertible, 
+	RevertibleFactory, 
+	RevertibleStatus, 
+	SchemaFactory, 
+	SchemaIncompatible, 
+	ScopedSchemaName, 
+	SharedTree, 
+	Tree, 
+	TreeApi, 
+	TreeArrayNode, 
+	TreeArrayNodeBase, 
+	TreeArrayNodeUnsafe, 
+	TreeChangeEvents, 
+	TreeConfiguration, 
+	TreeFieldFromImplicitField, 
+	TreeFieldFromImplicitFieldUnsafe, 
+	TreeLeafValue, 
+	TreeMapNode, 
+	TreeMapNodeUnsafe, 
+	TreeNode, 
+	TreeNodeApi, 
+	TreeNodeFromImplicitAllowedTypes, 
+	TreeNodeFromImplicitAllowedTypesUnsafe, 
+	TreeNodeSchema, 
+	TreeNodeSchemaClass, 
+	TreeNodeSchemaCore, 
+	TreeNodeSchemaNonClass, 
+	TreeObjectNode, 
+	TreeObjectNodeUnsafe, 
+	TreeStatus, 
+	TreeView, 
+	TreeViewEvents, 
+	Unenforced, 
+	Unhydrated, 
+	ValidateRecursiveSchema, 
+	WithType, 
+	disposeSymbol, 
+	type
+} from "./index.js";

package/dist/index.d.ts

@@ -15,7 +15,5 @@ export { ContainerErrorTypes } from "@fluidframework/container-definitions/inter
 export { DriverErrorTypes } from "@fluidframework/driver-definitions";
 export { ConnectionState } from "@fluidframework/container-loader";
 export type { ContainerAttachProps, ContainerSchema, DataObjectClass, IConnection, IFluidContainer, IFluidContainerEvents, IMember, InitialObjects, IServiceAudience, IServiceAudienceEvents, LoadableObjectClass, LoadableObjectClassRecord, MemberChangedListener, Myself, } from "@fluidframework/fluid-static";
-export type { ISharedMap, ISharedMapEvents, IValueChanged } from "@fluidframework/map";
-export { SharedMap } from "@fluidframework/map";
 export * from "@fluidframework/tree";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,YAAY,EACX,eAAe,IAAI,mBAAmB,EAAE,0CAA0C;AAClF,uBAAuB,GACvB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,YAAY,EACX,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,WAAW,EACX,eAAe,EACf,qBAAqB,EACrB,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,yBAAyB,EACzB,qBAAqB,EACrB,MAAM,GACN,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAOhD,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,YAAY,EACX,eAAe,IAAI,mBAAmB,EAAE,0CAA0C;AAClF,uBAAuB,GACvB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,YAAY,EACX,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,WAAW,EACX,eAAe,EACf,qBAAqB,EACrB,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,yBAAyB,EACzB,qBAAqB,EACrB,MAAM,GACN,MAAM,8BAA8B,CAAC;AAOtC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -18,7 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedMap = exports.ConnectionState = exports.DriverErrorTypes = exports.ContainerErrorTypes = exports.AttachState = void 0;
+exports.ConnectionState = exports.DriverErrorTypes = exports.ContainerErrorTypes = exports.AttachState = void 0;
 var container_definitions_1 = require("@fluidframework/container-definitions");
 Object.defineProperty(exports, "AttachState", { enumerable: true, get: function () { return container_definitions_1.AttachState; } });
 var internal_1 = require("@fluidframework/container-definitions/internal");
@@ -27,8 +27,6 @@ var driver_definitions_1 = require("@fluidframework/driver-definitions");
 Object.defineProperty(exports, "DriverErrorTypes", { enumerable: true, get: function () { return driver_definitions_1.DriverErrorTypes; } });
 var container_loader_1 = require("@fluidframework/container-loader");
 Object.defineProperty(exports, "ConnectionState", { enumerable: true, get: function () { return container_loader_1.ConnectionState; } });
-var map_1 = require("@fluidframework/map");
-Object.defineProperty(exports, "SharedMap", { enumerable: true, get: function () { return map_1.SharedMap; } });
 // Let the tree package manage its own API surface, we will simply reflect it here.
 // Note: this only surfaces the `@public` API items from the tree package. If the `@beta` and `@alpha` items are
 // desired, they can be added by re-exporting from one of the package's aliased export paths instead (e.g. `tree

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;AAaH,+EAAoE;AAA3D,oHAAA,WAAW,OAAA;AACpB,2EAAqF;AAA5E,+GAAA,mBAAmB,OAAA;AAC5B,yEAAsE;AAA7D,sHAAA,gBAAgB,OAAA;AACzB,qEAAmE;AAA1D,mHAAA,eAAe,OAAA;AAkBxB,2CAAgD;AAAvC,gGAAA,SAAS,OAAA;AAElB,mFAAmF;AACnF,gHAAgH;AAChH,gHAAgH;AAChH,qDAAqD;AACrD,gDAAgD;AAChD,uDAAqC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Bundles a collection of Fluid Framework client libraries for easy use when paired with a corresponding service client\n * package (e.g. `@fluidframework/azure-client`, `@fluidframework/tinylicious-client`, or `@fluid-experimental/osdp-client (BETA)`).\n *\n * @packageDocumentation\n */\n\nexport type {\n\tConnectionState as ConnectionStateType, // TODO: deduplicate ConnectionState types\n\tICriticalContainerError,\n} from \"@fluidframework/container-definitions\";\nexport { AttachState } from \"@fluidframework/container-definitions\";\nexport { ContainerErrorTypes } from \"@fluidframework/container-definitions/internal\";\nexport { DriverErrorTypes } from \"@fluidframework/driver-definitions\";\nexport { ConnectionState } from \"@fluidframework/container-loader\";\nexport type {\n\tContainerAttachProps,\n\tContainerSchema,\n\tDataObjectClass,\n\tIConnection,\n\tIFluidContainer,\n\tIFluidContainerEvents,\n\tIMember,\n\tInitialObjects,\n\tIServiceAudience,\n\tIServiceAudienceEvents,\n\tLoadableObjectClass,\n\tLoadableObjectClassRecord,\n\tMemberChangedListener,\n\tMyself,\n} from \"@fluidframework/fluid-static\";\nexport type { ISharedMap, ISharedMapEvents, IValueChanged } from \"@fluidframework/map\";\nexport { SharedMap } from \"@fluidframework/map\";\n\n// Let the tree package manage its own API surface, we will simply reflect it here.\n// Note: this only surfaces the `@public` API items from the tree package. If the `@beta` and `@alpha` items are\n// desired, they can be added by re-exporting from one of the package's aliased export paths instead (e.g. `tree\n// alpha` to surface everything `@alpha` and higher).\n// eslint-disable-next-line no-restricted-syntax\nexport * from \"@fluidframework/tree\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;AAaH,+EAAoE;AAA3D,oHAAA,WAAW,OAAA;AACpB,2EAAqF;AAA5E,+GAAA,mBAAmB,OAAA;AAC5B,yEAAsE;AAA7D,sHAAA,gBAAgB,OAAA;AACzB,qEAAmE;AAA1D,mHAAA,eAAe,OAAA;AAkBxB,mFAAmF;AACnF,gHAAgH;AAChH,gHAAgH;AAChH,qDAAqD;AACrD,gDAAgD;AAChD,uDAAqC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Bundles a collection of Fluid Framework client libraries for easy use when paired with a corresponding service client\n * package (e.g. `@fluidframework/azure-client`, `@fluidframework/tinylicious-client`, or `@fluid-experimental/osdp-client (BETA)`).\n *\n * @packageDocumentation\n */\n\nexport type {\n\tConnectionState as ConnectionStateType, // TODO: deduplicate ConnectionState types\n\tICriticalContainerError,\n} from \"@fluidframework/container-definitions\";\nexport { AttachState } from \"@fluidframework/container-definitions\";\nexport { ContainerErrorTypes } from \"@fluidframework/container-definitions/internal\";\nexport { DriverErrorTypes } from \"@fluidframework/driver-definitions\";\nexport { ConnectionState } from \"@fluidframework/container-loader\";\nexport type {\n\tContainerAttachProps,\n\tContainerSchema,\n\tDataObjectClass,\n\tIConnection,\n\tIFluidContainer,\n\tIFluidContainerEvents,\n\tIMember,\n\tInitialObjects,\n\tIServiceAudience,\n\tIServiceAudienceEvents,\n\tLoadableObjectClass,\n\tLoadableObjectClassRecord,\n\tMemberChangedListener,\n\tMyself,\n} from \"@fluidframework/fluid-static\";\n\n// Let the tree package manage its own API surface, we will simply reflect it here.\n// Note: this only surfaces the `@public` API items from the tree package. If the `@beta` and `@alpha` items are\n// desired, they can be added by re-exporting from one of the package's aliased export paths instead (e.g. `tree\n// alpha` to surface everything `@alpha` and higher).\n// eslint-disable-next-line no-restricted-syntax\nexport * from \"@fluidframework/tree\";\n"]}

package/dist/public.d.ts

@@ -0,0 +1,106 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/*
+ * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+ * Generated by "flub generate entrypoints" in @fluidframework/build-tools.
+ */
+export {
+	// public APIs
+	AllowedTypes, 
+	ApplyKind, 
+	AttachState, 
+	CommitKind, 
+	CommitMetadata, 
+	ConnectionState, 
+	ConnectionStateType, 
+	ContainerAttachProps, 
+	ContainerSchema, 
+	DataObjectClass, 
+	DriverErrorTypes, 
+	Events, 
+	ExtractItemType, 
+	FieldKind, 
+	FieldProps, 
+	FieldSchema, 
+	FieldSchemaUnsafe, 
+	FlexList, 
+	FlexListToUnion, 
+	IConnection, 
+	ICriticalContainerError, 
+	IDisposable, 
+	IFluidContainer, 
+	IFluidContainerEvents, 
+	IMember, 
+	IServiceAudience, 
+	IServiceAudienceEvents, 
+	ISubscribable, 
+	ITree, 
+	ImplicitAllowedTypes, 
+	ImplicitFieldSchema, 
+	InitialObjects, 
+	InsertableObjectFromSchemaRecord, 
+	InsertableObjectFromSchemaRecordUnsafe, 
+	InsertableTreeFieldFromImplicitField, 
+	InsertableTreeFieldFromImplicitFieldUnsafe, 
+	InsertableTreeNodeFromImplicitAllowedTypes, 
+	InsertableTreeNodeFromImplicitAllowedTypesUnsafe, 
+	InsertableTypedNode, 
+	InsertableTypedNodeUnsafe, 
+	IsEvent, 
+	IterableTreeArrayContent, 
+	LazyItem, 
+	LoadableObjectClass, 
+	LoadableObjectClassRecord, 
+	MakeNominal, 
+	MemberChangedListener, 
+	Myself, 
+	NodeBuilderData, 
+	NodeBuilderDataUnsafe, 
+	NodeFromSchema, 
+	NodeFromSchemaUnsafe, 
+	NodeKind, 
+	ObjectFromSchemaRecord, 
+	ObjectFromSchemaRecordUnsafe, 
+	RestrictiveReadonlyRecord, 
+	Revertible, 
+	RevertibleFactory, 
+	RevertibleStatus, 
+	SchemaFactory, 
+	SchemaIncompatible, 
+	ScopedSchemaName, 
+	SharedTree, 
+	Tree, 
+	TreeApi, 
+	TreeArrayNode, 
+	TreeArrayNodeBase, 
+	TreeArrayNodeUnsafe, 
+	TreeChangeEvents, 
+	TreeConfiguration, 
+	TreeFieldFromImplicitField, 
+	TreeFieldFromImplicitFieldUnsafe, 
+	TreeLeafValue, 
+	TreeMapNode, 
+	TreeMapNodeUnsafe, 
+	TreeNode, 
+	TreeNodeApi, 
+	TreeNodeFromImplicitAllowedTypes, 
+	TreeNodeFromImplicitAllowedTypesUnsafe, 
+	TreeNodeSchema, 
+	TreeNodeSchemaClass, 
+	TreeNodeSchemaCore, 
+	TreeNodeSchemaNonClass, 
+	TreeObjectNode, 
+	TreeObjectNodeUnsafe, 
+	TreeStatus, 
+	TreeView, 
+	TreeViewEvents, 
+	Unenforced, 
+	Unhydrated, 
+	ValidateRecursiveSchema, 
+	WithType, 
+	disposeSymbol, 
+	type
+} from "./index.js";