fluid-framework 2.51.0 → 2.53.0-350190

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 (9) hide show
  1. package/CHANGELOG.md +43 -0
  2. package/api-report/fluid-framework.alpha.api.md +52 -38
  3. package/api-report/fluid-framework.beta.api.md +12 -8
  4. package/api-report/fluid-framework.legacy.alpha.api.md +12 -8
  5. package/api-report/fluid-framework.legacy.public.api.md +12 -8
  6. package/api-report/fluid-framework.public.api.md +12 -8
  7. package/dist/alpha.d.ts +2 -1
  8. package/lib/alpha.d.ts +2 -1
  9. package/package.json +14 -14
package/CHANGELOG.md CHANGED
@@ -1,5 +1,48 @@
1
1
  # fluid-framework
2
2
 
3
+ ## 2.52.0
4
+
5
+ ### Minor Changes
6
+
7
+ - Change and clarify limitations related to alpha features allowUnknownOptionalFields and importVerbose ([#25074](https://github.com/microsoft/FluidFramework/pull/25074)) [62dc0b0095](https://github.com/microsoft/FluidFramework/commit/62dc0b0095226ade66648f6fd6b4f13b8c7880d8)
8
+
9
+ [allowUnknownOptionalFields](https://fluidframework.com/docs/api/fluid-framework/schemafactoryobjectoptions-interface#allowunknownoptionalfields-propertysignature) currently has some limitations.
10
+ To mitigate some bugs, [importVerbose](https://fluidframework.com/docs/api/fluid-framework/treealpha-interface#importverbose-methodsignature) has dropped support for unknown optional fields.
11
+ Previously `importVerbose` would tolerate some unknown optional fields, but could not validate they comply with the document stored schema.
12
+ This could cause some crashes, and likely document corruption.
13
+ This support has been removed: now trying to create nodes containing unknown optional fields via `importVerbose` will throw a `UsageError`.
14
+ There is no longer a way to create and insert nodes which contain subtrees for which there is no schema.
15
+
16
+ Ideally `exportVerbose` and `importVerbose` could be used to round trip data while optionally preserving unknown optional fields, but this is currently not working and thus not supported.
17
+
18
+ If exporting using [useStoredKeys](https://fluidframework.com/docs/api/fluid-framework/treeencodingoptions-interface#usestoredkeys-propertysignature), the unknown optional fields will be preserved but may not be able to be imported.
19
+ If exporting not using `useStoredKeys`, unknown optional fields will be omitted.
20
+
21
+ - Support unknown optional fields in TreeBeta.clone, TreeAlpha.exportConcise and TreeAlpha.exportVerbose ([#25106](https://github.com/microsoft/FluidFramework/pull/25106)) [e3a126ffac](https://github.com/microsoft/FluidFramework/commit/e3a126ffac46bb91e8b553535410d5532b05e662)
22
+
23
+ Trees with [unknown optional fields](https://fluidframework.com/docs/api/fluid-framework/schemafactoryobjectoptions-interface#allowunknownoptionalfields-propertysignature) are now supported in [TreeBeta.clone](https://fluidframework.com/docs/api/tree/treebeta-interface#clone-methodsignature), [TreeBeta.exportConcise](https://fluidframework.com/docs/api/tree/treealpha-interface#exportconcise-methodsignature) and [TreeBeta.exportVerbose](https://fluidframework.com/docs/api/tree/treealpha-interface#exportverbose-methodsignature).
24
+
25
+ Previously, attempts to clone or export such nodes could error in some cases, but should now work robustly.
26
+
27
+ - Fix independentInitializedView when used with ForestTypeExpensiveDebug ([#25083](https://github.com/microsoft/FluidFramework/pull/25083)) [2570b650b6](https://github.com/microsoft/FluidFramework/commit/2570b650b64f261fdf8cbfbfddaf3174577a5da2)
28
+
29
+ Previously, when using [independentInitializedView](https://fluidframework.com/docs/api/tree/#independentinitializedview-function) with [ForestTypeExpensiveDebug](https://fluidframework.com/docs/api/tree/#foresttypeexpensivedebug-variable) and the root schema was not an optional field, an error was thrown about the tree being out of schema.
30
+ This has been fixed.
31
+
32
+ - Allow attaching a SharedTree to an already attached container ([#25102](https://github.com/microsoft/FluidFramework/pull/25102)) [3e03f94f0e](https://github.com/microsoft/FluidFramework/commit/3e03f94f0e3529094304e272df75dae4bf43618e)
33
+
34
+ Before this release, attaching a SharedTree instance to an already attached container would fail with assert code `0x88f` if that instance needed to include data about removed nodes in its attach summary.
35
+ (This is the case when nodes are removed before attaching and there is a local branch that forks from a commit that made such a removal or from an earlier commit. This is also the case when retaining `Revertible` objects for those commits).
36
+
37
+ After this release, the behavior depends on the `CodecWriteOptions.oldestCompatibleClient` value:
38
+
39
+ - For values < `FluidClientVersion.v2_52`, the behavior is the same.
40
+ - For values >= `FluidClientVersion.v2_52`, the attach will succeed, but use a newer storage format.
41
+
42
+ Applications should take care to saturate their clients with FF version `2.52` (or greater) before using a `CodecWriteOptions.oldestCompatibleClient` that is equal to or greater than `FluidClientVersion.v2_52`.
43
+ Failure to do so may lead clients with `CodecWriteOptions.oldestCompatibleClient` equal to or greater than `FluidClientVersion.v2_52` to attach SharedTree instances using a storage format that is not supported by FF versions before `2.52`.
44
+ This means that application versions using FF versions before `2.52` will be unable to open documents where such an operation has happened.
45
+
3
46
  ## 2.51.0
4
47
 
5
48
  ### Minor Changes
package/api-report/fluid-framework.alpha.api.md CHANGED
@@ -18,6 +18,7 @@ export function adaptEnum<TScope extends string, const TEnum extends Record<stri
18
18
  // @alpha
19
19
  export interface AllowedTypeMetadata {
20
20
  readonly custom?: unknown;
21
+ readonly stagedSchemaUpgrade?: SchemaUpgrade;
21
22
  }
22
23
 
23
24
  // @public @system
@@ -140,10 +141,14 @@ export enum ConnectionState {
140
141
 
141
142
  // @public
142
143
  export namespace ConnectionStateType {
143
- export type CatchingUp = 1;
144
- export type Connected = 2;
145
- export type Disconnected = 0;
146
- export type EstablishingConnection = 3;
144
+ const Disconnected = 0;
145
+ export type CatchingUp = typeof CatchingUp;
146
+ const EstablishingConnection = 3;
147
+ export type Connected = typeof Connected;
148
+ const CatchingUp = 1;
149
+ export type Disconnected = typeof Disconnected;
150
+ const Connected = 2;
151
+ export type EstablishingConnection = typeof EstablishingConnection;
147
152
  }
148
153
 
149
154
  // @public
@@ -201,7 +206,7 @@ export function evaluateLazySchema<T extends TreeNodeSchema>(value: LazyItem<T>)
201
206
  type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result ? Result : Item;
202
207
 
203
208
  // @alpha
204
- export function extractPersistedSchema(schema: SimpleTreeSchema, oldestCompatibleClient: FluidClientVersion): JsonCompatible;
209
+ export function extractPersistedSchema(schema: ImplicitAnnotatedFieldSchema, oldestCompatibleClient: FluidClientVersion, includeStaged: (upgrade: SchemaUpgrade) => boolean): JsonCompatible;
205
210
 
206
211
  // @alpha @system
207
212
  export type FactoryContent = IFluidHandle | string | number | boolean | null | Iterable<readonly [string, InsertableContent]> | readonly InsertableContent[] | FactoryContentObject;
@@ -290,7 +295,8 @@ type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;
290
295
  // @alpha
291
296
  export enum FluidClientVersion {
292
297
  EnableUnstableFeatures,
293
- v2_0 = 2
298
+ v2_0 = 2,
299
+ v2_52 = 2.052
294
300
  }
295
301
 
296
302
  // @public
@@ -768,16 +774,14 @@ export namespace JsonAsTree {
768
774
  export class JsonObject extends _APIExtractorWorkaroundObjectBase {
769
775
  }
770
776
  const // @system
771
- _APIExtractorWorkaroundObjectBase: TreeNodeSchemaClass<"com.fluidframework.json.object", NodeKind.Record, TreeRecordNodeUnsafe_2<readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array]> & WithType<"com.fluidframework.json.object", NodeKind.Record, unknown>, {
777
+ _APIExtractorWorkaroundObjectBase: TreeNodeSchemaClass<"com.fluidframework.json.object", NodeKind.Record, TreeRecordNodeUnsafe<readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array]> & WithType<"com.fluidframework.json.object", NodeKind.Record, unknown>, {
772
778
  readonly [x: string]: string | number | JsonObject | Array | System_Unsafe.InsertableTypedNodeUnsafe<LeafSchema<"boolean", boolean>, LeafSchema<"boolean", boolean>> | null;
773
779
  }, false, readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array], undefined>;
774
- // (undocumented)
775
780
  export type Primitive = TreeNodeFromImplicitAllowedTypes<typeof Primitive>;
776
781
  // @system
777
782
  export type _RecursiveArrayWorkaroundJsonArray = FixRecursiveArraySchema<typeof Array>;
778
783
  const // @system
779
- _APIExtractorWorkaroundArrayBase: ArrayNodeCustomizableSchemaUnsafe_2<"com.fluidframework.json.array", readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array], unknown>;
780
- // (undocumented)
784
+ _APIExtractorWorkaroundArrayBase: ArrayNodeCustomizableSchemaUnsafe<"com.fluidframework.json.array", readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array], unknown>;
781
785
  export type Tree = TreeNodeFromImplicitAllowedTypes<typeof Tree>;
782
786
  }
783
787
 
@@ -1135,11 +1139,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
1135
1139
  readonly boolean: LeafSchema<"boolean", boolean>;
1136
1140
  static readonly boolean: LeafSchema<"boolean", boolean>;
1137
1141
  protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
1138
- readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
1139
- static readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
1142
+ readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
1143
+ static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
1140
1144
  get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
1141
- readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
1142
- static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
1145
+ readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
1146
+ static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
1143
1147
  map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
1144
1148
  map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
1145
1149
  mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
@@ -1173,9 +1177,9 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
1173
1177
  export class SchemaFactoryAlpha<out TScope extends string | undefined = string | undefined, TName extends number | string = string> extends SchemaFactory<TScope, TName> {
1174
1178
  arrayAlpha<const Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): ArrayNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
1175
1179
  arrayRecursive<const Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): ArrayNodeCustomizableSchemaUnsafe<ScopedSchemaName<TScope, Name>, T, TCustomMetadata>;
1176
- static readonly identifier: <const TCustomMetadata = unknown>(props?: Omit<FieldProps_2<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlpha_2<FieldKind_2.Identifier, LeafSchema_2<"string", string> & SimpleLeafNodeSchema_2, TCustomMetadata>;
1177
- static readonly leaves: readonly [LeafSchema_2<"string", string> & SimpleLeafNodeSchema_2, LeafSchema_2<"number", number> & SimpleLeafNodeSchema_2, LeafSchema_2<"boolean", boolean> & SimpleLeafNodeSchema_2, LeafSchema_2<"null", null> & SimpleLeafNodeSchema_2, LeafSchema_2<"handle", IFluidHandle_2<unknown>> & SimpleLeafNodeSchema_2];
1178
- readonly leaves: readonly [LeafSchema_2<"string", string> & SimpleLeafNodeSchema_2, LeafSchema_2<"number", number> & SimpleLeafNodeSchema_2, LeafSchema_2<"boolean", boolean> & SimpleLeafNodeSchema_2, LeafSchema_2<"null", null> & SimpleLeafNodeSchema_2, LeafSchema_2<"handle", IFluidHandle_2<unknown>> & SimpleLeafNodeSchema_2];
1180
+ static readonly identifier: <const TCustomMetadata = unknown>(props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlpha<FieldKind.Identifier, LeafSchema<"string", string> & SimpleLeafNodeSchema, TCustomMetadata>;
1181
+ static readonly leaves: readonly [LeafSchema<"string", string> & SimpleLeafNodeSchema, LeafSchema<"number", number> & SimpleLeafNodeSchema, LeafSchema<"boolean", boolean> & SimpleLeafNodeSchema, LeafSchema<"null", null> & SimpleLeafNodeSchema, LeafSchema<"handle", IFluidHandle_2<unknown>> & SimpleLeafNodeSchema];
1182
+ readonly leaves: readonly [LeafSchema<"string", string> & SimpleLeafNodeSchema, LeafSchema<"number", number> & SimpleLeafNodeSchema, LeafSchema<"boolean", boolean> & SimpleLeafNodeSchema, LeafSchema<"null", null> & SimpleLeafNodeSchema, LeafSchema<"handle", IFluidHandle_2<unknown>> & SimpleLeafNodeSchema];
1179
1183
  mapAlpha<Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): MapNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
1180
1184
  mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): MapNodeCustomizableSchemaUnsafe<ScopedSchemaName<TScope, Name>, T, TCustomMetadata>;
1181
1185
  objectAlpha<const Name extends TName, const T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>, const TCustomMetadata = unknown>(name: Name, fields: T, options?: SchemaFactoryObjectOptions<TCustomMetadata>): ObjectNodeSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> & {
@@ -1183,15 +1187,15 @@ export class SchemaFactoryAlpha<out TScope extends string | undefined = string |
1183
1187
  };
1184
1188
  objectRecursive<const Name extends TName, const T extends RestrictiveStringRecord<System_Unsafe.ImplicitFieldSchemaUnsafe>, const TCustomMetadata = unknown>(name: Name, t: T, options?: SchemaFactoryObjectOptions<TCustomMetadata>): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, System_Unsafe.TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & System_Unsafe.InsertableObjectFromSchemaRecordUnsafe<T>, false, T, never, TCustomMetadata> & SimpleObjectNodeSchema<TCustomMetadata> & Pick<ObjectNodeSchema, "fields">;
1185
1189
  static readonly optional: {
1186
- <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Optional, T, TCustomMetadata>;
1187
- <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha_2<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Optional, UnannotateImplicitAllowedTypes_2<T_1>, TCustomMetadata_1>;
1190
+ <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata>;
1191
+ <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
1188
1192
  };
1189
1193
  readonly optional: {
1190
- <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Optional, T, TCustomMetadata>;
1191
- <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha_2<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Optional, UnannotateImplicitAllowedTypes_2<T_1>, TCustomMetadata_1>;
1194
+ <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata>;
1195
+ <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
1192
1196
  };
1193
- static readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe_2<FieldKind_2.Optional, T, TCustomMetadata>;
1194
- readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe_2<FieldKind_2.Optional, T, TCustomMetadata>;
1197
+ static readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata>;
1198
+ readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata>;
1195
1199
  record<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
1196
1200
  record<const Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
1197
1201
  recordAlpha<const Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): RecordNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
@@ -1199,16 +1203,18 @@ export class SchemaFactoryAlpha<out TScope extends string | undefined = string |
1199
1203
  readonly [x: string]: System_Unsafe.InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>;
1200
1204
  }, false, T, undefined>;
1201
1205
  static readonly required: {
1202
- <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Required, T, TCustomMetadata>;
1203
- <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha_2<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Required, UnannotateImplicitAllowedTypes_2<T_1>, TCustomMetadata_1>;
1206
+ <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata>;
1207
+ <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
1204
1208
  };
1205
1209
  readonly required: {
1206
- <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Required, T, TCustomMetadata>;
1207
- <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha_2<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha_2<FieldKind_2.Required, UnannotateImplicitAllowedTypes_2<T_1>, TCustomMetadata_1>;
1210
+ <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata>;
1211
+ <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
1208
1212
  };
1209
- static readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe_2<FieldKind_2.Required, T, TCustomMetadata>;
1210
- readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha_2<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe_2<FieldKind_2.Required, T, TCustomMetadata>;
1213
+ static readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata>;
1214
+ readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata>;
1211
1215
  scopedFactory<const T extends TName, TNameInner extends number | string = string>(name: T): SchemaFactoryAlpha<ScopedSchemaName<TScope, T>, TNameInner>;
1216
+ static staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
1217
+ staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
1212
1218
  }
1213
1219
 
1214
1220
  // @alpha
@@ -1236,6 +1242,17 @@ export interface SchemaStatics {
1236
1242
  readonly string: LeafSchema<"string", string>;
1237
1243
  }
1238
1244
 
1245
+ // @alpha @sealed @system
1246
+ export interface SchemaStaticsAlpha {
1247
+ staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
1248
+ }
1249
+
1250
+ // @alpha @sealed
1251
+ export class SchemaUpgrade {
1252
+ // (undocumented)
1253
+ protected _typeCheck: MakeNominal;
1254
+ }
1255
+
1239
1256
  // @alpha @input
1240
1257
  export interface SchemaValidationFunction<Schema extends TSchema> {
1241
1258
  check(data: unknown): data is Static<Schema>;
@@ -1353,7 +1370,7 @@ export namespace System_TableSchema {
1353
1370
  props: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>>;
1354
1371
  }), true, {
1355
1372
  readonly props: TPropsSchema;
1356
- readonly id: FieldSchema_2<FieldKind_3.Identifier, LeafSchema_3<"string", string>, unknown>;
1373
+ readonly id: FieldSchema_2<FieldKind_2.Identifier, LeafSchema_2<"string", string>, unknown>;
1357
1374
  }>;
1358
1375
  // @system
1359
1376
  export type CreateRowOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
@@ -1367,8 +1384,8 @@ export namespace System_TableSchema {
1367
1384
  props: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>>;
1368
1385
  }), true, {
1369
1386
  readonly props: TPropsSchema;
1370
- readonly id: FieldSchema_2<FieldKind_3.Identifier, LeafSchema_3<"string", string>, unknown>;
1371
- readonly cells: FieldSchemaAlpha_3<FieldKind_3.Required, TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Record, TreeRecordNode_2<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Record, unknown>, RecordNodeInsertableData_2<TCellSchema>, true, TCellSchema, undefined>, unknown>;
1387
+ readonly id: FieldSchema_2<FieldKind_2.Identifier, LeafSchema_2<"string", string>, unknown>;
1388
+ readonly cells: FieldSchemaAlpha_2<FieldKind_2.Required, TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Record, TreeRecordNode_2<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Record, unknown>, RecordNodeInsertableData_2<TCellSchema>, true, TCellSchema, undefined>, unknown>;
1372
1389
  }>;
1373
1390
  // @system
1374
1391
  export function createTableSchema<const TInputScope extends string | undefined, const TCellSchema extends ImplicitAllowedTypes, const TColumnSchema extends ColumnSchemaBase<TInputScope, TCellSchema>, const TRowSchema extends RowSchemaBase<TInputScope, TCellSchema>>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCellSchema, columnSchema: TColumnSchema, rowSchema: TRowSchema): TreeNodeSchemaCore_2<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind.Object, true, {
@@ -1928,21 +1945,18 @@ const typeNameSymbol: unique symbol;
1928
1945
  export const typeSchemaSymbol: unique symbol;
1929
1946
 
1930
1947
  // @alpha @system
1931
- export type UnannotateAllowedType<T extends AnnotatedAllowedType> = T extends AnnotatedAllowedType<infer X> ? [X] : T;
1932
-
1933
- // @alpha @system
1934
- export type UnannotateAllowedTypeOrLazyItem<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> = T extends AnnotatedAllowedType<infer X> ? X : T;
1948
+ export type UnannotateAllowedType<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> = T extends AnnotatedAllowedType<infer X> ? X : T;
1935
1949
 
1936
1950
  // @alpha @system
1937
1951
  export type UnannotateAllowedTypes<T extends AnnotatedAllowedTypes> = UnannotateAllowedTypesList<T["types"]>;
1938
1952
 
1939
1953
  // @alpha @system
1940
1954
  export type UnannotateAllowedTypesList<T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]> = {
1941
- [I in keyof T]: UnannotateAllowedTypeOrLazyItem<T[I]>;
1955
+ [I in keyof T]: UnannotateAllowedType<T[I]>;
1942
1956
  };
1943
1957
 
1944
1958
  // @alpha @system
1945
- export type UnannotateImplicitAllowedTypes<T extends ImplicitAnnotatedAllowedTypes> = T extends AnnotatedAllowedTypes ? UnannotateAllowedTypes<T> : T extends AnnotatedAllowedType ? UnannotateAllowedType<T> : T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[] ? UnannotateAllowedTypesList<T> : T extends TreeNodeSchema ? T : never;
1959
+ export type UnannotateImplicitAllowedTypes<T extends ImplicitAnnotatedAllowedTypes> = T extends AnnotatedAllowedTypes ? UnannotateAllowedTypes<T> : T extends AnnotatedAllowedType ? UnannotateAllowedTypesList<[T]> : T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[] ? UnannotateAllowedTypesList<T> : T extends TreeNodeSchema ? T : never;
1946
1960
 
1947
1961
  // @alpha @system
1948
1962
  export type UnannotateImplicitFieldSchema<T extends ImplicitAnnotatedFieldSchema> = T extends ImplicitAnnotatedAllowedTypes ? UnannotateImplicitAllowedTypes<T> : T;
package/api-report/fluid-framework.beta.api.md CHANGED
@@ -60,10 +60,14 @@ export enum ConnectionState {
60
60
 
61
61
  // @public
62
62
  export namespace ConnectionStateType {
63
- export type CatchingUp = 1;
64
- export type Connected = 2;
65
- export type Disconnected = 0;
66
- export type EstablishingConnection = 3;
63
+ const Disconnected = 0;
64
+ export type CatchingUp = typeof CatchingUp;
65
+ const EstablishingConnection = 3;
66
+ export type Connected = typeof Connected;
67
+ const CatchingUp = 1;
68
+ export type Disconnected = typeof Disconnected;
69
+ const Connected = 2;
70
+ export type EstablishingConnection = typeof EstablishingConnection;
67
71
  }
68
72
 
69
73
  // @public
@@ -695,11 +699,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
695
699
  readonly boolean: LeafSchema<"boolean", boolean>;
696
700
  static readonly boolean: LeafSchema<"boolean", boolean>;
697
701
  protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
698
- readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
699
- static readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
702
+ readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
703
+ static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
700
704
  get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
701
- readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
702
- static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
705
+ readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
706
+ static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
703
707
  map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
704
708
  map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
705
709
  mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
package/api-report/fluid-framework.legacy.alpha.api.md CHANGED
@@ -49,10 +49,14 @@ export enum ConnectionState {
49
49
 
50
50
  // @public
51
51
  export namespace ConnectionStateType {
52
- export type CatchingUp = 1;
53
- export type Connected = 2;
54
- export type Disconnected = 0;
55
- export type EstablishingConnection = 3;
52
+ const Disconnected = 0;
53
+ export type CatchingUp = typeof CatchingUp;
54
+ const EstablishingConnection = 3;
55
+ export type Connected = typeof Connected;
56
+ const CatchingUp = 1;
57
+ export type Disconnected = typeof Disconnected;
58
+ const Connected = 2;
59
+ export type EstablishingConnection = typeof EstablishingConnection;
56
60
  }
57
61
 
58
62
  // @public
@@ -957,11 +961,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
957
961
  readonly boolean: LeafSchema<"boolean", boolean>;
958
962
  static readonly boolean: LeafSchema<"boolean", boolean>;
959
963
  protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
960
- readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
961
- static readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
964
+ readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
965
+ static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
962
966
  get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
963
- readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
964
- static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
967
+ readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
968
+ static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
965
969
  map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
966
970
  map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
967
971
  mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
package/api-report/fluid-framework.legacy.public.api.md CHANGED
@@ -49,10 +49,14 @@ export enum ConnectionState {
49
49
 
50
50
  // @public
51
51
  export namespace ConnectionStateType {
52
- export type CatchingUp = 1;
53
- export type Connected = 2;
54
- export type Disconnected = 0;
55
- export type EstablishingConnection = 3;
52
+ const Disconnected = 0;
53
+ export type CatchingUp = typeof CatchingUp;
54
+ const EstablishingConnection = 3;
55
+ export type Connected = typeof Connected;
56
+ const CatchingUp = 1;
57
+ export type Disconnected = typeof Disconnected;
58
+ const Connected = 2;
59
+ export type EstablishingConnection = typeof EstablishingConnection;
56
60
  }
57
61
 
58
62
  // @public
@@ -699,11 +703,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
699
703
  readonly boolean: LeafSchema<"boolean", boolean>;
700
704
  static readonly boolean: LeafSchema<"boolean", boolean>;
701
705
  protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
702
- readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
703
- static readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
706
+ readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
707
+ static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
704
708
  get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
705
- readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
706
- static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
709
+ readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
710
+ static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
707
711
  map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
708
712
  map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
709
713
  mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
package/api-report/fluid-framework.public.api.md CHANGED
@@ -49,10 +49,14 @@ export enum ConnectionState {
49
49
 
50
50
  // @public
51
51
  export namespace ConnectionStateType {
52
- export type CatchingUp = 1;
53
- export type Connected = 2;
54
- export type Disconnected = 0;
55
- export type EstablishingConnection = 3;
52
+ const Disconnected = 0;
53
+ export type CatchingUp = typeof CatchingUp;
54
+ const EstablishingConnection = 3;
55
+ export type Connected = typeof Connected;
56
+ const CatchingUp = 1;
57
+ export type Disconnected = typeof Disconnected;
58
+ const Connected = 2;
59
+ export type EstablishingConnection = typeof EstablishingConnection;
56
60
  }
57
61
 
58
62
  // @public
@@ -665,11 +669,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
665
669
  readonly boolean: LeafSchema<"boolean", boolean>;
666
670
  static readonly boolean: LeafSchema<"boolean", boolean>;
667
671
  protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
668
- readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
669
- static readonly handle: LeafSchema<"handle", IFluidHandle<unknown>>;
672
+ readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
673
+ static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
670
674
  get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
671
- readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
672
- static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle<unknown>>];
675
+ readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
676
+ static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
673
677
  map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
674
678
  map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
675
679
  mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
package/dist/alpha.d.ts CHANGED
@@ -215,6 +215,8 @@ export {
215
215
  RunTransactionParams,
216
216
  SchemaFactoryAlpha,
217
217
  SchemaFactoryObjectOptions,
218
+ SchemaStaticsAlpha,
219
+ SchemaUpgrade,
218
220
  SchemaValidationFunction,
219
221
  SharedTreeFormatOptions,
220
222
  SharedTreeFormatVersion,
@@ -254,7 +256,6 @@ export {
254
256
  TreeViewAlpha,
255
257
  TreeViewConfigurationAlpha,
256
258
  UnannotateAllowedType,
257
- UnannotateAllowedTypeOrLazyItem,
258
259
  UnannotateAllowedTypes,
259
260
  UnannotateAllowedTypesList,
260
261
  UnannotateImplicitAllowedTypes,
package/lib/alpha.d.ts CHANGED
@@ -215,6 +215,8 @@ export {
215
215
  RunTransactionParams,
216
216
  SchemaFactoryAlpha,
217
217
  SchemaFactoryObjectOptions,
218
+ SchemaStaticsAlpha,
219
+ SchemaUpgrade,
218
220
  SchemaValidationFunction,
219
221
  SharedTreeFormatOptions,
220
222
  SharedTreeFormatVersion,
@@ -254,7 +256,6 @@ export {
254
256
  TreeViewAlpha,
255
257
  TreeViewConfigurationAlpha,
256
258
  UnannotateAllowedType,
257
- UnannotateAllowedTypeOrLazyItem,
258
259
  UnannotateAllowedTypes,
259
260
  UnannotateAllowedTypesList,
260
261
  UnannotateImplicitAllowedTypes,
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "fluid-framework",
3
- "version": "2.51.0",
3
+ "version": "2.53.0-350190",
4
4
  "description": "The main entry point into Fluid Framework public packages",
5
5
  "homepage": "https://fluidframework.com",
6
6
  "repository": {
@@ -57,24 +57,24 @@
57
57
  "main": "lib/index.js",
58
58
  "types": "lib/public.d.ts",
59
59
  "dependencies": {
60
- "@fluidframework/container-definitions": "~2.51.0",
61
- "@fluidframework/container-loader": "~2.51.0",
62
- "@fluidframework/core-interfaces": "~2.51.0",
63
- "@fluidframework/core-utils": "~2.51.0",
64
- "@fluidframework/driver-definitions": "~2.51.0",
65
- "@fluidframework/fluid-static": "~2.51.0",
66
- "@fluidframework/map": "~2.51.0",
67
- "@fluidframework/runtime-utils": "~2.51.0",
68
- "@fluidframework/sequence": "~2.51.0",
69
- "@fluidframework/shared-object-base": "~2.51.0",
70
- "@fluidframework/tree": "~2.51.0"
60
+ "@fluidframework/container-definitions": "2.53.0-350190",
61
+ "@fluidframework/container-loader": "2.53.0-350190",
62
+ "@fluidframework/core-interfaces": "2.53.0-350190",
63
+ "@fluidframework/core-utils": "2.53.0-350190",
64
+ "@fluidframework/driver-definitions": "2.53.0-350190",
65
+ "@fluidframework/fluid-static": "2.53.0-350190",
66
+ "@fluidframework/map": "2.53.0-350190",
67
+ "@fluidframework/runtime-utils": "2.53.0-350190",
68
+ "@fluidframework/sequence": "2.53.0-350190",
69
+ "@fluidframework/shared-object-base": "2.53.0-350190",
70
+ "@fluidframework/tree": "2.53.0-350190"
71
71
  },
72
72
  "devDependencies": {
73
73
  "@arethetypeswrong/cli": "^0.17.1",
74
74
  "@biomejs/biome": "~1.9.3",
75
- "@fluid-tools/build-cli": "^0.56.0",
75
+ "@fluid-tools/build-cli": "^0.57.0",
76
76
  "@fluidframework/build-common": "^2.0.3",
77
- "@fluidframework/build-tools": "^0.56.0",
77
+ "@fluidframework/build-tools": "^0.57.0",
78
78
  "@fluidframework/eslint-config-fluid": "^5.7.4",
79
79
  "@microsoft/api-extractor": "7.52.8",
80
80
  "@types/node": "^18.19.0",