fluid-framework 2.4.0-299374 → 2.4.0-299707

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/api-report/fluid-framework.alpha.api.md +21 -78
  2. package/api-report/fluid-framework.beta.api.md +21 -46
  3. package/api-report/fluid-framework.legacy.alpha.api.md +21 -46
  4. package/api-report/fluid-framework.legacy.public.api.md +21 -46
  5. package/api-report/fluid-framework.public.api.md +21 -46
  6. package/dist/alpha.d.ts +0 -9
  7. package/dist/beta.d.ts +0 -2
  8. package/dist/legacy.d.ts +0 -2
  9. package/dist/public.d.ts +0 -2
  10. package/lib/alpha.d.ts +0 -9
  11. package/lib/beta.d.ts +0 -2
  12. package/lib/legacy.d.ts +0 -2
  13. package/lib/public.d.ts +0 -2
  14. package/package.json +12 -12
package/api-report/fluid-framework.alpha.api.md CHANGED
@@ -16,9 +16,6 @@ export function adaptEnum<TScope extends string, const TEnum extends Record<stri
16
16
  // @public
17
17
  export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
18
18
 
19
- // @public
20
- type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
21
-
22
19
  // @public
23
20
  type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
24
21
  [FieldKind.Required]: T;
@@ -105,14 +102,6 @@ type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result ?
105
102
  // @alpha
106
103
  export function extractPersistedSchema(schema: ImplicitFieldSchema): JsonCompatible;
107
104
 
108
- // @alpha
109
- export type FactoryContent = IFluidHandle | string | number | boolean | null | Iterable<readonly [string, InsertableContent]> | readonly InsertableContent[] | FactoryContentObject;
110
-
111
- // @alpha
112
- export type FactoryContentObject = {
113
- readonly [P in string]?: InsertableContent;
114
- };
115
-
116
105
  // @public
117
106
  type FieldHasDefault<T extends ImplicitFieldSchema> = T extends FieldSchema<FieldKind.Optional | FieldKind.Identifier> ? true : false;
118
107
 
@@ -472,15 +461,6 @@ export type InitialObjects<T extends ContainerSchema> = {
472
461
  // @public
473
462
  type _InlineTrick = 0;
474
463
 
475
- // @alpha
476
- export type Insertable<TSchema extends ImplicitAllowedTypes | UnsafeUnknownSchema> = TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : InsertableContent;
477
-
478
- // @alpha
479
- export type InsertableContent = Unhydrated<TreeNode> | FactoryContent;
480
-
481
- // @alpha
482
- export type InsertableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = TSchema extends ImplicitFieldSchema ? InsertableTreeFieldFromImplicitField<TSchema> : InsertableContent | undefined;
483
-
484
464
  // @public
485
465
  type InsertableObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> = FlattenKeys<{
486
466
  readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<T[Property] & string>;
@@ -496,7 +476,7 @@ export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<Restrict
496
476
  };
497
477
 
498
478
  // @public
499
- export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
479
+ export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
500
480
 
501
481
  // @public
502
482
  export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
@@ -505,7 +485,7 @@ export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforce
505
485
  export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
506
486
 
507
487
  // @public
508
- export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypesUnsafe ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
488
+ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
509
489
 
510
490
  // @public
511
491
  export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
@@ -550,9 +530,6 @@ declare namespace InternalTypes {
550
530
  NodeBuilderDataUnsafe,
551
531
  NodeFromSchemaUnsafe,
552
532
  ReadonlyMapInlined,
553
- TreeNodeSchemaUnsafe,
554
- AllowedTypesUnsafe,
555
- TreeNodeSchemaNonClassUnsafe,
556
533
  FlexList,
557
534
  FlexListToUnion,
558
535
  ExtractItemType,
@@ -718,10 +695,10 @@ export type Myself<M extends IMember = IMember> = M & {
718
695
  };
719
696
 
720
697
  // @public
721
- type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, infer TBuild> ? TBuild : never;
698
+ type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
722
699
 
723
700
  // @public
724
- type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
701
+ type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
725
702
 
726
703
  // @beta @sealed
727
704
  export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
@@ -732,7 +709,7 @@ export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
732
709
  export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
733
710
 
734
711
  // @public
735
- type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
712
+ type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
736
713
 
737
714
  // @public
738
715
  export interface NodeInDocumentConstraint {
@@ -766,10 +743,6 @@ type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveStringRecord<I
766
743
  // @public
767
744
  export type Off = () => void;
768
745
 
769
- // @public @sealed
770
- export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends ReadonlyArray<T>, Awaited<TreeNode & WithType<string, NodeKind.Array>> {
771
- }
772
-
773
746
  // @public @sealed
774
747
  interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {
775
748
  [Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
@@ -826,17 +799,17 @@ export const rollback: unique symbol;
826
799
  // @public @sealed
827
800
  export interface RunTransaction {
828
801
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult): TResult;
829
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
802
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
830
803
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback): TResult | typeof rollback;
831
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
804
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
832
805
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;
833
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
806
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void): void;
834
807
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
835
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
808
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
836
809
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
837
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
810
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
838
811
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void, preconditions?: readonly TransactionConstraint[]): void;
839
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
812
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
840
813
  readonly rollback: typeof rollback;
841
814
  }
842
815
 
@@ -949,7 +922,7 @@ interface TreeApi extends TreeNodeApi {
949
922
  }
950
923
 
951
924
  // @public @sealed
952
- export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>> {
925
+ export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
953
926
  }
954
927
 
955
928
  // @public
@@ -958,7 +931,7 @@ export const TreeArrayNode: {
958
931
  };
959
932
 
960
933
  // @public @sealed
961
- interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
934
+ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
962
935
  insertAt(index: number, ...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
963
936
  insertAtEnd(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
964
937
  insertAtStart(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
@@ -980,7 +953,7 @@ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> ex
980
953
  }
981
954
 
982
955
  // @public @sealed
983
- export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>> {
956
+ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
984
957
  }
985
958
 
986
959
  // @beta @sealed
@@ -1019,7 +992,7 @@ export enum TreeCompressionStrategy {
1019
992
  }
1020
993
 
1021
994
  // @public
1022
- export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
995
+ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
1023
996
 
1024
997
  // @public
1025
998
  type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
@@ -1068,19 +1041,13 @@ export interface TreeNodeApi {
1068
1041
  export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
1069
1042
 
1070
1043
  // @public
1071
- type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<TSchema> : TSchema extends AllowedTypesUnsafe ? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>> : unknown;
1044
+ type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
1072
1045
 
1073
1046
  // @public @sealed
1074
- export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
1047
+ 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>;
1075
1048
 
1076
1049
  // @public @sealed
1077
- export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1078
- // @sealed
1079
- new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
1080
- }
1081
-
1082
- // @public
1083
- export interface TreeNodeSchemaClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1050
+ export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1084
1051
  // @sealed
1085
1052
  new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
1086
1053
  }
@@ -1096,20 +1063,11 @@ export interface TreeNodeSchemaCore<out Name extends string, out Kind extends No
1096
1063
  }
1097
1064
 
1098
1065
  // @public @sealed
1099
- export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1066
+ export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1100
1067
  // (undocumented)
1101
1068
  create(data: TInsertable): TNode;
1102
1069
  }
1103
1070
 
1104
- // @public
1105
- interface TreeNodeSchemaNonClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1106
- // (undocumented)
1107
- create(data: TInsertable): TNode;
1108
- }
1109
-
1110
- // @public
1111
- type TreeNodeSchemaUnsafe<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
1112
-
1113
1071
  // @public
1114
1072
  export type TreeObjectNode<T extends RestrictiveStringRecord<ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
1115
1073
 
@@ -1125,7 +1083,7 @@ export enum TreeStatus {
1125
1083
  }
1126
1084
 
1127
1085
  // @public @sealed
1128
- export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
1086
+ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
1129
1087
  readonly compatibility: SchemaCompatibilityStatus;
1130
1088
  readonly events: Listenable<TreeViewEvents>;
1131
1089
  initialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;
@@ -1135,15 +1093,6 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
1135
1093
  upgradeSchema(): void;
1136
1094
  }
1137
1095
 
1138
- // @alpha
1139
- export interface TreeViewAlpha<in out TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> extends Omit<TreeView<TSchema extends ImplicitFieldSchema ? TSchema : ImplicitFieldSchema>, "root" | "initialize"> {
1140
- // (undocumented)
1141
- initialize(content: InsertableField<TSchema>): void;
1142
- // (undocumented)
1143
- get root(): TSchema extends ImplicitFieldSchema ? TreeFieldFromImplicitField<TSchema> : TreeLeafValue | TreeNode;
1144
- set root(newRoot: InsertableField<TSchema>);
1145
- }
1146
-
1147
1096
  // @public @sealed
1148
1097
  export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema> implements Required<ITreeViewConfiguration<TSchema>> {
1149
1098
  constructor(props: ITreeViewConfiguration<TSchema>);
@@ -1179,12 +1128,6 @@ export type Unenforced<_DesiredExtendsConstraint> = unknown;
1179
1128
  // @public
1180
1129
  export type Unhydrated<T> = T;
1181
1130
 
1182
- // @alpha
1183
- export const UnsafeUnknownSchema: unique symbol;
1184
-
1185
- // @alpha
1186
- export type UnsafeUnknownSchema = typeof UnsafeUnknownSchema;
1187
-
1188
1131
  // @public
1189
1132
  export type ValidateRecursiveSchema<T extends TreeNodeSchemaClass<string, NodeKind.Array | NodeKind.Map | NodeKind.Object, TreeNode & WithType<T["identifier"], T["kind"]>, {
1190
1133
  [NodeKind.Object]: T["info"] extends RestrictiveStringRecord<ImplicitFieldSchema> ? InsertableObjectFromSchemaRecord<T["info"]> : unknown;
@@ -1205,7 +1148,7 @@ export interface ViewableTree {
1205
1148
  export interface WithType<out TName extends string = string, out TKind extends NodeKind = NodeKind, out TInfo = unknown> {
1206
1149
  // @deprecated
1207
1150
  get [typeNameSymbol](): TName;
1208
- get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode | TreeLeafValue, never, boolean, TInfo>;
1151
+ get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
1209
1152
  }
1210
1153
 
1211
1154
  ```
package/api-report/fluid-framework.beta.api.md CHANGED
@@ -7,9 +7,6 @@
7
7
  // @public
8
8
  export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
9
9
 
10
- // @public
11
- type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
12
-
13
10
  // @public
14
11
  type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
15
12
  [FieldKind.Required]: T;
@@ -423,7 +420,7 @@ export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<Restrict
423
420
  };
424
421
 
425
422
  // @public
426
- export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
423
+ export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
427
424
 
428
425
  // @public
429
426
  export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
@@ -432,7 +429,7 @@ export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforce
432
429
  export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
433
430
 
434
431
  // @public
435
- export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypesUnsafe ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
432
+ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
436
433
 
437
434
  // @public
438
435
  export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
@@ -477,9 +474,6 @@ declare namespace InternalTypes {
477
474
  NodeBuilderDataUnsafe,
478
475
  NodeFromSchemaUnsafe,
479
476
  ReadonlyMapInlined,
480
- TreeNodeSchemaUnsafe,
481
- AllowedTypesUnsafe,
482
- TreeNodeSchemaNonClassUnsafe,
483
477
  FlexList,
484
478
  FlexListToUnion,
485
479
  ExtractItemType,
@@ -570,10 +564,10 @@ export type Myself<M extends IMember = IMember> = M & {
570
564
  };
571
565
 
572
566
  // @public
573
- type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, infer TBuild> ? TBuild : never;
567
+ type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
574
568
 
575
569
  // @public
576
- type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
570
+ type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
577
571
 
578
572
  // @beta @sealed
579
573
  export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
@@ -584,7 +578,7 @@ export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
584
578
  export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
585
579
 
586
580
  // @public
587
- type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
581
+ type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
588
582
 
589
583
  // @public
590
584
  export interface NodeInDocumentConstraint {
@@ -615,10 +609,6 @@ type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveStringRecord<I
615
609
  // @public
616
610
  export type Off = () => void;
617
611
 
618
- // @public @sealed
619
- export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends ReadonlyArray<T>, Awaited<TreeNode & WithType<string, NodeKind.Array>> {
620
- }
621
-
622
612
  // @public @sealed
623
613
  interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {
624
614
  [Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
@@ -675,17 +665,17 @@ export const rollback: unique symbol;
675
665
  // @public @sealed
676
666
  export interface RunTransaction {
677
667
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult): TResult;
678
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
668
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
679
669
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback): TResult | typeof rollback;
680
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
670
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
681
671
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;
682
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
672
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void): void;
683
673
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
684
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
674
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
685
675
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
686
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
676
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
687
677
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void, preconditions?: readonly TransactionConstraint[]): void;
688
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
678
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
689
679
  readonly rollback: typeof rollback;
690
680
  }
691
681
 
@@ -767,7 +757,7 @@ interface TreeApi extends TreeNodeApi {
767
757
  }
768
758
 
769
759
  // @public @sealed
770
- export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>> {
760
+ export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
771
761
  }
772
762
 
773
763
  // @public
@@ -776,7 +766,7 @@ export const TreeArrayNode: {
776
766
  };
777
767
 
778
768
  // @public @sealed
779
- interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
769
+ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
780
770
  insertAt(index: number, ...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
781
771
  insertAtEnd(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
782
772
  insertAtStart(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
@@ -798,7 +788,7 @@ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> ex
798
788
  }
799
789
 
800
790
  // @public @sealed
801
- export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>> {
791
+ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
802
792
  }
803
793
 
804
794
  // @beta @sealed
@@ -818,7 +808,7 @@ export interface TreeChangeEventsBeta<TNode extends TreeNode = TreeNode> extends
818
808
  }
819
809
 
820
810
  // @public
821
- export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
811
+ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
822
812
 
823
813
  // @public
824
814
  type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
@@ -867,19 +857,13 @@ export interface TreeNodeApi {
867
857
  export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
868
858
 
869
859
  // @public
870
- type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<TSchema> : TSchema extends AllowedTypesUnsafe ? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>> : unknown;
860
+ type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
871
861
 
872
862
  // @public @sealed
873
- export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
863
+ 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>;
874
864
 
875
865
  // @public @sealed
876
- export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
877
- // @sealed
878
- new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
879
- }
880
-
881
- // @public
882
- export interface TreeNodeSchemaClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
866
+ export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
883
867
  // @sealed
884
868
  new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
885
869
  }
@@ -895,20 +879,11 @@ export interface TreeNodeSchemaCore<out Name extends string, out Kind extends No
895
879
  }
896
880
 
897
881
  // @public @sealed
898
- export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
899
- // (undocumented)
900
- create(data: TInsertable): TNode;
901
- }
902
-
903
- // @public
904
- interface TreeNodeSchemaNonClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
882
+ export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
905
883
  // (undocumented)
906
884
  create(data: TInsertable): TNode;
907
885
  }
908
886
 
909
- // @public
910
- type TreeNodeSchemaUnsafe<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
911
-
912
887
  // @public
913
888
  export type TreeObjectNode<T extends RestrictiveStringRecord<ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
914
889
 
@@ -924,7 +899,7 @@ export enum TreeStatus {
924
899
  }
925
900
 
926
901
  // @public @sealed
927
- export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
902
+ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
928
903
  readonly compatibility: SchemaCompatibilityStatus;
929
904
  readonly events: Listenable<TreeViewEvents>;
930
905
  initialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;
@@ -983,7 +958,7 @@ export interface ViewableTree {
983
958
  export interface WithType<out TName extends string = string, out TKind extends NodeKind = NodeKind, out TInfo = unknown> {
984
959
  // @deprecated
985
960
  get [typeNameSymbol](): TName;
986
- get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode | TreeLeafValue, never, boolean, TInfo>;
961
+ get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
987
962
  }
988
963
 
989
964
  ```
package/api-report/fluid-framework.legacy.alpha.api.md CHANGED
@@ -7,9 +7,6 @@
7
7
  // @public
8
8
  export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
9
9
 
10
- // @public
11
- type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
12
-
13
10
  // @public
14
11
  type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
15
12
  [FieldKind.Required]: T;
@@ -523,7 +520,7 @@ export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<Restrict
523
520
  };
524
521
 
525
522
  // @public
526
- export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
523
+ export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
527
524
 
528
525
  // @public
529
526
  export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
@@ -532,7 +529,7 @@ export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforce
532
529
  export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
533
530
 
534
531
  // @public
535
- export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypesUnsafe ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
532
+ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
536
533
 
537
534
  // @public
538
535
  export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
@@ -579,9 +576,6 @@ declare namespace InternalTypes {
579
576
  NodeBuilderDataUnsafe,
580
577
  NodeFromSchemaUnsafe,
581
578
  ReadonlyMapInlined,
582
- TreeNodeSchemaUnsafe,
583
- AllowedTypesUnsafe,
584
- TreeNodeSchemaNonClassUnsafe,
585
579
  FlexList,
586
580
  FlexListToUnion,
587
581
  ExtractItemType,
@@ -876,16 +870,16 @@ export type Myself<M extends IMember = IMember> = M & {
876
870
  };
877
871
 
878
872
  // @public
879
- type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, infer TBuild> ? TBuild : never;
873
+ type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
880
874
 
881
875
  // @public
882
- type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
876
+ type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
883
877
 
884
878
  // @public
885
879
  export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
886
880
 
887
881
  // @public
888
- type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
882
+ type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
889
883
 
890
884
  // @public
891
885
  export interface NodeInDocumentConstraint {
@@ -916,10 +910,6 @@ type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveStringRecord<I
916
910
  // @public
917
911
  export type Off = () => void;
918
912
 
919
- // @public @sealed
920
- export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends ReadonlyArray<T>, Awaited<TreeNode & WithType<string, NodeKind.Array>> {
921
- }
922
-
923
913
  // @public @sealed
924
914
  interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {
925
915
  [Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
@@ -976,17 +966,17 @@ export const rollback: unique symbol;
976
966
  // @public @sealed
977
967
  export interface RunTransaction {
978
968
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult): TResult;
979
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
969
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
980
970
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback): TResult | typeof rollback;
981
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
971
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
982
972
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;
983
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
973
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void): void;
984
974
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
985
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
975
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
986
976
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
987
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
977
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
988
978
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void, preconditions?: readonly TransactionConstraint[]): void;
989
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
979
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
990
980
  readonly rollback: typeof rollback;
991
981
  }
992
982
 
@@ -1163,7 +1153,7 @@ interface TreeApi extends TreeNodeApi {
1163
1153
  }
1164
1154
 
1165
1155
  // @public @sealed
1166
- export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>> {
1156
+ export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
1167
1157
  }
1168
1158
 
1169
1159
  // @public
@@ -1172,7 +1162,7 @@ export const TreeArrayNode: {
1172
1162
  };
1173
1163
 
1174
1164
  // @public @sealed
1175
- interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
1165
+ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
1176
1166
  insertAt(index: number, ...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
1177
1167
  insertAtEnd(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
1178
1168
  insertAtStart(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
@@ -1194,7 +1184,7 @@ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> ex
1194
1184
  }
1195
1185
 
1196
1186
  // @public @sealed
1197
- export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>> {
1187
+ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
1198
1188
  }
1199
1189
 
1200
1190
  // @public @sealed
@@ -1204,7 +1194,7 @@ export interface TreeChangeEvents {
1204
1194
  }
1205
1195
 
1206
1196
  // @public
1207
- export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
1197
+ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
1208
1198
 
1209
1199
  // @public
1210
1200
  type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
@@ -1253,19 +1243,13 @@ export interface TreeNodeApi {
1253
1243
  export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
1254
1244
 
1255
1245
  // @public
1256
- type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<TSchema> : TSchema extends AllowedTypesUnsafe ? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>> : unknown;
1246
+ type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
1257
1247
 
1258
1248
  // @public @sealed
1259
- export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
1249
+ 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>;
1260
1250
 
1261
1251
  // @public @sealed
1262
- export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1263
- // @sealed
1264
- new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
1265
- }
1266
-
1267
- // @public
1268
- export interface TreeNodeSchemaClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1252
+ export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1269
1253
  // @sealed
1270
1254
  new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
1271
1255
  }
@@ -1281,20 +1265,11 @@ export interface TreeNodeSchemaCore<out Name extends string, out Kind extends No
1281
1265
  }
1282
1266
 
1283
1267
  // @public @sealed
1284
- export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1285
- // (undocumented)
1286
- create(data: TInsertable): TNode;
1287
- }
1288
-
1289
- // @public
1290
- interface TreeNodeSchemaNonClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1268
+ export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1291
1269
  // (undocumented)
1292
1270
  create(data: TInsertable): TNode;
1293
1271
  }
1294
1272
 
1295
- // @public
1296
- type TreeNodeSchemaUnsafe<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
1297
-
1298
1273
  // @public
1299
1274
  export type TreeObjectNode<T extends RestrictiveStringRecord<ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
1300
1275
 
@@ -1310,7 +1285,7 @@ export enum TreeStatus {
1310
1285
  }
1311
1286
 
1312
1287
  // @public @sealed
1313
- export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
1288
+ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
1314
1289
  readonly compatibility: SchemaCompatibilityStatus;
1315
1290
  readonly events: Listenable<TreeViewEvents>;
1316
1291
  initialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;
@@ -1369,7 +1344,7 @@ export interface ViewableTree {
1369
1344
  export interface WithType<out TName extends string = string, out TKind extends NodeKind = NodeKind, out TInfo = unknown> {
1370
1345
  // @deprecated
1371
1346
  get [typeNameSymbol](): TName;
1372
- get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode | TreeLeafValue, never, boolean, TInfo>;
1347
+ get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
1373
1348
  }
1374
1349
 
1375
1350
  ```
package/api-report/fluid-framework.legacy.public.api.md CHANGED
@@ -7,9 +7,6 @@
7
7
  // @public
8
8
  export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
9
9
 
10
- // @public
11
- type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
12
-
13
10
  // @public
14
11
  type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
15
12
  [FieldKind.Required]: T;
@@ -451,7 +448,7 @@ export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<Restrict
451
448
  };
452
449
 
453
450
  // @public
454
- export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
451
+ export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
455
452
 
456
453
  // @public
457
454
  export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
@@ -460,7 +457,7 @@ export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforce
460
457
  export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
461
458
 
462
459
  // @public
463
- export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypesUnsafe ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
460
+ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
464
461
 
465
462
  // @public
466
463
  export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
@@ -507,9 +504,6 @@ declare namespace InternalTypes {
507
504
  NodeBuilderDataUnsafe,
508
505
  NodeFromSchemaUnsafe,
509
506
  ReadonlyMapInlined,
510
- TreeNodeSchemaUnsafe,
511
- AllowedTypesUnsafe,
512
- TreeNodeSchemaNonClassUnsafe,
513
507
  FlexList,
514
508
  FlexListToUnion,
515
509
  ExtractItemType,
@@ -606,16 +600,16 @@ export type Myself<M extends IMember = IMember> = M & {
606
600
  };
607
601
 
608
602
  // @public
609
- type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, infer TBuild> ? TBuild : never;
603
+ type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
610
604
 
611
605
  // @public
612
- type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
606
+ type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
613
607
 
614
608
  // @public
615
609
  export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
616
610
 
617
611
  // @public
618
- type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
612
+ type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
619
613
 
620
614
  // @public
621
615
  export interface NodeInDocumentConstraint {
@@ -646,10 +640,6 @@ type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveStringRecord<I
646
640
  // @public
647
641
  export type Off = () => void;
648
642
 
649
- // @public @sealed
650
- export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends ReadonlyArray<T>, Awaited<TreeNode & WithType<string, NodeKind.Array>> {
651
- }
652
-
653
643
  // @public @sealed
654
644
  interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {
655
645
  [Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
@@ -706,17 +696,17 @@ export const rollback: unique symbol;
706
696
  // @public @sealed
707
697
  export interface RunTransaction {
708
698
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult): TResult;
709
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
699
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
710
700
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback): TResult | typeof rollback;
711
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
701
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
712
702
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;
713
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
703
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void): void;
714
704
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
715
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
705
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
716
706
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
717
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
707
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
718
708
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void, preconditions?: readonly TransactionConstraint[]): void;
719
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
709
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
720
710
  readonly rollback: typeof rollback;
721
711
  }
722
712
 
@@ -802,7 +792,7 @@ interface TreeApi extends TreeNodeApi {
802
792
  }
803
793
 
804
794
  // @public @sealed
805
- export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>> {
795
+ export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
806
796
  }
807
797
 
808
798
  // @public
@@ -811,7 +801,7 @@ export const TreeArrayNode: {
811
801
  };
812
802
 
813
803
  // @public @sealed
814
- interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
804
+ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
815
805
  insertAt(index: number, ...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
816
806
  insertAtEnd(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
817
807
  insertAtStart(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
@@ -833,7 +823,7 @@ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> ex
833
823
  }
834
824
 
835
825
  // @public @sealed
836
- export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>> {
826
+ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
837
827
  }
838
828
 
839
829
  // @public @sealed
@@ -843,7 +833,7 @@ export interface TreeChangeEvents {
843
833
  }
844
834
 
845
835
  // @public
846
- export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
836
+ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
847
837
 
848
838
  // @public
849
839
  type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
@@ -892,19 +882,13 @@ export interface TreeNodeApi {
892
882
  export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
893
883
 
894
884
  // @public
895
- type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<TSchema> : TSchema extends AllowedTypesUnsafe ? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>> : unknown;
885
+ type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
896
886
 
897
887
  // @public @sealed
898
- export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
888
+ 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>;
899
889
 
900
890
  // @public @sealed
901
- export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
902
- // @sealed
903
- new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
904
- }
905
-
906
- // @public
907
- export interface TreeNodeSchemaClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
891
+ export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
908
892
  // @sealed
909
893
  new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
910
894
  }
@@ -920,20 +904,11 @@ export interface TreeNodeSchemaCore<out Name extends string, out Kind extends No
920
904
  }
921
905
 
922
906
  // @public @sealed
923
- export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
924
- // (undocumented)
925
- create(data: TInsertable): TNode;
926
- }
927
-
928
- // @public
929
- interface TreeNodeSchemaNonClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
907
+ export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
930
908
  // (undocumented)
931
909
  create(data: TInsertable): TNode;
932
910
  }
933
911
 
934
- // @public
935
- type TreeNodeSchemaUnsafe<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
936
-
937
912
  // @public
938
913
  export type TreeObjectNode<T extends RestrictiveStringRecord<ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
939
914
 
@@ -949,7 +924,7 @@ export enum TreeStatus {
949
924
  }
950
925
 
951
926
  // @public @sealed
952
- export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
927
+ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
953
928
  readonly compatibility: SchemaCompatibilityStatus;
954
929
  readonly events: Listenable<TreeViewEvents>;
955
930
  initialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;
@@ -1008,7 +983,7 @@ export interface ViewableTree {
1008
983
  export interface WithType<out TName extends string = string, out TKind extends NodeKind = NodeKind, out TInfo = unknown> {
1009
984
  // @deprecated
1010
985
  get [typeNameSymbol](): TName;
1011
- get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode | TreeLeafValue, never, boolean, TInfo>;
986
+ get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
1012
987
  }
1013
988
 
1014
989
  ```
package/api-report/fluid-framework.public.api.md CHANGED
@@ -7,9 +7,6 @@
7
7
  // @public
8
8
  export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
9
9
 
10
- // @public
11
- type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
12
-
13
10
  // @public
14
11
  type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
15
12
  [FieldKind.Required]: T;
@@ -423,7 +420,7 @@ export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<Restrict
423
420
  };
424
421
 
425
422
  // @public
426
- export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
423
+ export type InsertableTreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : TSchema extends ImplicitAllowedTypes ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
427
424
 
428
425
  // @public
429
426
  export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
@@ -432,7 +429,7 @@ export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforce
432
429
  export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
433
430
 
434
431
  // @public
435
- export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypesUnsafe ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
432
+ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
436
433
 
437
434
  // @public
438
435
  export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
@@ -477,9 +474,6 @@ declare namespace InternalTypes {
477
474
  NodeBuilderDataUnsafe,
478
475
  NodeFromSchemaUnsafe,
479
476
  ReadonlyMapInlined,
480
- TreeNodeSchemaUnsafe,
481
- AllowedTypesUnsafe,
482
- TreeNodeSchemaNonClassUnsafe,
483
477
  FlexList,
484
478
  FlexListToUnion,
485
479
  ExtractItemType,
@@ -570,16 +564,16 @@ export type Myself<M extends IMember = IMember> = M & {
570
564
  };
571
565
 
572
566
  // @public
573
- type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, infer TBuild> ? TBuild : never;
567
+ type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
574
568
 
575
569
  // @public
576
- type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
570
+ type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
577
571
 
578
572
  // @public
579
573
  export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
580
574
 
581
575
  // @public
582
- type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
576
+ type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
583
577
 
584
578
  // @public
585
579
  export interface NodeInDocumentConstraint {
@@ -610,10 +604,6 @@ type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveStringRecord<I
610
604
  // @public
611
605
  export type Off = () => void;
612
606
 
613
- // @public @sealed
614
- export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends ReadonlyArray<T>, Awaited<TreeNode & WithType<string, NodeKind.Array>> {
615
- }
616
-
617
607
  // @public @sealed
618
608
  interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {
619
609
  [Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
@@ -670,17 +660,17 @@ export const rollback: unique symbol;
670
660
  // @public @sealed
671
661
  export interface RunTransaction {
672
662
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult): TResult;
673
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
663
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
674
664
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback): TResult | typeof rollback;
675
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
665
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
676
666
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;
677
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
667
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void): void;
678
668
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
679
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
669
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
680
670
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
681
- <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
671
+ <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
682
672
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void, preconditions?: readonly TransactionConstraint[]): void;
683
- <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
673
+ <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
684
674
  readonly rollback: typeof rollback;
685
675
  }
686
676
 
@@ -762,7 +752,7 @@ interface TreeApi extends TreeNodeApi {
762
752
  }
763
753
 
764
754
  // @public @sealed
765
- export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>> {
755
+ export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
766
756
  }
767
757
 
768
758
  // @public
@@ -771,7 +761,7 @@ export const TreeArrayNode: {
771
761
  };
772
762
 
773
763
  // @public @sealed
774
- interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
764
+ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
775
765
  insertAt(index: number, ...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
776
766
  insertAtEnd(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
777
767
  insertAtStart(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
@@ -793,7 +783,7 @@ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> ex
793
783
  }
794
784
 
795
785
  // @public @sealed
796
- export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>> {
786
+ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
797
787
  }
798
788
 
799
789
  // @public @sealed
@@ -803,7 +793,7 @@ export interface TreeChangeEvents {
803
793
  }
804
794
 
805
795
  // @public
806
- export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
796
+ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : unknown;
807
797
 
808
798
  // @public
809
799
  type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
@@ -852,19 +842,13 @@ export interface TreeNodeApi {
852
842
  export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
853
843
 
854
844
  // @public
855
- type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<TSchema> : TSchema extends AllowedTypesUnsafe ? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>> : unknown;
845
+ type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
856
846
 
857
847
  // @public @sealed
858
- export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
848
+ 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>;
859
849
 
860
850
  // @public @sealed
861
- export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
862
- // @sealed
863
- new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
864
- }
865
-
866
- // @public
867
- export interface TreeNodeSchemaClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
851
+ export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
868
852
  // @sealed
869
853
  new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
870
854
  }
@@ -880,20 +864,11 @@ export interface TreeNodeSchemaCore<out Name extends string, out Kind extends No
880
864
  }
881
865
 
882
866
  // @public @sealed
883
- export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
884
- // (undocumented)
885
- create(data: TInsertable): TNode;
886
- }
887
-
888
- // @public
889
- interface TreeNodeSchemaNonClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
867
+ export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
890
868
  // (undocumented)
891
869
  create(data: TInsertable): TNode;
892
870
  }
893
871
 
894
- // @public
895
- type TreeNodeSchemaUnsafe<Name extends string = string, Kind extends NodeKind = NodeKind, TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
896
-
897
872
  // @public
898
873
  export type TreeObjectNode<T extends RestrictiveStringRecord<ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
899
874
 
@@ -909,7 +884,7 @@ export enum TreeStatus {
909
884
  }
910
885
 
911
886
  // @public @sealed
912
- export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
887
+ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
913
888
  readonly compatibility: SchemaCompatibilityStatus;
914
889
  readonly events: Listenable<TreeViewEvents>;
915
890
  initialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;
@@ -968,7 +943,7 @@ export interface ViewableTree {
968
943
  export interface WithType<out TName extends string = string, out TKind extends NodeKind = NodeKind, out TInfo = unknown> {
969
944
  // @deprecated
970
945
  get [typeNameSymbol](): TName;
971
- get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode | TreeLeafValue, never, boolean, TInfo>;
946
+ get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
972
947
  }
973
948
 
974
949
  ```
package/dist/alpha.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
@@ -134,15 +132,10 @@ export {
134
132
  TreeChangeEventsBeta,
135
133
 
136
134
  // @alpha APIs
137
- FactoryContent,
138
- FactoryContentObject,
139
135
  FixRecursiveArraySchema,
140
136
  ForestOptions,
141
137
  ForestType,
142
138
  ICodecOptions,
143
- Insertable,
144
- InsertableContent,
145
- InsertableField,
146
139
  JsonArrayNodeSchema,
147
140
  JsonCompatible,
148
141
  JsonCompatibleObject,
@@ -166,8 +159,6 @@ export {
166
159
  TreeBranch,
167
160
  TreeBranchFork,
168
161
  TreeCompressionStrategy,
169
- TreeViewAlpha,
170
- UnsafeUnknownSchema,
171
162
  adaptEnum,
172
163
  comparePersistedSchema,
173
164
  configuredSharedTree,
package/dist/beta.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
package/dist/legacy.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
package/dist/public.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
package/lib/alpha.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
@@ -134,15 +132,10 @@ export {
134
132
  TreeChangeEventsBeta,
135
133
 
136
134
  // @alpha APIs
137
- FactoryContent,
138
- FactoryContentObject,
139
135
  FixRecursiveArraySchema,
140
136
  ForestOptions,
141
137
  ForestType,
142
138
  ICodecOptions,
143
- Insertable,
144
- InsertableContent,
145
- InsertableField,
146
139
  JsonArrayNodeSchema,
147
140
  JsonCompatible,
148
141
  JsonCompatibleObject,
@@ -166,8 +159,6 @@ export {
166
159
  TreeBranch,
167
160
  TreeBranchFork,
168
161
  TreeCompressionStrategy,
169
- TreeViewAlpha,
170
- UnsafeUnknownSchema,
171
162
  adaptEnum,
172
163
  comparePersistedSchema,
173
164
  configuredSharedTree,
package/lib/beta.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
package/lib/legacy.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
package/lib/public.d.ts CHANGED
@@ -81,7 +81,6 @@ export {
81
81
  NodeInDocumentConstraint,
82
82
  NodeKind,
83
83
  Off,
84
- ReadonlyArrayNode,
85
84
  ReplaceIEventThisPlaceHolder,
86
85
  RestrictiveReadonlyRecord,
87
86
  RestrictiveStringRecord,
@@ -110,7 +109,6 @@ export {
110
109
  TreeNodeFromImplicitAllowedTypes,
111
110
  TreeNodeSchema,
112
111
  TreeNodeSchemaClass,
113
- TreeNodeSchemaClassUnsafe,
114
112
  TreeNodeSchemaCore,
115
113
  TreeNodeSchemaNonClass,
116
114
  TreeObjectNode,
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "fluid-framework",
3
- "version": "2.4.0-299374",
3
+ "version": "2.4.0-299707",
4
4
  "description": "The main entry point into Fluid Framework public packages",
5
5
  "homepage": "https://fluidframework.com",
6
6
  "repository": {
@@ -57,19 +57,19 @@
57
57
  "main": "lib/index.js",
58
58
  "types": "lib/public.d.ts",
59
59
  "dependencies": {
60
- "@fluidframework/container-definitions": "2.4.0-299374",
61
- "@fluidframework/container-loader": "2.4.0-299374",
62
- "@fluidframework/core-interfaces": "2.4.0-299374",
63
- "@fluidframework/driver-definitions": "2.4.0-299374",
64
- "@fluidframework/fluid-static": "2.4.0-299374",
65
- "@fluidframework/map": "2.4.0-299374",
66
- "@fluidframework/runtime-utils": "2.4.0-299374",
67
- "@fluidframework/sequence": "2.4.0-299374",
68
- "@fluidframework/shared-object-base": "2.4.0-299374",
69
- "@fluidframework/tree": "2.4.0-299374"
60
+ "@fluidframework/container-definitions": "2.4.0-299707",
61
+ "@fluidframework/container-loader": "2.4.0-299707",
62
+ "@fluidframework/core-interfaces": "2.4.0-299707",
63
+ "@fluidframework/driver-definitions": "2.4.0-299707",
64
+ "@fluidframework/fluid-static": "2.4.0-299707",
65
+ "@fluidframework/map": "2.4.0-299707",
66
+ "@fluidframework/runtime-utils": "2.4.0-299707",
67
+ "@fluidframework/sequence": "2.4.0-299707",
68
+ "@fluidframework/shared-object-base": "2.4.0-299707",
69
+ "@fluidframework/tree": "2.4.0-299707"
70
70
  },
71
71
  "devDependencies": {
72
- "@arethetypeswrong/cli": "^0.15.2",
72
+ "@arethetypeswrong/cli": "^0.16.4",
73
73
  "@biomejs/biome": "~1.8.3",
74
74
  "@fluid-tools/build-cli": "^0.48.0",
75
75
  "@fluidframework/build-common": "^2.0.3",