fluid-framework 2.4.0 → 2.5.0-302463

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 +148 -51
  2. package/api-report/fluid-framework.beta.api.md +83 -38
  3. package/api-report/fluid-framework.legacy.alpha.api.md +83 -38
  4. package/api-report/fluid-framework.legacy.public.api.md +83 -38
  5. package/api-report/fluid-framework.public.api.md +83 -38
  6. package/dist/alpha.d.ts +17 -2
  7. package/dist/beta.d.ts +6 -0
  8. package/dist/legacy.d.ts +6 -0
  9. package/dist/public.d.ts +6 -0
  10. package/lib/alpha.d.ts +17 -2
  11. package/lib/beta.d.ts +6 -0
  12. package/lib/legacy.d.ts +6 -0
  13. package/lib/public.d.ts +6 -0
  14. package/package.json +14 -14
package/api-report/fluid-framework.beta.api.md CHANGED
@@ -8,12 +8,20 @@
8
8
  export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
9
9
 
10
10
  // @public
11
- type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
11
+ type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
12
+
13
+ // @public
14
+ type ApplyKind<T, Kind extends FieldKind> = {
12
15
  [FieldKind.Required]: T;
13
16
  [FieldKind.Optional]: T | undefined;
14
- [FieldKind.Identifier]: DefaultsAreOptional extends true ? T | undefined : T;
17
+ [FieldKind.Identifier]: T;
15
18
  }[Kind];
16
19
 
20
+ // @public
21
+ type ApplyKindInput<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = [
22
+ Kind
23
+ ] extends [FieldKind.Required] ? T : [Kind] extends [FieldKind.Optional] ? T | undefined : [Kind] extends [FieldKind.Identifier] ? DefaultsAreOptional extends true ? T | undefined : T : never;
24
+
17
25
  // @public
18
26
  export enum AttachState {
19
27
  Attached = "Attached",
@@ -405,11 +413,14 @@ export type InitialObjects<T extends ContainerSchema> = {
405
413
  // @public
406
414
  type _InlineTrick = 0;
407
415
 
416
+ // @public
417
+ export type Input<T extends never> = T;
418
+
408
419
  // @public
409
420
  type InsertableObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> = FlattenKeys<{
410
- readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<T[Property] & string>;
421
+ readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<T[Property & string]>;
411
422
  } & {
412
- readonly [Property in keyof T as FieldHasDefault<T[Property] & string> extends false ? Property : never]: InsertableTreeFieldFromImplicitField<T[Property] & string>;
423
+ readonly [Property in keyof T as FieldHasDefault<T[Property & string]> extends false ? Property : never]: InsertableTreeFieldFromImplicitField<T[Property & string]>;
413
424
  }>;
414
425
 
415
426
  // @public
@@ -420,28 +431,36 @@ export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<Restrict
420
431
  };
421
432
 
422
433
  // @public
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;
434
+ export type InsertableTreeFieldFromImplicitField<TSchemaInput extends ImplicitFieldSchema, TSchema = UnionToIntersection<TSchemaInput>> = [TSchema] extends [FieldSchema<infer Kind, infer Types>] ? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : [TSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
435
+
436
+ // @public
437
+ export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchemaInput extends Unenforced<ImplicitFieldSchema>, TSchema = UnionToIntersection<TSchemaInput>> = [TSchema] extends [FieldSchemaUnsafe<infer Kind, infer Types>] ? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : [TSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : never;
438
+
439
+ // @public
440
+ export type InsertableTreeNodeFromAllowedTypes<TList extends AllowedTypes> = TList extends readonly [
441
+ LazyItem<infer TSchema extends TreeNodeSchema>,
442
+ ...infer Rest extends AllowedTypes
443
+ ] ? InsertableTypedNode<TSchema> | InsertableTreeNodeFromAllowedTypes<Rest> : never;
424
444
 
425
445
  // @public
426
- export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
446
+ export type InsertableTreeNodeFromAllowedTypesUnsafe<TList extends Unenforced<AllowedTypesUnsafe>> = TList extends readonly [
447
+ LazyItem<infer TSchema extends TreeNodeSchemaUnsafe>,
448
+ ...infer Rest extends AllowedTypesUnsafe
449
+ ] ? InsertableTypedNodeUnsafe<TSchema> | InsertableTreeNodeFromAllowedTypesUnsafe<Rest> : never;
427
450
 
428
451
  // @public
429
- export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
452
+ export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes> = [
453
+ TSchema
454
+ ] extends [TreeNodeSchema] ? InsertableTypedNode<TSchema> : [TSchema] extends [AllowedTypes] ? InsertableTreeNodeFromAllowedTypes<TSchema> : never;
430
455
 
431
456
  // @public
432
- export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
457
+ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = [TSchema] extends [TreeNodeSchemaUnsafe] ? InsertableTypedNodeUnsafe<TSchema> : [TSchema] extends [AllowedTypesUnsafe] ? InsertableTreeNodeFromAllowedTypesUnsafe<TSchema> : never;
433
458
 
434
459
  // @public
435
- export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
436
- implicitlyConstructable: true;
437
- } ? NodeBuilderData<T> : never) | Unhydrated<NodeFromSchema<T>>;
460
+ export type InsertableTypedNode<TSchema extends TreeNodeSchema, T = UnionToIntersection<TSchema>> = (T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, never, true> ? NodeBuilderData<T> : never) | (T extends TreeNodeSchema ? Unhydrated<TreeNode extends NodeFromSchema<T> ? never : NodeFromSchema<T>> : never);
438
461
 
439
462
  // @public
440
- type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
441
- Unhydrated<NodeFromSchemaUnsafe<T>> | (T extends {
442
- implicitlyConstructable: true;
443
- } ? NodeBuilderDataUnsafe<T> : never)
444
- ][_InlineTrick];
463
+ type InsertableTypedNodeUnsafe<TSchema extends Unenforced<TreeNodeSchemaUnsafe>, T = UnionToIntersection<TSchema>> = (T extends TreeNodeSchemaUnsafe<string, NodeKind, TreeNode | TreeLeafValue, never, true> ? NodeBuilderDataUnsafe<T> : never) | (T extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<T> : never);
445
464
 
446
465
  // @public @sealed
447
466
  export interface InternalTreeNode extends ErasedType<"@fluidframework/tree.InternalTreeNode"> {
@@ -452,6 +471,7 @@ declare namespace InternalTypes {
452
471
  _InlineTrick,
453
472
  FlattenKeys,
454
473
  ApplyKind,
474
+ ApplyKindInput,
455
475
  NodeBuilderData,
456
476
  FieldHasDefault,
457
477
  TreeArrayNodeBase,
@@ -474,6 +494,9 @@ declare namespace InternalTypes {
474
494
  NodeBuilderDataUnsafe,
475
495
  NodeFromSchemaUnsafe,
476
496
  ReadonlyMapInlined,
497
+ TreeNodeSchemaUnsafe,
498
+ AllowedTypesUnsafe,
499
+ TreeNodeSchemaNonClassUnsafe,
477
500
  FlexList,
478
501
  FlexListToUnion,
479
502
  ExtractItemType,
@@ -564,10 +587,10 @@ export type Myself<M extends IMember = IMember> = M & {
564
587
  };
565
588
 
566
589
  // @public
567
- type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
590
+ type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, infer TBuild> ? TBuild : never;
568
591
 
569
592
  // @public
570
- type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
593
+ type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
571
594
 
572
595
  // @beta @sealed
573
596
  export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
@@ -578,7 +601,7 @@ export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
578
601
  export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
579
602
 
580
603
  // @public
581
- type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
604
+ type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
582
605
 
583
606
  // @public
584
607
  export interface NodeInDocumentConstraint {
@@ -609,6 +632,10 @@ type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveStringRecord<I
609
632
  // @public
610
633
  export type Off = () => void;
611
634
 
635
+ // @public @sealed
636
+ export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends ReadonlyArray<T>, Awaited<TreeNode & WithType<string, NodeKind.Array>> {
637
+ }
638
+
612
639
  // @public @sealed
613
640
  interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {
614
641
  [Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
@@ -665,17 +692,17 @@ export const rollback: unique symbol;
665
692
  // @public @sealed
666
693
  export interface RunTransaction {
667
694
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult): TResult;
668
- <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
695
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
669
696
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback): TResult | typeof rollback;
670
- <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
697
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
671
698
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;
672
- <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void): void;
699
+ <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
673
700
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
674
- <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
701
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
675
702
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => 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;
703
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
677
704
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void, preconditions?: readonly TransactionConstraint[]): void;
678
- <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
705
+ <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
679
706
  readonly rollback: typeof rollback;
680
707
  }
681
708
 
@@ -709,7 +736,7 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
709
736
  readonly null: TreeNodeSchema<"com.fluidframework.leaf.null", NodeKind.Leaf, null, null>;
710
737
  readonly number: TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
711
738
  object<const Name extends TName, const T extends RestrictiveStringRecord<ImplicitFieldSchema>>(name: Name, fields: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNode<T, ScopedSchemaName<TScope, Name>>, object & InsertableObjectFromSchemaRecord<T>, true, T>;
712
- objectRecursive<const Name extends TName, const T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>>(name: Name, t: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & { readonly [Property in keyof T as FieldHasDefaultUnsafe<T[Property]> extends false ? Property : never]: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property]>; } & { readonly [Property_1 in keyof T as FieldHasDefaultUnsafe<T[Property_1]> extends true ? Property_1 : never]?: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property_1]> | undefined; }, false, T>;
739
+ objectRecursive<const Name extends TName, const T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>>(name: Name, t: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & { readonly [Property in keyof T as FieldHasDefaultUnsafe<T[Property]> extends false ? Property : never]: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property], UnionToIntersection_2<T[Property]>>; } & { readonly [Property_1 in keyof T as FieldHasDefaultUnsafe<T[Property_1]> extends true ? Property_1 : never]?: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property_1], UnionToIntersection_2<T[Property_1]>> | undefined; }, false, T>;
713
740
  optional<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">): FieldSchema<FieldKind.Optional, T, TCustomMetadata>;
714
741
  optionalRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(t: T, props?: Omit<FieldProps, "defaultProvider">): FieldSchemaUnsafe<FieldKind.Optional, T>;
715
742
  required<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">): FieldSchema<FieldKind.Required, T, TCustomMetadata>;
@@ -757,7 +784,7 @@ interface TreeApi extends TreeNodeApi {
757
784
  }
758
785
 
759
786
  // @public @sealed
760
- export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
787
+ export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>> {
761
788
  }
762
789
 
763
790
  // @public
@@ -766,7 +793,7 @@ export const TreeArrayNode: {
766
793
  };
767
794
 
768
795
  // @public @sealed
769
- interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
796
+ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
770
797
  insertAt(index: number, ...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
771
798
  insertAtEnd(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
772
799
  insertAtStart(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
@@ -788,7 +815,7 @@ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<
788
815
  }
789
816
 
790
817
  // @public @sealed
791
- export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
818
+ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>> {
792
819
  }
793
820
 
794
821
  // @beta @sealed
@@ -809,10 +836,10 @@ export interface TreeChangeEventsBeta<TNode extends TreeNode = TreeNode> extends
809
836
  }
810
837
 
811
838
  // @public
812
- 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;
839
+ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
813
840
 
814
841
  // @public
815
- type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, false> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
842
+ type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
816
843
 
817
844
  // @public
818
845
  export type TreeLeafValue = number | string | boolean | IFluidHandle | null;
@@ -858,13 +885,19 @@ export interface TreeNodeApi {
858
885
  export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
859
886
 
860
887
  // @public
861
- type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
888
+ type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<TSchema> : TSchema extends AllowedTypesUnsafe ? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>> : unknown;
862
889
 
863
890
  // @public @sealed
864
- 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>;
891
+ 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>;
865
892
 
866
893
  // @public @sealed
867
- 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> {
894
+ 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> {
895
+ // @sealed
896
+ new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
897
+ }
898
+
899
+ // @public
900
+ export interface TreeNodeSchemaClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable, out ImplicitlyConstructable extends boolean, out Info> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
868
901
  // @sealed
869
902
  new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
870
903
  }
@@ -880,11 +913,20 @@ export interface TreeNodeSchemaCore<out Name extends string, out Kind extends No
880
913
  }
881
914
 
882
915
  // @public @sealed
883
- 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> {
916
+ 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
917
  // (undocumented)
885
918
  create(data: TInsertable): TNode;
886
919
  }
887
920
 
921
+ // @public
922
+ interface TreeNodeSchemaNonClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable, out ImplicitlyConstructable extends boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
923
+ // (undocumented)
924
+ create(data: TInsertable): TNode;
925
+ }
926
+
927
+ // @public
928
+ 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>;
929
+
888
930
  // @public
889
931
  export type TreeObjectNode<T extends RestrictiveStringRecord<ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
890
932
 
@@ -900,7 +942,7 @@ export enum TreeStatus {
900
942
  }
901
943
 
902
944
  // @public @sealed
903
- export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
945
+ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
904
946
  readonly compatibility: SchemaCompatibilityStatus;
905
947
  readonly events: Listenable<TreeViewEvents>;
906
948
  initialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;
@@ -911,7 +953,7 @@ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposab
911
953
  }
912
954
 
913
955
  // @public @sealed
914
- export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema> implements Required<ITreeViewConfiguration<TSchema>> {
956
+ export class TreeViewConfiguration<const TSchema extends ImplicitFieldSchema = ImplicitFieldSchema> implements Required<ITreeViewConfiguration<TSchema>> {
915
957
  constructor(props: ITreeViewConfiguration<TSchema>);
916
958
  readonly enableSchemaValidation: boolean;
917
959
  readonly preventAmbiguity: boolean;
@@ -939,6 +981,9 @@ export type Unenforced<_DesiredExtendsConstraint> = unknown;
939
981
  // @public
940
982
  export type Unhydrated<T> = T;
941
983
 
984
+ // @public
985
+ export type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) extends (k: infer U) => unknown ? U : never;
986
+
942
987
  // @public
943
988
  export type ValidateRecursiveSchema<T extends TreeNodeSchemaClass<string, NodeKind.Array | NodeKind.Map | NodeKind.Object, TreeNode & WithType<T["identifier"], T["kind"]>, {
944
989
  [NodeKind.Object]: T["info"] extends RestrictiveStringRecord<ImplicitFieldSchema> ? InsertableObjectFromSchemaRecord<T["info"]> : unknown;
@@ -959,7 +1004,7 @@ export interface ViewableTree {
959
1004
  export interface WithType<out TName extends string = string, out TKind extends NodeKind = NodeKind, out TInfo = unknown> {
960
1005
  // @deprecated
961
1006
  get [typeNameSymbol](): TName;
962
- get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
1007
+ get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode | TreeLeafValue, never, boolean, TInfo>;
963
1008
  }
964
1009
 
965
1010
  ```
package/api-report/fluid-framework.legacy.alpha.api.md CHANGED
@@ -8,12 +8,20 @@
8
8
  export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
9
9
 
10
10
  // @public
11
- type ApplyKind<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = {
11
+ type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
12
+
13
+ // @public
14
+ type ApplyKind<T, Kind extends FieldKind> = {
12
15
  [FieldKind.Required]: T;
13
16
  [FieldKind.Optional]: T | undefined;
14
- [FieldKind.Identifier]: DefaultsAreOptional extends true ? T | undefined : T;
17
+ [FieldKind.Identifier]: T;
15
18
  }[Kind];
16
19
 
20
+ // @public
21
+ type ApplyKindInput<T, Kind extends FieldKind, DefaultsAreOptional extends boolean> = [
22
+ Kind
23
+ ] extends [FieldKind.Required] ? T : [Kind] extends [FieldKind.Optional] ? T | undefined : [Kind] extends [FieldKind.Identifier] ? DefaultsAreOptional extends true ? T | undefined : T : never;
24
+
17
25
  // @public
18
26
  export enum AttachState {
19
27
  Attached = "Attached",
@@ -505,11 +513,14 @@ export type InitialObjects<T extends ContainerSchema> = {
505
513
  // @public
506
514
  type _InlineTrick = 0;
507
515
 
516
+ // @public
517
+ export type Input<T extends never> = T;
518
+
508
519
  // @public
509
520
  type InsertableObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> = FlattenKeys<{
510
- readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<T[Property] & string>;
521
+ readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<T[Property & string]>;
511
522
  } & {
512
- readonly [Property in keyof T as FieldHasDefault<T[Property] & string> extends false ? Property : never]: InsertableTreeFieldFromImplicitField<T[Property] & string>;
523
+ readonly [Property in keyof T as FieldHasDefault<T[Property & string]> extends false ? Property : never]: InsertableTreeFieldFromImplicitField<T[Property & string]>;
513
524
  }>;
514
525
 
515
526
  // @public
@@ -520,28 +531,36 @@ export type InsertableObjectFromSchemaRecordUnsafe<T extends Unenforced<Restrict
520
531
  };
521
532
 
522
533
  // @public
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;
534
+ export type InsertableTreeFieldFromImplicitField<TSchemaInput extends ImplicitFieldSchema, TSchema = UnionToIntersection<TSchemaInput>> = [TSchema] extends [FieldSchema<infer Kind, infer Types>] ? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true> : [TSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TSchema> : never;
535
+
536
+ // @public
537
+ export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchemaInput extends Unenforced<ImplicitFieldSchema>, TSchema = UnionToIntersection<TSchemaInput>> = [TSchema] extends [FieldSchemaUnsafe<infer Kind, infer Types>] ? ApplyKindInput<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : [TSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : never;
538
+
539
+ // @public
540
+ export type InsertableTreeNodeFromAllowedTypes<TList extends AllowedTypes> = TList extends readonly [
541
+ LazyItem<infer TSchema extends TreeNodeSchema>,
542
+ ...infer Rest extends AllowedTypes
543
+ ] ? InsertableTypedNode<TSchema> | InsertableTreeNodeFromAllowedTypes<Rest> : never;
524
544
 
525
545
  // @public
526
- export type InsertableTreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind, true> : InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema>;
546
+ export type InsertableTreeNodeFromAllowedTypesUnsafe<TList extends Unenforced<AllowedTypesUnsafe>> = TList extends readonly [
547
+ LazyItem<infer TSchema extends TreeNodeSchemaUnsafe>,
548
+ ...infer Rest extends AllowedTypesUnsafe
549
+ ] ? InsertableTypedNodeUnsafe<TSchema> | InsertableTreeNodeFromAllowedTypesUnsafe<Rest> : never;
527
550
 
528
551
  // @public
529
- export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? InsertableTypedNode<TSchema> : TSchema extends AllowedTypes ? InsertableTypedNode<FlexListToUnion<TSchema>> : never;
552
+ export type InsertableTreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes> = [
553
+ TSchema
554
+ ] extends [TreeNodeSchema] ? InsertableTypedNode<TSchema> : [TSchema] extends [AllowedTypes] ? InsertableTreeNodeFromAllowedTypes<TSchema> : never;
530
555
 
531
556
  // @public
532
- export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends AllowedTypes ? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>> : InsertableTypedNodeUnsafe<TSchema>;
557
+ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = [TSchema] extends [TreeNodeSchemaUnsafe] ? InsertableTypedNodeUnsafe<TSchema> : [TSchema] extends [AllowedTypesUnsafe] ? InsertableTreeNodeFromAllowedTypesUnsafe<TSchema> : never;
533
558
 
534
559
  // @public
535
- export type InsertableTypedNode<T extends TreeNodeSchema> = (T extends {
536
- implicitlyConstructable: true;
537
- } ? NodeBuilderData<T> : never) | Unhydrated<NodeFromSchema<T>>;
560
+ export type InsertableTypedNode<TSchema extends TreeNodeSchema, T = UnionToIntersection<TSchema>> = (T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, never, true> ? NodeBuilderData<T> : never) | (T extends TreeNodeSchema ? Unhydrated<TreeNode extends NodeFromSchema<T> ? never : NodeFromSchema<T>> : never);
538
561
 
539
562
  // @public
540
- type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
541
- Unhydrated<NodeFromSchemaUnsafe<T>> | (T extends {
542
- implicitlyConstructable: true;
543
- } ? NodeBuilderDataUnsafe<T> : never)
544
- ][_InlineTrick];
563
+ type InsertableTypedNodeUnsafe<TSchema extends Unenforced<TreeNodeSchemaUnsafe>, T = UnionToIntersection<TSchema>> = (T extends TreeNodeSchemaUnsafe<string, NodeKind, TreeNode | TreeLeafValue, never, true> ? NodeBuilderDataUnsafe<T> : never) | (T extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<T> : never);
545
564
 
546
565
  export { InteriorSequencePlace }
547
566
 
@@ -554,6 +573,7 @@ declare namespace InternalTypes {
554
573
  _InlineTrick,
555
574
  FlattenKeys,
556
575
  ApplyKind,
576
+ ApplyKindInput,
557
577
  NodeBuilderData,
558
578
  FieldHasDefault,
559
579
  TreeArrayNodeBase,
@@ -576,6 +596,9 @@ declare namespace InternalTypes {
576
596
  NodeBuilderDataUnsafe,
577
597
  NodeFromSchemaUnsafe,
578
598
  ReadonlyMapInlined,
599
+ TreeNodeSchemaUnsafe,
600
+ AllowedTypesUnsafe,
601
+ TreeNodeSchemaNonClassUnsafe,
579
602
  FlexList,
580
603
  FlexListToUnion,
581
604
  ExtractItemType,
@@ -870,16 +893,16 @@ export type Myself<M extends IMember = IMember> = M & {
870
893
  };
871
894
 
872
895
  // @public
873
- type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
896
+ type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, TreeNode | TreeLeafValue, infer TBuild> ? TBuild : never;
874
897
 
875
898
  // @public
876
- type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
899
+ type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
877
900
 
878
901
  // @public
879
902
  export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
880
903
 
881
904
  // @public
882
- type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
905
+ type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> = T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
883
906
 
884
907
  // @public
885
908
  export interface NodeInDocumentConstraint {
@@ -910,6 +933,10 @@ type ObjectFromSchemaRecordUnsafe<T extends Unenforced<RestrictiveStringRecord<I
910
933
  // @public
911
934
  export type Off = () => void;
912
935
 
936
+ // @public @sealed
937
+ export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue> extends ReadonlyArray<T>, Awaited<TreeNode & WithType<string, NodeKind.Array>> {
938
+ }
939
+
913
940
  // @public @sealed
914
941
  interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes>> {
915
942
  [Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
@@ -966,17 +993,17 @@ export const rollback: unique symbol;
966
993
  // @public @sealed
967
994
  export interface RunTransaction {
968
995
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult): TResult;
969
- <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
996
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult): TResult;
970
997
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult | typeof rollback): TResult | typeof rollback;
971
- <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
998
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback): TResult | typeof rollback;
972
999
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;
973
- <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void): void;
1000
+ <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
974
1001
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
975
- <TView extends TreeView<ImplicitFieldSchema>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
1002
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult, preconditions?: readonly TransactionConstraint[]): TResult;
976
1003
  <TNode extends TreeNode, TResult>(node: TNode, transaction: (node: TNode) => 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;
1004
+ <TView extends TreeView<any>, TResult>(tree: TView, transaction: (root: TView["root"]) => TResult | typeof rollback, preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
978
1005
  <TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void, preconditions?: readonly TransactionConstraint[]): void;
979
- <TView extends TreeView<ImplicitFieldSchema>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
1006
+ <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
980
1007
  readonly rollback: typeof rollback;
981
1008
  }
982
1009
 
@@ -1010,7 +1037,7 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
1010
1037
  readonly null: TreeNodeSchema<"com.fluidframework.leaf.null", NodeKind.Leaf, null, null>;
1011
1038
  readonly number: TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
1012
1039
  object<const Name extends TName, const T extends RestrictiveStringRecord<ImplicitFieldSchema>>(name: Name, fields: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNode<T, ScopedSchemaName<TScope, Name>>, object & InsertableObjectFromSchemaRecord<T>, true, T>;
1013
- objectRecursive<const Name extends TName, const T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>>(name: Name, t: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & { readonly [Property in keyof T as FieldHasDefaultUnsafe<T[Property]> extends false ? Property : never]: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property]>; } & { readonly [Property_1 in keyof T as FieldHasDefaultUnsafe<T[Property_1]> extends true ? Property_1 : never]?: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property_1]> | undefined; }, false, T>;
1040
+ objectRecursive<const Name extends TName, const T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>>(name: Name, t: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & { readonly [Property in keyof T as FieldHasDefaultUnsafe<T[Property]> extends false ? Property : never]: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property], UnionToIntersection_2<T[Property]>>; } & { readonly [Property_1 in keyof T as FieldHasDefaultUnsafe<T[Property_1]> extends true ? Property_1 : never]?: InsertableTreeFieldFromImplicitFieldUnsafe<T[Property_1], UnionToIntersection_2<T[Property_1]>> | undefined; }, false, T>;
1014
1041
  optional<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">): FieldSchema<FieldKind.Optional, T, TCustomMetadata>;
1015
1042
  optionalRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(t: T, props?: Omit<FieldProps, "defaultProvider">): FieldSchemaUnsafe<FieldKind.Optional, T>;
1016
1043
  required<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">): FieldSchema<FieldKind.Required, T, TCustomMetadata>;
@@ -1153,7 +1180,7 @@ interface TreeApi extends TreeNodeApi {
1153
1180
  }
1154
1181
 
1155
1182
  // @public @sealed
1156
- export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
1183
+ export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>> {
1157
1184
  }
1158
1185
 
1159
1186
  // @public
@@ -1162,7 +1189,7 @@ export const TreeArrayNode: {
1162
1189
  };
1163
1190
 
1164
1191
  // @public @sealed
1165
- interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<T>, TreeNode {
1192
+ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode> extends ReadonlyArrayNode<T> {
1166
1193
  insertAt(index: number, ...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
1167
1194
  insertAtEnd(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
1168
1195
  insertAtStart(...value: readonly (TNew | IterableTreeArrayContent<TNew>)[]): void;
@@ -1184,7 +1211,7 @@ interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends ReadonlyArray<
1184
1211
  }
1185
1212
 
1186
1213
  // @public @sealed
1187
- export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, TreeArrayNode> {
1214
+ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>> extends TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>> {
1188
1215
  }
1189
1216
 
1190
1217
  // @public @sealed
@@ -1194,10 +1221,10 @@ export interface TreeChangeEvents {
1194
1221
  }
1195
1222
 
1196
1223
  // @public
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;
1224
+ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> = TSchema extends FieldSchema<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TreeNode | TreeLeafValue | undefined;
1198
1225
 
1199
1226
  // @public
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;
1227
+ type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> = TSchema extends FieldSchemaUnsafe<infer Kind, infer Types> ? ApplyKind<TreeNodeFromImplicitAllowedTypesUnsafe<Types>, Kind> : TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema> : unknown;
1201
1228
 
1202
1229
  // @public
1203
1230
  export type TreeLeafValue = number | string | boolean | IFluidHandle | null;
@@ -1243,13 +1270,19 @@ export interface TreeNodeApi {
1243
1270
  export type TreeNodeFromImplicitAllowedTypes<TSchema extends ImplicitAllowedTypes = TreeNodeSchema> = TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
1244
1271
 
1245
1272
  // @public
1246
- type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends ImplicitAllowedTypes ? TreeNodeFromImplicitAllowedTypes<TSchema> : TSchema extends TreeNodeSchema ? NodeFromSchema<TSchema> : TSchema extends AllowedTypes ? NodeFromSchema<FlexListToUnion<TSchema>> : unknown;
1273
+ type TreeNodeFromImplicitAllowedTypesUnsafe<TSchema extends Unenforced<ImplicitAllowedTypes>> = TSchema extends TreeNodeSchemaUnsafe ? NodeFromSchemaUnsafe<TSchema> : TSchema extends AllowedTypesUnsafe ? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>> : unknown;
1247
1274
 
1248
1275
  // @public @sealed
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>;
1276
+ 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>;
1250
1277
 
1251
1278
  // @public @sealed
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> {
1279
+ 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> {
1280
+ // @sealed
1281
+ new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
1282
+ }
1283
+
1284
+ // @public
1285
+ export interface TreeNodeSchemaClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable, out ImplicitlyConstructable extends boolean, out Info> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1253
1286
  // @sealed
1254
1287
  new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
1255
1288
  }
@@ -1265,11 +1298,20 @@ export interface TreeNodeSchemaCore<out Name extends string, out Kind extends No
1265
1298
  }
1266
1299
 
1267
1300
  // @public @sealed
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> {
1301
+ 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> {
1269
1302
  // (undocumented)
1270
1303
  create(data: TInsertable): TNode;
1271
1304
  }
1272
1305
 
1306
+ // @public
1307
+ interface TreeNodeSchemaNonClassUnsafe<out Name extends string, out Kind extends NodeKind, out TNode extends Unenforced<TreeNode | TreeLeafValue>, in TInsertable, out ImplicitlyConstructable extends boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
1308
+ // (undocumented)
1309
+ create(data: TInsertable): TNode;
1310
+ }
1311
+
1312
+ // @public
1313
+ 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>;
1314
+
1273
1315
  // @public
1274
1316
  export type TreeObjectNode<T extends RestrictiveStringRecord<ImplicitFieldSchema>, TypeName extends string = string> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
1275
1317
 
@@ -1285,7 +1327,7 @@ export enum TreeStatus {
1285
1327
  }
1286
1328
 
1287
1329
  // @public @sealed
1288
- export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
1330
+ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
1289
1331
  readonly compatibility: SchemaCompatibilityStatus;
1290
1332
  readonly events: Listenable<TreeViewEvents>;
1291
1333
  initialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;
@@ -1296,7 +1338,7 @@ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposab
1296
1338
  }
1297
1339
 
1298
1340
  // @public @sealed
1299
- export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema> implements Required<ITreeViewConfiguration<TSchema>> {
1341
+ export class TreeViewConfiguration<const TSchema extends ImplicitFieldSchema = ImplicitFieldSchema> implements Required<ITreeViewConfiguration<TSchema>> {
1300
1342
  constructor(props: ITreeViewConfiguration<TSchema>);
1301
1343
  readonly enableSchemaValidation: boolean;
1302
1344
  readonly preventAmbiguity: boolean;
@@ -1324,6 +1366,9 @@ export type Unenforced<_DesiredExtendsConstraint> = unknown;
1324
1366
  // @public
1325
1367
  export type Unhydrated<T> = T;
1326
1368
 
1369
+ // @public
1370
+ export type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) extends (k: infer U) => unknown ? U : never;
1371
+
1327
1372
  // @public
1328
1373
  export type ValidateRecursiveSchema<T extends TreeNodeSchemaClass<string, NodeKind.Array | NodeKind.Map | NodeKind.Object, TreeNode & WithType<T["identifier"], T["kind"]>, {
1329
1374
  [NodeKind.Object]: T["info"] extends RestrictiveStringRecord<ImplicitFieldSchema> ? InsertableObjectFromSchemaRecord<T["info"]> : unknown;
@@ -1344,7 +1389,7 @@ export interface ViewableTree {
1344
1389
  export interface WithType<out TName extends string = string, out TKind extends NodeKind = NodeKind, out TInfo = unknown> {
1345
1390
  // @deprecated
1346
1391
  get [typeNameSymbol](): TName;
1347
- get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
1392
+ get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, TreeNode | TreeLeafValue, never, boolean, TInfo>;
1348
1393
  }
1349
1394
 
1350
1395
  ```