fluid-framework 2.4.0-299374 → 2.4.0

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 (15) hide show
  1. package/CHANGELOG.md +111 -0
  2. package/api-report/fluid-framework.alpha.api.md +23 -79
  3. package/api-report/fluid-framework.beta.api.md +23 -47
  4. package/api-report/fluid-framework.legacy.alpha.api.md +21 -46
  5. package/api-report/fluid-framework.legacy.public.api.md +21 -46
  6. package/api-report/fluid-framework.public.api.md +21 -46
  7. package/dist/alpha.d.ts +0 -9
  8. package/dist/beta.d.ts +0 -2
  9. package/dist/legacy.d.ts +0 -2
  10. package/dist/public.d.ts +0 -2
  11. package/lib/alpha.d.ts +0 -9
  12. package/lib/beta.d.ts +0 -2
  13. package/lib/legacy.d.ts +0 -2
  14. package/lib/public.d.ts +0 -2
  15. package/package.json +12 -12
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,