@fluidframework/core-interfaces 0.43.1000-60265 → 0.43.1000

package/api-report/core-interfaces.api.md

@@ -7,7 +7,9 @@
 // Warning: (ae-incompatible-release-tags) The symbol "FluidObject" is marked as @public, but its signature references "FluidObjectProviderKeys" which is marked as @internal
 //
 // @public
-export type FluidObject<T = unknown> = Partial<Pick<T, FluidObjectProviderKeys<T>>>;
+export type FluidObject<T = unknown> = {
+    [P in FluidObjectProviderKeys<T>]?: T[P];
+};
 
 // @public
 export type FluidObjectKeys<T> = keyof FluidObject<T>;
@@ -15,7 +17,7 @@ export type FluidObjectKeys<T> = keyof FluidObject<T>;
 // Warning: (ae-internal-missing-underscore) The name "FluidObjectProviderKeys" should be prefixed with an underscore because the declaration is marked as @internal
 //
 // @internal
-export type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> = string extends TProp ? never : number extends TProp ? never : TProp extends keyof Exclude<T[TProp], undefined> ? TProp : never;
+export type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> = string extends TProp ? never : number extends TProp ? never : TProp extends keyof Required<T>[TProp] ? Required<T>[TProp] extends Required<Required<T>[TProp]>[TProp] ? TProp : never : never;
 
 // @public @deprecated (undocumented)
 export interface IFluidCodeDetails {
@@ -42,7 +44,7 @@ export interface IFluidCodeDetailsConfig {
 export const IFluidHandle: keyof IProvideFluidHandle;
 
 // @public
-export interface IFluidHandle<T = IFluidObject & FluidObject & IFluidLoadable> extends IProvideFluidHandle {
+export interface IFluidHandle<T = FluidObject & IFluidLoadable> extends IProvideFluidHandle {
     // @deprecated (undocumented)
     readonly absolutePath: string;
     attachGraph(): void;

package/dist/handles.d.ts

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 import { IRequest, IResponse } from "./fluidRouter";
-import { IFluidObject } from "./fluidObject";
 import { IFluidLoadable } from "./fluidLoadable";
 import { FluidObject } from "./provider";
 export declare const IFluidHandleContext: keyof IProvideFluidHandleContext;
@@ -40,7 +39,7 @@ export interface IProvideFluidHandle {
 /**
  * Handle to a shared FluidObject
  */
-export interface IFluidHandle<T = IFluidObject & FluidObject & IFluidLoadable> extends IProvideFluidHandle {
+export interface IFluidHandle<T = FluidObject & IFluidLoadable> extends IProvideFluidHandle {
     /**
      * @deprecated - Do not use handle's path for routing. Use `get` to get the underlying object.
      *

package/dist/handles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,mBAAmB,EAAE,MAAM,0BAAkD,CAAC;AAE3F,MAAM,WAAW,0BAA0B;IACvC,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,0BAA0B;IACnE;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACxD;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,mBAAoC,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAEzB,CAAC,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,CAC7C,SAAQ,mBAAmB;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;OAEG;IACH,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IAElB;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CACpC"}
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,mBAAmB,EAAE,MAAM,0BAAkD,CAAC;AAE3F,MAAM,WAAW,0BAA0B;IACvC,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,0BAA0B;IACnE;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACxD;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,mBAAoC,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAEzB,CAAC,GAAG,WAAW,GAAG,cAAc,CAC9B,SAAQ,mBAAmB;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;OAEG;IACH,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IAElB;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CACpC"}

package/dist/handles.js.map

@@ -1 +1 @@
-{"version":3,"file":"handles.js","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAOU,QAAA,mBAAmB,GAAqC,qBAAqB,CAAC;AAkC9E,QAAA,YAAY,GAA8B,cAAc,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IRequest, IResponse } from \"./fluidRouter\";\nimport { IFluidObject } from \"./fluidObject\";\nimport { IFluidLoadable } from \"./fluidLoadable\";\nimport { FluidObject } from \"./provider\";\n\nexport const IFluidHandleContext: keyof IProvideFluidHandleContext = \"IFluidHandleContext\";\n\nexport interface IProvideFluidHandleContext {\n    readonly IFluidHandleContext: IFluidHandleContext;\n}\n\n/**\n * An IFluidHandleContext describes a routing context from which other IFluidHandleContexts are defined\n */\nexport interface IFluidHandleContext extends IProvideFluidHandleContext {\n    /**\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * The parent IFluidHandleContext that has provided a route path to this IFluidHandleContext or undefined\n     * at the root.\n     */\n    readonly routeContext?: IFluidHandleContext;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    resolveHandle(request: IRequest): Promise<IResponse>;\n}\n\nexport const IFluidHandle: keyof IProvideFluidHandle = \"IFluidHandle\";\n\nexport interface IProvideFluidHandle {\n    readonly IFluidHandle: IFluidHandle;\n}\n\n/**\n * Handle to a shared FluidObject\n */\nexport interface IFluidHandle<\n    // REVIEW: Constrain `T` to something? How do we support dds and datastores safely?\n    T = IFluidObject & FluidObject & IFluidLoadable\n    > extends IProvideFluidHandle {\n\n    /**\n     * @deprecated - Do not use handle's path for routing. Use `get` to get the underlying object.\n     *\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    /**\n     * Returns a promise to the Fluid Object referenced by the handle.\n     */\n    get(): Promise<T>;\n\n    /**\n     * Binds the given handle to this one or attach the given handle if this handle is attached.\n     * A bound handle will also be attached once this handle is attached.\n     */\n    bind(handle: IFluidHandle): void;\n}\n"]}
+{"version":3,"file":"handles.js","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAMU,QAAA,mBAAmB,GAAqC,qBAAqB,CAAC;AAkC9E,QAAA,YAAY,GAA8B,cAAc,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IRequest, IResponse } from \"./fluidRouter\";\nimport { IFluidLoadable } from \"./fluidLoadable\";\nimport { FluidObject } from \"./provider\";\n\nexport const IFluidHandleContext: keyof IProvideFluidHandleContext = \"IFluidHandleContext\";\n\nexport interface IProvideFluidHandleContext {\n    readonly IFluidHandleContext: IFluidHandleContext;\n}\n\n/**\n * An IFluidHandleContext describes a routing context from which other IFluidHandleContexts are defined\n */\nexport interface IFluidHandleContext extends IProvideFluidHandleContext {\n    /**\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * The parent IFluidHandleContext that has provided a route path to this IFluidHandleContext or undefined\n     * at the root.\n     */\n    readonly routeContext?: IFluidHandleContext;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    resolveHandle(request: IRequest): Promise<IResponse>;\n}\n\nexport const IFluidHandle: keyof IProvideFluidHandle = \"IFluidHandle\";\n\nexport interface IProvideFluidHandle {\n    readonly IFluidHandle: IFluidHandle;\n}\n\n/**\n * Handle to a shared FluidObject\n */\nexport interface IFluidHandle<\n    // REVIEW: Constrain `T` to something? How do we support dds and datastores safely?\n    T = FluidObject & IFluidLoadable\n    > extends IProvideFluidHandle {\n\n    /**\n     * @deprecated - Do not use handle's path for routing. Use `get` to get the underlying object.\n     *\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    /**\n     * Returns a promise to the Fluid Object referenced by the handle.\n     */\n    get(): Promise<T>;\n\n    /**\n     * Binds the given handle to this one or attach the given handle if this handle is attached.\n     * A bound handle will also be attached once this handle is attached.\n     */\n    bind(handle: IFluidHandle): void;\n}\n"]}

package/dist/provider.d.ts

@@ -21,7 +21,7 @@
  * This pattern enables discovery, and delegation in a standard way which is central
  * to FluidObject pattern
  */
-export declare type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> = string extends TProp ? never : number extends TProp ? never : TProp extends keyof Exclude<T[TProp], undefined> ? TProp : never;
+export declare type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> = string extends TProp ? never : number extends TProp ? never : TProp extends keyof Required<T>[TProp] ? Required<T>[TProp] extends Required<Required<T>[TProp]>[TProp] ? TProp : never : never;
 /**
  * This utility type take interface(s) that follow the FluidObject pattern, and produces
  * a new type that can be used for inspection and discovery of those interfaces.
@@ -52,7 +52,9 @@ export declare type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T>
  * `FluidObject<IFoo & IBar>`
  *
  */
-export declare type FluidObject<T = unknown> = Partial<Pick<T, FluidObjectProviderKeys<T>>>;
+export declare type FluidObject<T = unknown> = {
+    [P in FluidObjectProviderKeys<T>]?: T[P];
+};
 /**
  * This utility type creates a type that is the union of all keys on the generic type
  * which implement the FluidObject pattern. @see FluidObject

package/dist/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACF,oBAAY,uBAAuB,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IACnE,MAAM,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,SAAS,KAAK,GAAE,KAAK,GAC1D,KAAK,SAAS,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,GAC1C,KAAK,GACN,KAAK,CAAC;AAEf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACF,oBAAY,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAErF;;;;;;GAMG;AACH,oBAAY,eAAe,CAAC,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACF,oBAAY,uBAAuB,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IACnE,MAAM,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,SAAS,KAAK,GAAE,KAAK,GAC1D,KAAK,SAAS,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAChC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,GAC1D,KAAK,GACL,KAAK,GACT,KAAK,CAAC;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACF,oBAAY,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI;KACnC,CAAC,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAC;AAEF;;;;;;GAMG;AACH,oBAAY,eAAe,CAAC,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC"}

package/dist/provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * @internal\n * This utility type is meant for internal use by @see FluidObject\n * Produces a valid FluidObject key given a type and a property.\n * A valid FluidObject key is a property that exists on the incoming type\n * as well as on the type of the property itself. For example, IProvideFoo.IFoo.IFoo\n * This aligns with the FluidObject pattern expected to be used with all FluidObjects.\n * For example:\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n * This pattern enables discovery, and delegation in a standard way which is central\n * to FluidObject pattern\n */\n export type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> =\n    string extends TProp ? never : number extends TProp? never : // exclude indexers [key:string |number]: any\n    TProp extends keyof Exclude<T[TProp], undefined> // TProp is a property of T, and T[TProp]\n        ? TProp\n        :never;\n\n/**\n * This utility type take interface(s) that follow the FluidObject pattern, and produces\n * a new type that can be used for inspection and discovery of those interfaces.\n *\n * It is meant to be used with types that are known to implement the FluidObject pattern.\n * A common way to specify a type implements the FluidObject pattern is to expose it as a\n * FluidObject without a generic argument.\n *\n * For example, if we have an interface like below\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n *\n * and a function that returns a FluidObject. You would do the following\n *\n * `const maybeFoo: FluidObject<IFoo> = getFluidObject()`;\n *\n * Either IFoo or IProvideFoo are valid generic arguments. In both case\n * maybeFoo will be of type `{IFoo?: IFoo}`. If IFoo is not undefined,\n * then the FluidObject provides IFoo, and it can be used.\n *\n * You can inspect multiple types via a intersection. For example:\n * `FluidObject<IFoo & IBar>`\n *\n */\n export type FluidObject<T = unknown> = Partial<Pick<T, FluidObjectProviderKeys<T>>>;\n\n/**\n * This utility type creates a type that is the union of all keys on the generic type\n * which implement the FluidObject pattern. @see FluidObject\n *\n * For example `FluidObjectKeys<IFoo & IBar>` would result in `\"IFoo\" | \"IBar\"`\n *\n */\nexport type FluidObjectKeys<T> = keyof FluidObject<T>;\n"]}
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * @internal\n * This utility type is meant for internal use by @see FluidObject\n * Produces a valid FluidObject key given a type and a property.\n * A valid FluidObject key is a property that exists on the incoming type\n * as well as on the type of the property itself. For example, IProvideFoo.IFoo.IFoo\n * This aligns with the FluidObject pattern expected to be used with all FluidObjects.\n * For example:\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n * This pattern enables discovery, and delegation in a standard way which is central\n * to FluidObject pattern\n */\n export type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> =\n    string extends TProp ? never : number extends TProp? never : // exclude indexers [key:string |number]: any\n    TProp extends keyof Required<T>[TProp] // TProp is a property of T, and T[TProp]\n        ? Required<T>[TProp] extends Required<Required<T>[TProp]>[TProp] // T[TProp] is the same type as T[TProp][TProp]\n            ? TProp\n            : never\n        : never;\n\n/**\n * This utility type take interface(s) that follow the FluidObject pattern, and produces\n * a new type that can be used for inspection and discovery of those interfaces.\n *\n * It is meant to be used with types that are known to implement the FluidObject pattern.\n * A common way to specify a type implements the FluidObject pattern is to expose it as a\n * FluidObject without a generic argument.\n *\n * For example, if we have an interface like below\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n *\n * and a function that returns a FluidObject. You would do the following\n *\n * `const maybeFoo: FluidObject<IFoo> = getFluidObject()`;\n *\n * Either IFoo or IProvideFoo are valid generic arguments. In both case\n * maybeFoo will be of type `{IFoo?: IFoo}`. If IFoo is not undefined,\n * then the FluidObject provides IFoo, and it can be used.\n *\n * You can inspect multiple types via a intersection. For example:\n * `FluidObject<IFoo & IBar>`\n *\n */\n export type FluidObject<T = unknown> = {\n    [P in FluidObjectProviderKeys<T>]?: T[P];\n};\n\n/**\n * This utility type creates a type that is the union of all keys on the generic type\n * which implement the FluidObject pattern. @see FluidObject\n *\n * For example `FluidObjectKeys<IFoo & IBar>` would result in `\"IFoo\" | \"IBar\"`\n *\n */\nexport type FluidObjectKeys<T> = keyof FluidObject<T>;\n"]}

package/lib/handles.d.ts

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 import { IRequest, IResponse } from "./fluidRouter";
-import { IFluidObject } from "./fluidObject";
 import { IFluidLoadable } from "./fluidLoadable";
 import { FluidObject } from "./provider";
 export declare const IFluidHandleContext: keyof IProvideFluidHandleContext;
@@ -40,7 +39,7 @@ export interface IProvideFluidHandle {
 /**
  * Handle to a shared FluidObject
  */
-export interface IFluidHandle<T = IFluidObject & FluidObject & IFluidLoadable> extends IProvideFluidHandle {
+export interface IFluidHandle<T = FluidObject & IFluidLoadable> extends IProvideFluidHandle {
     /**
      * @deprecated - Do not use handle's path for routing. Use `get` to get the underlying object.
      *

package/lib/handles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,mBAAmB,EAAE,MAAM,0BAAkD,CAAC;AAE3F,MAAM,WAAW,0BAA0B;IACvC,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,0BAA0B;IACnE;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACxD;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,mBAAoC,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAEzB,CAAC,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,CAC7C,SAAQ,mBAAmB;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;OAEG;IACH,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IAElB;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CACpC"}
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,mBAAmB,EAAE,MAAM,0BAAkD,CAAC;AAE3F,MAAM,WAAW,0BAA0B;IACvC,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,0BAA0B;IACnE;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACxD;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,mBAAoC,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAEzB,CAAC,GAAG,WAAW,GAAG,cAAc,CAC9B,SAAQ,mBAAmB;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;OAEG;IACH,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IAElB;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CACpC"}

package/lib/handles.js.map

@@ -1 +1 @@
-{"version":3,"file":"handles.js","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,CAAC,MAAM,mBAAmB,GAAqC,qBAAqB,CAAC;AAkC3F,MAAM,CAAC,MAAM,YAAY,GAA8B,cAAc,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IRequest, IResponse } from \"./fluidRouter\";\nimport { IFluidObject } from \"./fluidObject\";\nimport { IFluidLoadable } from \"./fluidLoadable\";\nimport { FluidObject } from \"./provider\";\n\nexport const IFluidHandleContext: keyof IProvideFluidHandleContext = \"IFluidHandleContext\";\n\nexport interface IProvideFluidHandleContext {\n    readonly IFluidHandleContext: IFluidHandleContext;\n}\n\n/**\n * An IFluidHandleContext describes a routing context from which other IFluidHandleContexts are defined\n */\nexport interface IFluidHandleContext extends IProvideFluidHandleContext {\n    /**\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * The parent IFluidHandleContext that has provided a route path to this IFluidHandleContext or undefined\n     * at the root.\n     */\n    readonly routeContext?: IFluidHandleContext;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    resolveHandle(request: IRequest): Promise<IResponse>;\n}\n\nexport const IFluidHandle: keyof IProvideFluidHandle = \"IFluidHandle\";\n\nexport interface IProvideFluidHandle {\n    readonly IFluidHandle: IFluidHandle;\n}\n\n/**\n * Handle to a shared FluidObject\n */\nexport interface IFluidHandle<\n    // REVIEW: Constrain `T` to something? How do we support dds and datastores safely?\n    T = IFluidObject & FluidObject & IFluidLoadable\n    > extends IProvideFluidHandle {\n\n    /**\n     * @deprecated - Do not use handle's path for routing. Use `get` to get the underlying object.\n     *\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    /**\n     * Returns a promise to the Fluid Object referenced by the handle.\n     */\n    get(): Promise<T>;\n\n    /**\n     * Binds the given handle to this one or attach the given handle if this handle is attached.\n     * A bound handle will also be attached once this handle is attached.\n     */\n    bind(handle: IFluidHandle): void;\n}\n"]}
+{"version":3,"file":"handles.js","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,CAAC,MAAM,mBAAmB,GAAqC,qBAAqB,CAAC;AAkC3F,MAAM,CAAC,MAAM,YAAY,GAA8B,cAAc,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IRequest, IResponse } from \"./fluidRouter\";\nimport { IFluidLoadable } from \"./fluidLoadable\";\nimport { FluidObject } from \"./provider\";\n\nexport const IFluidHandleContext: keyof IProvideFluidHandleContext = \"IFluidHandleContext\";\n\nexport interface IProvideFluidHandleContext {\n    readonly IFluidHandleContext: IFluidHandleContext;\n}\n\n/**\n * An IFluidHandleContext describes a routing context from which other IFluidHandleContexts are defined\n */\nexport interface IFluidHandleContext extends IProvideFluidHandleContext {\n    /**\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * The parent IFluidHandleContext that has provided a route path to this IFluidHandleContext or undefined\n     * at the root.\n     */\n    readonly routeContext?: IFluidHandleContext;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    resolveHandle(request: IRequest): Promise<IResponse>;\n}\n\nexport const IFluidHandle: keyof IProvideFluidHandle = \"IFluidHandle\";\n\nexport interface IProvideFluidHandle {\n    readonly IFluidHandle: IFluidHandle;\n}\n\n/**\n * Handle to a shared FluidObject\n */\nexport interface IFluidHandle<\n    // REVIEW: Constrain `T` to something? How do we support dds and datastores safely?\n    T = FluidObject & IFluidLoadable\n    > extends IProvideFluidHandle {\n\n    /**\n     * @deprecated - Do not use handle's path for routing. Use `get` to get the underlying object.\n     *\n     * The absolute path to the handle context from the root.\n     */\n    readonly absolutePath: string;\n\n    /**\n     * Flag indicating whether or not the entity has services attached.\n     */\n    readonly isAttached: boolean;\n\n    /**\n     * Runs through the graph and attach the bounded handles.\n     */\n    attachGraph(): void;\n\n    /**\n     * Returns a promise to the Fluid Object referenced by the handle.\n     */\n    get(): Promise<T>;\n\n    /**\n     * Binds the given handle to this one or attach the given handle if this handle is attached.\n     * A bound handle will also be attached once this handle is attached.\n     */\n    bind(handle: IFluidHandle): void;\n}\n"]}

package/lib/provider.d.ts

@@ -21,7 +21,7 @@
  * This pattern enables discovery, and delegation in a standard way which is central
  * to FluidObject pattern
  */
-export declare type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> = string extends TProp ? never : number extends TProp ? never : TProp extends keyof Exclude<T[TProp], undefined> ? TProp : never;
+export declare type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> = string extends TProp ? never : number extends TProp ? never : TProp extends keyof Required<T>[TProp] ? Required<T>[TProp] extends Required<Required<T>[TProp]>[TProp] ? TProp : never : never;
 /**
  * This utility type take interface(s) that follow the FluidObject pattern, and produces
  * a new type that can be used for inspection and discovery of those interfaces.
@@ -52,7 +52,9 @@ export declare type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T>
  * `FluidObject<IFoo & IBar>`
  *
  */
-export declare type FluidObject<T = unknown> = Partial<Pick<T, FluidObjectProviderKeys<T>>>;
+export declare type FluidObject<T = unknown> = {
+    [P in FluidObjectProviderKeys<T>]?: T[P];
+};
 /**
  * This utility type creates a type that is the union of all keys on the generic type
  * which implement the FluidObject pattern. @see FluidObject

package/lib/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACF,oBAAY,uBAAuB,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IACnE,MAAM,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,SAAS,KAAK,GAAE,KAAK,GAC1D,KAAK,SAAS,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,GAC1C,KAAK,GACN,KAAK,CAAC;AAEf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACF,oBAAY,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAErF;;;;;;GAMG;AACH,oBAAY,eAAe,CAAC,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACF,oBAAY,uBAAuB,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IACnE,MAAM,SAAS,KAAK,GAAG,KAAK,GAAG,MAAM,SAAS,KAAK,GAAE,KAAK,GAC1D,KAAK,SAAS,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAChC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,GAC1D,KAAK,GACL,KAAK,GACT,KAAK,CAAC;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACF,oBAAY,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI;KACnC,CAAC,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAC;AAEF;;;;;;GAMG;AACH,oBAAY,eAAe,CAAC,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC"}

package/lib/provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * @internal\n * This utility type is meant for internal use by @see FluidObject\n * Produces a valid FluidObject key given a type and a property.\n * A valid FluidObject key is a property that exists on the incoming type\n * as well as on the type of the property itself. For example, IProvideFoo.IFoo.IFoo\n * This aligns with the FluidObject pattern expected to be used with all FluidObjects.\n * For example:\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n * This pattern enables discovery, and delegation in a standard way which is central\n * to FluidObject pattern\n */\n export type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> =\n    string extends TProp ? never : number extends TProp? never : // exclude indexers [key:string |number]: any\n    TProp extends keyof Exclude<T[TProp], undefined> // TProp is a property of T, and T[TProp]\n        ? TProp\n        :never;\n\n/**\n * This utility type take interface(s) that follow the FluidObject pattern, and produces\n * a new type that can be used for inspection and discovery of those interfaces.\n *\n * It is meant to be used with types that are known to implement the FluidObject pattern.\n * A common way to specify a type implements the FluidObject pattern is to expose it as a\n * FluidObject without a generic argument.\n *\n * For example, if we have an interface like below\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n *\n * and a function that returns a FluidObject. You would do the following\n *\n * `const maybeFoo: FluidObject<IFoo> = getFluidObject()`;\n *\n * Either IFoo or IProvideFoo are valid generic arguments. In both case\n * maybeFoo will be of type `{IFoo?: IFoo}`. If IFoo is not undefined,\n * then the FluidObject provides IFoo, and it can be used.\n *\n * You can inspect multiple types via a intersection. For example:\n * `FluidObject<IFoo & IBar>`\n *\n */\n export type FluidObject<T = unknown> = Partial<Pick<T, FluidObjectProviderKeys<T>>>;\n\n/**\n * This utility type creates a type that is the union of all keys on the generic type\n * which implement the FluidObject pattern. @see FluidObject\n *\n * For example `FluidObjectKeys<IFoo & IBar>` would result in `\"IFoo\" | \"IBar\"`\n *\n */\nexport type FluidObjectKeys<T> = keyof FluidObject<T>;\n"]}
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * @internal\n * This utility type is meant for internal use by @see FluidObject\n * Produces a valid FluidObject key given a type and a property.\n * A valid FluidObject key is a property that exists on the incoming type\n * as well as on the type of the property itself. For example, IProvideFoo.IFoo.IFoo\n * This aligns with the FluidObject pattern expected to be used with all FluidObjects.\n * For example:\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n * This pattern enables discovery, and delegation in a standard way which is central\n * to FluidObject pattern\n */\n export type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> =\n    string extends TProp ? never : number extends TProp? never : // exclude indexers [key:string |number]: any\n    TProp extends keyof Required<T>[TProp] // TProp is a property of T, and T[TProp]\n        ? Required<T>[TProp] extends Required<Required<T>[TProp]>[TProp] // T[TProp] is the same type as T[TProp][TProp]\n            ? TProp\n            : never\n        : never;\n\n/**\n * This utility type take interface(s) that follow the FluidObject pattern, and produces\n * a new type that can be used for inspection and discovery of those interfaces.\n *\n * It is meant to be used with types that are known to implement the FluidObject pattern.\n * A common way to specify a type implements the FluidObject pattern is to expose it as a\n * FluidObject without a generic argument.\n *\n * For example, if we have an interface like below\n * ```\n * interface IProvideFoo{\n *  IFoo: IFoo\n * }\n * interface IFoo extends IProvideFoo{\n *  foobar();\n * }\n * ```\n *\n * and a function that returns a FluidObject. You would do the following\n *\n * `const maybeFoo: FluidObject<IFoo> = getFluidObject()`;\n *\n * Either IFoo or IProvideFoo are valid generic arguments. In both case\n * maybeFoo will be of type `{IFoo?: IFoo}`. If IFoo is not undefined,\n * then the FluidObject provides IFoo, and it can be used.\n *\n * You can inspect multiple types via a intersection. For example:\n * `FluidObject<IFoo & IBar>`\n *\n */\n export type FluidObject<T = unknown> = {\n    [P in FluidObjectProviderKeys<T>]?: T[P];\n};\n\n/**\n * This utility type creates a type that is the union of all keys on the generic type\n * which implement the FluidObject pattern. @see FluidObject\n *\n * For example `FluidObjectKeys<IFoo & IBar>` would result in `\"IFoo\" | \"IBar\"`\n *\n */\nexport type FluidObjectKeys<T> = keyof FluidObject<T>;\n"]}

package/lib/test/types/fluidObjectTypes.js

@@ -1,4 +1,4 @@
-var _a, _b, _c;
+var _a, _b, _c, _d, _e, _f, _g, _h, _j;
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
@@ -77,4 +77,32 @@ import { IFluidLoadable } from "../../";
     useProvider(legacy);
     useProvider(fluidObject);
 }
+// validate nested property is FluidObject too
+{
+    const foo = getFluidObject();
+    // @ts-expect-error "Property 'z' does not exist on type 'FluidObject<IFoo>'."
+    useProvider(foo.z);
+}
+// validate provider inheritance
+{
+    const p = getFluidObject();
+    useProvider((_d = p.IFooParent) === null || _d === void 0 ? void 0 : _d.parent());
+    const c = getFluidObject();
+    // @ts-expect-error Property 'IFooParent' does not exist on type 'FluidObject<IFooProvideChild>'.
+    useProvider((_e = c.IFooParent) === null || _e === void 0 ? void 0 : _e.parent());
+    useProvider((_f = c.IFooChild) === null || _f === void 0 ? void 0 : _f.child());
+    useProvider((_g = c.IFooChild) === null || _g === void 0 ? void 0 : _g.parent());
+    useProvider((_j = (_h = c.IFooChild) === null || _h === void 0 ? void 0 : _h.IFooParent) === null || _j === void 0 ? void 0 : _j.parent());
+}
+// validate usage as builder
+{
+    const builder = {};
+    builder.IFluidLoadable = getLoadable();
+}
+// validate readonly prevents modification
+{
+    const builder = {};
+    // @ts-expect-error Cannot assign to 'IFluidLoadable' because it is a read-only property.
+    builder.IFluidLoadable = getLoadable();
+}
 //# sourceMappingURL=fluidObjectTypes.js.map

package/lib/test/types/fluidObjectTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"fluidObjectTypes.js","sourceRoot":"","sources":["../../../src/test/types/fluidObjectTypes.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\nimport { IFluidLoadable, IProvideFluidLoadable, FluidObject, FluidObjectKeys, IFluidObject } from \"../../\";\n\ndeclare function getFluidObject(): FluidObject;\n\ndeclare function useFluidObject(params: FluidObject | undefined): void;\n\ndeclare function useProvider<T extends FluidObject>(params: FluidObject<T> | undefined): void;\n\ndeclare function useProviderKey<T,TKey extends FluidObjectKeys<T> = FluidObjectKeys<T>>(key: TKey): void;\n\ndeclare function useLoadable(params: FluidObject<IFluidLoadable> | undefined): void;\n\ndeclare function use(obj: any);\n// test implicit conversions between FluidObject and a FluidObject with a provides interface\n{\n    const provider: FluidObject<IProvideFluidLoadable> = getFluidObject();\n    useFluidObject(provider);\n    useFluidObject(provider.IFluidLoadable);\n    useProvider(provider);\n    useProvider(provider.IFluidLoadable);\n    useLoadable(provider);\n    useLoadable(provider.IFluidLoadable);\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    use(provider.handle);\n    use(provider.IFluidLoadable?.handle);\n    const unknown: FluidObject | undefined = provider.IFluidLoadable;\n    useFluidObject(unknown);\n    useProvider(unknown);\n    useProvider<IFluidLoadable>(unknown);\n    useLoadable(unknown);\n}\n\n// test implicit conversions between FluidObject and a FluidObject with a implementation interface\n{\n    const foo: FluidObject<IFluidLoadable> = getFluidObject();\n    useFluidObject(foo);\n    useFluidObject(foo.IFluidLoadable);\n    useProvider(foo);\n    useProvider(foo.IFluidLoadable);\n    useLoadable(foo);\n    useLoadable(foo.IFluidLoadable);\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    use(foo.handle);\n    use(foo.IFluidLoadable?.handle);\n    const unknown: FluidObject | undefined = foo.IFluidLoadable;\n    useFluidObject(unknown);\n    useProvider(unknown);\n    useProvider<IFluidLoadable>(unknown);\n    useLoadable(unknown);\n}\n\n// test getting keys\n{\n    useProviderKey<IProvideFluidLoadable>(IFluidLoadable);\n    useProviderKey<IFluidLoadable>(IFluidLoadable);\n    const loadableKey: keyof IFluidLoadable = \"handle\";\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    useProviderKey<IFluidLoadable>(loadableKey);\n}\n\n// test implicit conversions between FluidObject and a FluidObject with a partial provider interface\n{\n    interface IProvideFoo{\n        IFoo: IFoo;\n    }\n    interface IFoo extends Partial<IProvideFoo>{\n        doFoo();\n    }\n\n    const foo: FluidObject<IFoo> = getFluidObject();\n    useFluidObject(foo);\n    useFluidObject(foo.IFoo);\n    useProvider(foo);\n    useProvider(foo.IFoo);\n    foo.IFoo?.doFoo();\n    const fooKey: keyof IFoo = \"doFoo\";\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    useProviderKey<IFoo>(fooKey);\n    const unknown: FluidObject | undefined = foo.IFoo;\n    useFluidObject(unknown);\n    useProvider(unknown);\n    useProvider<IFoo>(unknown);\n    useLoadable(unknown);\n}\n\n// test implicit conversions between FluidObject and IFluidObject for backcompat\ndeclare function getIFluidObject(): IFluidObject;\n{\n    const fluidObject: FluidObject = getIFluidObject();\n    const legacy: IFluidObject = getFluidObject();\n    useLoadable(fluidObject);\n    useLoadable(legacy);\n    useFluidObject(fluidObject);\n    useFluidObject(legacy);\n    useProvider(legacy);\n    useProvider(fluidObject);\n    useProvider<IFluidLoadable>(legacy);\n    useProvider<IFluidLoadable>(fluidObject);\n}\n"]}
+{"version":3,"file":"fluidObjectTypes.js","sourceRoot":"","sources":["../../../src/test/types/fluidObjectTypes.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\nimport { IFluidLoadable, IProvideFluidLoadable, FluidObject, FluidObjectKeys, IFluidObject } from \"../../\";\n\ndeclare function getFluidObject(): FluidObject;\n\ndeclare function useFluidObject(params: FluidObject | undefined): void;\n\ndeclare function useProvider<T extends FluidObject>(params: FluidObject<T> | undefined): void;\n\ndeclare function useProviderKey<T,TKey extends FluidObjectKeys<T> = FluidObjectKeys<T>>(key: TKey): void;\n\ndeclare function useLoadable(params: FluidObject<IFluidLoadable> | undefined): void;\ndeclare function getLoadable(): IFluidLoadable;\n\ndeclare function use(obj: any);\n// test implicit conversions between FluidObject and a FluidObject with a provides interface\n{\n    const provider: FluidObject<IProvideFluidLoadable> = getFluidObject();\n    useFluidObject(provider);\n    useFluidObject(provider.IFluidLoadable);\n    useProvider(provider);\n    useProvider(provider.IFluidLoadable);\n    useLoadable(provider);\n    useLoadable(provider.IFluidLoadable);\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    use(provider.handle);\n    use(provider.IFluidLoadable?.handle);\n    const unknown: FluidObject | undefined = provider.IFluidLoadable;\n    useFluidObject(unknown);\n    useProvider(unknown);\n    useProvider<IFluidLoadable>(unknown);\n    useLoadable(unknown);\n}\n\n// test implicit conversions between FluidObject and a FluidObject with a implementation interface\n{\n    const foo: FluidObject<IFluidLoadable> = getFluidObject();\n    useFluidObject(foo);\n    useFluidObject(foo.IFluidLoadable);\n    useProvider(foo);\n    useProvider(foo.IFluidLoadable);\n    useLoadable(foo);\n    useLoadable(foo.IFluidLoadable);\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    use(foo.handle);\n    use(foo.IFluidLoadable?.handle);\n    const unknown: FluidObject | undefined = foo.IFluidLoadable;\n    useFluidObject(unknown);\n    useProvider(unknown);\n    useProvider<IFluidLoadable>(unknown);\n    useLoadable(unknown);\n}\n\n// test getting keys\n{\n    useProviderKey<IProvideFluidLoadable>(IFluidLoadable);\n    useProviderKey<IFluidLoadable>(IFluidLoadable);\n    const loadableKey: keyof IFluidLoadable = \"handle\";\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    useProviderKey<IFluidLoadable>(loadableKey);\n}\n\n// test implicit conversions between FluidObject and a FluidObject with a partial provider interface\n{\n    interface IProvideFoo{\n        IFoo: IFoo;\n    }\n    interface IFoo extends Partial<IProvideFoo>{\n        doFoo();\n    }\n\n    const foo: FluidObject<IFoo> = getFluidObject();\n    useFluidObject(foo);\n    useFluidObject(foo.IFoo);\n    useProvider(foo);\n    useProvider(foo.IFoo);\n    foo.IFoo?.doFoo();\n    const fooKey: keyof IFoo = \"doFoo\";\n    // @ts-expect-error provider shouldn't have any non-provider properties\n    useProviderKey<IFoo>(fooKey);\n    const unknown: FluidObject | undefined = foo.IFoo;\n    useFluidObject(unknown);\n    useProvider(unknown);\n    useProvider<IFoo>(unknown);\n    useLoadable(unknown);\n}\n\n// test implicit conversions between FluidObject and IFluidObject for backcompat\ndeclare function getIFluidObject(): IFluidObject;\n{\n    const fluidObject: FluidObject = getIFluidObject();\n    const legacy: IFluidObject = getFluidObject();\n    useLoadable(fluidObject);\n    useLoadable(legacy);\n    useFluidObject(fluidObject);\n    useFluidObject(legacy);\n    useProvider(legacy);\n    useProvider(fluidObject);\n    useProvider<IFluidLoadable>(legacy);\n    useProvider<IFluidLoadable>(fluidObject);\n}\n\n// validate nested property is FluidObject too\n{\n    interface IFoo {\n        z: { z: { z: boolean } };\n      }\n\n    const foo: FluidObject<IFoo> = getFluidObject();\n    // @ts-expect-error \"Property 'z' does not exist on type 'FluidObject<IFoo>'.\"\n    useProvider(foo.z);\n}\n\n// validate provider inheritance\n{\n    interface IProvideFooParent{\n        IFooParent: IFooParent\n    }\n\n    interface IFooParent extends Partial<IProvideFooParent>{\n        parent();\n    }\n\n    interface IFooProvideChild {\n        IFooChild: IFooChild\n    }\n\n    interface IFooChild extends IFooParent, Partial<IFooProvideChild>{\n        child();\n    }\n\n    const p: FluidObject<IProvideFooParent> = getFluidObject();\n    useProvider(p.IFooParent?.parent());\n\n    const c: FluidObject<IFooProvideChild> = getFluidObject();\n    // @ts-expect-error Property 'IFooParent' does not exist on type 'FluidObject<IFooProvideChild>'.\n    useProvider(c.IFooParent?.parent());\n    useProvider(c.IFooChild?.child());\n    useProvider(c.IFooChild?.parent());\n    useProvider(c.IFooChild?.IFooParent?.parent());\n}\n\n// validate usage as builder\n{\n    const builder: FluidObject<IFluidLoadable> = {};\n    builder.IFluidLoadable = getLoadable();\n}\n\n// validate readonly prevents modification\n{\n    const builder: Readonly<FluidObject<IFluidLoadable>> = {};\n    // @ts-expect-error Cannot assign to 'IFluidLoadable' because it is a read-only property.\n    builder.IFluidLoadable = getLoadable();\n}\n"]}

package/lib/test/types/validateCoreInterfacesPrevious.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validateCoreInterfacesPrevious.d.ts.map

package/lib/test/types/validateCoreInterfacesPrevious.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateCoreInterfacesPrevious.d.ts","sourceRoot":"","sources":["../../../src/test/types/validateCoreInterfacesPrevious.ts"],"names":[],"mappings":""}

package/lib/test/types/{validate0.41.0.js → validateCoreInterfacesPrevious.js}

@@ -75,4 +75,4 @@ use_old_VariableDeclaration_isFluidCodeDetails(get_current_VariableDeclaration_i
 use_current_VariableDeclaration_isFluidPackage(get_old_VariableDeclaration_isFluidPackage());
 use_old_VariableDeclaration_isFluidPackage(get_current_VariableDeclaration_isFluidPackage());
 export {};
-//# sourceMappingURL=validate0.41.0.js.map
+//# sourceMappingURL=validateCoreInterfacesPrevious.js.map

package/lib/test/types/validateCoreInterfacesPrevious.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateCoreInterfacesPrevious.js","sourceRoot":"","sources":["../../../src/test/types/validateCoreInterfacesPrevious.ts"],"names":[],"mappings":"AAyBA,4CAA4C,CACxC,wCAAwC,EAAE,CAAC,CAAC;AAWhD,wCAAwC,CACpC,4CAA4C,EAAE,CAAC,CAAC;AAWpD,gDAAgD,CAC5C,4CAA4C,EAAE,CAAC,CAAC;AAWpD,4CAA4C,CACxC,gDAAgD,EAAE,CAAC,CAAC;AAWxD,wDAAwD,CACpD,oDAAoD,EAAE,CAAC,CAAC;AAW5D,oDAAoD,CAChD,wDAAwD,EAAE,CAAC,CAAC;AAWhE,kDAAkD,CAC9C,8CAA8C,EAAE,CAAC,CAAC;AAWtD,8CAA8C,CAC1C,kDAAkD,EAAE,CAAC,CAAC;AAW1D,yDAAyD,CACrD,qDAAqD,EAAE,CAAC,CAAC;AAW7D,qDAAqD,CACjD,yDAAyD,EAAE,CAAC,CAAC;AAWjE,0DAA0D,CACtD,sDAAsD,EAAE,CAAC,CAAC;AAW9D,sDAAsD,CAClD,0DAA0D,EAAE,CAAC,CAAC;AAWlE,wDAAwD,CACpD,oDAAoD,EAAE,CAAC,CAAC;AAW5D,oDAAoD,CAChD,wDAAwD,EAAE,CAAC,CAAC;AAYhE,0DAA0D,CACtD,+CAA+C,EAAE,CAAC,CAAC;AAYvD,+CAA+C,CAC3C,0DAA0D,EAAE,CAAC,CAAC;AAYlE,2DAA2D,CACvD,gDAAgD,EAAE,CAAC,CAAC;AAYxD,gDAAgD,CAC5C,2DAA2D,EAAE,CAAC,CAAC;AAWnE,4CAA4C,CACxC,wCAAwC,EAAE,CAAC,CAAC;AAWhD,wCAAwC,CACpC,4CAA4C,EAAE,CAAC,CAAC;AAWpD,6CAA6C,CACzC,yCAAyC,EAAE,CAAC,CAAC;AAWjD,yCAAyC,CACrC,6CAA6C,EAAE,CAAC,CAAC;AAWrD,mDAAmD,CAC/C,+CAA+C,EAAE,CAAC,CAAC;AAWvD,+CAA+C,CAC3C,mDAAmD,EAAE,CAAC,CAAC;AAW3D,oDAAoD,CAChD,gDAAgD,EAAE,CAAC,CAAC;AAWxD,gDAAgD,CAC5C,oDAAoD,EAAE,CAAC,CAAC;AAW5D,8CAA8C,CAC1C,0CAA0C,EAAE,CAAC,CAAC;AAWlD,0CAA0C,CACtC,8CAA8C,EAAE,CAAC,CAAC;AAWtD,+CAA+C,CAC3C,2CAA2C,EAAE,CAAC,CAAC;AAWnD,2CAA2C,CACvC,+CAA+C,EAAE,CAAC,CAAC;AAWvD,6CAA6C,CACzC,yCAAyC,EAAE,CAAC,CAAC;AAWjD,yCAAyC,CACrC,6CAA6C,EAAE,CAAC,CAAC;AAWrD,8CAA8C,CAC1C,0CAA0C,EAAE,CAAC,CAAC;AAWlD,0CAA0C,CACtC,8CAA8C,EAAE,CAAC,CAAC;AAWtD,yDAAyD,CACrD,qDAAqD,EAAE,CAAC,CAAC;AAW7D,qDAAqD,CACjD,yDAAyD,EAAE,CAAC,CAAC;AAWjE,4CAA4C,CACxC,wCAAwC,EAAE,CAAC,CAAC;AAWhD,wCAAwC,CACpC,4CAA4C,EAAE,CAAC,CAAC;AAWpD,6CAA6C,CACzC,yCAAyC,EAAE,CAAC,CAAC;AAWjD,yCAAyC,CACrC,6CAA6C,EAAE,CAAC,CAAC;AAWrD,8CAA8C,CAC1C,0CAA0C,EAAE,CAAC,CAAC;AAWlD,0CAA0C,CACtC,8CAA8C,EAAE,CAAC,CAAC;AAWtD,+CAA+C,CAC3C,2CAA2C,EAAE,CAAC,CAAC;AAWnD,2CAA2C,CACvC,+CAA+C,EAAE,CAAC,CAAC;AAWvD,gDAAgD,CAC5C,4CAA4C,EAAE,CAAC,CAAC;AAWpD,4CAA4C,CACxC,gDAAgD,EAAE,CAAC,CAAC;AAWxD,iDAAiD,CAC7C,6CAA6C,EAAE,CAAC,CAAC;AAWrD,6CAA6C,CACzC,iDAAiD,EAAE,CAAC,CAAC;AAWzD,iEAAiE,CAC7D,6DAA6D,EAAE,CAAC,CAAC;AAWrE,6DAA6D,CACzD,iEAAiE,EAAE,CAAC,CAAC;AAYzE,kEAAkE,CAC9D,uDAAuD,EAAE,CAAC,CAAC;AAY/D,uDAAuD,CACnD,kEAAkE,EAAE,CAAC,CAAC;AAW1E,oDAAoD,CAChD,gDAAgD,EAAE,CAAC,CAAC;AAWxD,gDAAgD,CAC5C,oDAAoD,EAAE,CAAC,CAAC;AAW5D,2DAA2D,CACvD,uDAAuD,EAAE,CAAC,CAAC;AAW/D,uDAAuD,CACnD,2DAA2D,EAAE,CAAC,CAAC;AAWnE,sDAAsD,CAClD,kDAAkD,EAAE,CAAC,CAAC;AAW1D,kDAAkD,CAC9C,sDAAsD,EAAE,CAAC,CAAC;AAW9D,oDAAoD,CAChD,gDAAgD,EAAE,CAAC,CAAC;AAWxD,gDAAgD,CAC5C,oDAAoD,EAAE,CAAC,CAAC;AAW5D,sDAAsD,CAClD,kDAAkD,EAAE,CAAC,CAAC;AAW1D,kDAAkD,CAC9C,sDAAsD,EAAE,CAAC,CAAC;AAW9D,wDAAwD,CACpD,oDAAoD,EAAE,CAAC,CAAC;AAW5D,oDAAoD,CAChD,wDAAwD,EAAE,CAAC,CAAC;AAWhE,yCAAyC,CACrC,qCAAqC,EAAE,CAAC,CAAC;AAW7C,qCAAqC,CACjC,yCAAyC,EAAE,CAAC,CAAC;AAWjD,+CAA+C,CAC3C,2CAA2C,EAAE,CAAC,CAAC;AAWnD,2CAA2C,CACvC,+CAA+C,EAAE,CAAC,CAAC;AAWvD,0CAA0C,CACtC,sCAAsC,EAAE,CAAC,CAAC;AAW9C,sCAAsC,CAClC,0CAA0C,EAAE,CAAC,CAAC;AAWlD,kDAAkD,CAC9C,8CAA8C,EAAE,CAAC,CAAC;AAWtD,8CAA8C,CAC1C,kDAAkD,EAAE,CAAC,CAAC;AAW1D,kDAAkD,CAC9C,8CAA8C,EAAE,CAAC,CAAC;AAWtD,8CAA8C,CAC1C,kDAAkD,EAAE,CAAC,CAAC;AAW1D,8CAA8C,CAC1C,0CAA0C,EAAE,CAAC,CAAC;AAWlD,0CAA0C,CACtC,8CAA8C,EAAE,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n/*\n * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.\n * Generated by fluid-type-validator in @fluidframework/build-tools.\n */\n/* eslint-disable max-lines */\nimport * as old from \"@fluidframework/core-interfaces-previous\";\nimport * as current from \"../../index\";\n\ntype TypeOnly<T> = {\n    [P in keyof T]: TypeOnly<T[P]>;\n};\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"TypeAliasDeclaration_FluidObject\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_FluidObject():\n    TypeOnly<old.FluidObject>;\ndeclare function use_current_TypeAliasDeclaration_FluidObject(\n    use: TypeOnly<current.FluidObject>);\nuse_current_TypeAliasDeclaration_FluidObject(\n    get_old_TypeAliasDeclaration_FluidObject());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"TypeAliasDeclaration_FluidObject\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_FluidObject():\n    TypeOnly<current.FluidObject>;\ndeclare function use_old_TypeAliasDeclaration_FluidObject(\n    use: TypeOnly<old.FluidObject>);\nuse_old_TypeAliasDeclaration_FluidObject(\n    get_current_TypeAliasDeclaration_FluidObject());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"TypeAliasDeclaration_FluidObjectKeys\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_FluidObjectKeys():\n    TypeOnly<old.FluidObjectKeys<any>>;\ndeclare function use_current_TypeAliasDeclaration_FluidObjectKeys(\n    use: TypeOnly<current.FluidObjectKeys<any>>);\nuse_current_TypeAliasDeclaration_FluidObjectKeys(\n    get_old_TypeAliasDeclaration_FluidObjectKeys());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"TypeAliasDeclaration_FluidObjectKeys\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_FluidObjectKeys():\n    TypeOnly<current.FluidObjectKeys<any>>;\ndeclare function use_old_TypeAliasDeclaration_FluidObjectKeys(\n    use: TypeOnly<old.FluidObjectKeys<any>>);\nuse_old_TypeAliasDeclaration_FluidObjectKeys(\n    get_current_TypeAliasDeclaration_FluidObjectKeys());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"TypeAliasDeclaration_FluidObjectProviderKeys\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_TypeAliasDeclaration_FluidObjectProviderKeys():\n    TypeOnly<old.FluidObjectProviderKeys<any,any>>;\ndeclare function use_current_TypeAliasDeclaration_FluidObjectProviderKeys(\n    use: TypeOnly<current.FluidObjectProviderKeys<any,any>>);\nuse_current_TypeAliasDeclaration_FluidObjectProviderKeys(\n    get_old_TypeAliasDeclaration_FluidObjectProviderKeys());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"TypeAliasDeclaration_FluidObjectProviderKeys\": {\"backCompat\": false}\n*/\ndeclare function get_current_TypeAliasDeclaration_FluidObjectProviderKeys():\n    TypeOnly<current.FluidObjectProviderKeys<any,any>>;\ndeclare function use_old_TypeAliasDeclaration_FluidObjectProviderKeys(\n    use: TypeOnly<old.FluidObjectProviderKeys<any,any>>);\nuse_old_TypeAliasDeclaration_FluidObjectProviderKeys(\n    get_current_TypeAliasDeclaration_FluidObjectProviderKeys());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidCodeDetails\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidCodeDetails():\n    TypeOnly<old.IFluidCodeDetails>;\ndeclare function use_current_InterfaceDeclaration_IFluidCodeDetails(\n    use: TypeOnly<current.IFluidCodeDetails>);\nuse_current_InterfaceDeclaration_IFluidCodeDetails(\n    get_old_InterfaceDeclaration_IFluidCodeDetails());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidCodeDetails\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidCodeDetails():\n    TypeOnly<current.IFluidCodeDetails>;\ndeclare function use_old_InterfaceDeclaration_IFluidCodeDetails(\n    use: TypeOnly<old.IFluidCodeDetails>);\nuse_old_InterfaceDeclaration_IFluidCodeDetails(\n    get_current_InterfaceDeclaration_IFluidCodeDetails());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidCodeDetailsComparer\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidCodeDetailsComparer():\n    TypeOnly<typeof old.IFluidCodeDetailsComparer>;\ndeclare function use_current_VariableDeclaration_IFluidCodeDetailsComparer(\n    use: TypeOnly<typeof current.IFluidCodeDetailsComparer>);\nuse_current_VariableDeclaration_IFluidCodeDetailsComparer(\n    get_old_VariableDeclaration_IFluidCodeDetailsComparer());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidCodeDetailsComparer\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IFluidCodeDetailsComparer():\n    TypeOnly<typeof current.IFluidCodeDetailsComparer>;\ndeclare function use_old_VariableDeclaration_IFluidCodeDetailsComparer(\n    use: TypeOnly<typeof old.IFluidCodeDetailsComparer>);\nuse_old_VariableDeclaration_IFluidCodeDetailsComparer(\n    get_current_VariableDeclaration_IFluidCodeDetailsComparer());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidCodeDetailsComparer\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidCodeDetailsComparer():\n    TypeOnly<old.IFluidCodeDetailsComparer>;\ndeclare function use_current_InterfaceDeclaration_IFluidCodeDetailsComparer(\n    use: TypeOnly<current.IFluidCodeDetailsComparer>);\nuse_current_InterfaceDeclaration_IFluidCodeDetailsComparer(\n    get_old_InterfaceDeclaration_IFluidCodeDetailsComparer());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidCodeDetailsComparer\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidCodeDetailsComparer():\n    TypeOnly<current.IFluidCodeDetailsComparer>;\ndeclare function use_old_InterfaceDeclaration_IFluidCodeDetailsComparer(\n    use: TypeOnly<old.IFluidCodeDetailsComparer>);\nuse_old_InterfaceDeclaration_IFluidCodeDetailsComparer(\n    get_current_InterfaceDeclaration_IFluidCodeDetailsComparer());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidCodeDetailsConfig\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidCodeDetailsConfig():\n    TypeOnly<old.IFluidCodeDetailsConfig>;\ndeclare function use_current_InterfaceDeclaration_IFluidCodeDetailsConfig(\n    use: TypeOnly<current.IFluidCodeDetailsConfig>);\nuse_current_InterfaceDeclaration_IFluidCodeDetailsConfig(\n    get_old_InterfaceDeclaration_IFluidCodeDetailsConfig());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidCodeDetailsConfig\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidCodeDetailsConfig():\n    TypeOnly<current.IFluidCodeDetailsConfig>;\ndeclare function use_old_InterfaceDeclaration_IFluidCodeDetailsConfig(\n    use: TypeOnly<old.IFluidCodeDetailsConfig>);\nuse_old_InterfaceDeclaration_IFluidCodeDetailsConfig(\n    get_current_InterfaceDeclaration_IFluidCodeDetailsConfig());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"RemovedVariableDeclaration_IFluidConfiguration\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidConfiguration():\n    TypeOnly<typeof old.IFluidConfiguration>;\ndeclare function use_current_RemovedVariableDeclaration_IFluidConfiguration(\n    // @ts-expect-error compatibility expected to be broken\n    use: TypeOnly<typeof current.IFluidConfiguration>);\nuse_current_RemovedVariableDeclaration_IFluidConfiguration(\n    get_old_VariableDeclaration_IFluidConfiguration());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"RemovedVariableDeclaration_IFluidConfiguration\": {\"backCompat\": false}\n*/\ndeclare function get_current_RemovedVariableDeclaration_IFluidConfiguration():\n    // @ts-expect-error compatibility expected to be broken\n    TypeOnly<typeof current.IFluidConfiguration>;\ndeclare function use_old_VariableDeclaration_IFluidConfiguration(\n    use: TypeOnly<typeof old.IFluidConfiguration>);\nuse_old_VariableDeclaration_IFluidConfiguration(\n    get_current_RemovedVariableDeclaration_IFluidConfiguration());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"RemovedInterfaceDeclaration_IFluidConfiguration\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidConfiguration():\n    TypeOnly<old.IFluidConfiguration>;\ndeclare function use_current_RemovedInterfaceDeclaration_IFluidConfiguration(\n    // @ts-expect-error compatibility expected to be broken\n    use: TypeOnly<current.IFluidConfiguration>);\nuse_current_RemovedInterfaceDeclaration_IFluidConfiguration(\n    get_old_InterfaceDeclaration_IFluidConfiguration());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"RemovedInterfaceDeclaration_IFluidConfiguration\": {\"backCompat\": false}\n*/\ndeclare function get_current_RemovedInterfaceDeclaration_IFluidConfiguration():\n    // @ts-expect-error compatibility expected to be broken\n    TypeOnly<current.IFluidConfiguration>;\ndeclare function use_old_InterfaceDeclaration_IFluidConfiguration(\n    use: TypeOnly<old.IFluidConfiguration>);\nuse_old_InterfaceDeclaration_IFluidConfiguration(\n    get_current_RemovedInterfaceDeclaration_IFluidConfiguration());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidHandle\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidHandle():\n    TypeOnly<typeof old.IFluidHandle>;\ndeclare function use_current_VariableDeclaration_IFluidHandle(\n    use: TypeOnly<typeof current.IFluidHandle>);\nuse_current_VariableDeclaration_IFluidHandle(\n    get_old_VariableDeclaration_IFluidHandle());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidHandle\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IFluidHandle():\n    TypeOnly<typeof current.IFluidHandle>;\ndeclare function use_old_VariableDeclaration_IFluidHandle(\n    use: TypeOnly<typeof old.IFluidHandle>);\nuse_old_VariableDeclaration_IFluidHandle(\n    get_current_VariableDeclaration_IFluidHandle());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidHandle\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidHandle():\n    TypeOnly<old.IFluidHandle>;\ndeclare function use_current_InterfaceDeclaration_IFluidHandle(\n    use: TypeOnly<current.IFluidHandle>);\nuse_current_InterfaceDeclaration_IFluidHandle(\n    get_old_InterfaceDeclaration_IFluidHandle());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidHandle\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidHandle():\n    TypeOnly<current.IFluidHandle>;\ndeclare function use_old_InterfaceDeclaration_IFluidHandle(\n    use: TypeOnly<old.IFluidHandle>);\nuse_old_InterfaceDeclaration_IFluidHandle(\n    get_current_InterfaceDeclaration_IFluidHandle());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidHandleContext\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidHandleContext():\n    TypeOnly<typeof old.IFluidHandleContext>;\ndeclare function use_current_VariableDeclaration_IFluidHandleContext(\n    use: TypeOnly<typeof current.IFluidHandleContext>);\nuse_current_VariableDeclaration_IFluidHandleContext(\n    get_old_VariableDeclaration_IFluidHandleContext());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidHandleContext\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IFluidHandleContext():\n    TypeOnly<typeof current.IFluidHandleContext>;\ndeclare function use_old_VariableDeclaration_IFluidHandleContext(\n    use: TypeOnly<typeof old.IFluidHandleContext>);\nuse_old_VariableDeclaration_IFluidHandleContext(\n    get_current_VariableDeclaration_IFluidHandleContext());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidHandleContext\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidHandleContext():\n    TypeOnly<old.IFluidHandleContext>;\ndeclare function use_current_InterfaceDeclaration_IFluidHandleContext(\n    use: TypeOnly<current.IFluidHandleContext>);\nuse_current_InterfaceDeclaration_IFluidHandleContext(\n    get_old_InterfaceDeclaration_IFluidHandleContext());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidHandleContext\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidHandleContext():\n    TypeOnly<current.IFluidHandleContext>;\ndeclare function use_old_InterfaceDeclaration_IFluidHandleContext(\n    use: TypeOnly<old.IFluidHandleContext>);\nuse_old_InterfaceDeclaration_IFluidHandleContext(\n    get_current_InterfaceDeclaration_IFluidHandleContext());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidLoadable\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidLoadable():\n    TypeOnly<typeof old.IFluidLoadable>;\ndeclare function use_current_VariableDeclaration_IFluidLoadable(\n    use: TypeOnly<typeof current.IFluidLoadable>);\nuse_current_VariableDeclaration_IFluidLoadable(\n    get_old_VariableDeclaration_IFluidLoadable());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidLoadable\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IFluidLoadable():\n    TypeOnly<typeof current.IFluidLoadable>;\ndeclare function use_old_VariableDeclaration_IFluidLoadable(\n    use: TypeOnly<typeof old.IFluidLoadable>);\nuse_old_VariableDeclaration_IFluidLoadable(\n    get_current_VariableDeclaration_IFluidLoadable());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidLoadable\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidLoadable():\n    TypeOnly<old.IFluidLoadable>;\ndeclare function use_current_InterfaceDeclaration_IFluidLoadable(\n    use: TypeOnly<current.IFluidLoadable>);\nuse_current_InterfaceDeclaration_IFluidLoadable(\n    get_old_InterfaceDeclaration_IFluidLoadable());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidLoadable\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidLoadable():\n    TypeOnly<current.IFluidLoadable>;\ndeclare function use_old_InterfaceDeclaration_IFluidLoadable(\n    use: TypeOnly<old.IFluidLoadable>);\nuse_old_InterfaceDeclaration_IFluidLoadable(\n    get_current_InterfaceDeclaration_IFluidLoadable());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidObject\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidObject():\n    TypeOnly<old.IFluidObject>;\ndeclare function use_current_InterfaceDeclaration_IFluidObject(\n    use: TypeOnly<current.IFluidObject>);\nuse_current_InterfaceDeclaration_IFluidObject(\n    get_old_InterfaceDeclaration_IFluidObject());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidObject\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidObject():\n    TypeOnly<current.IFluidObject>;\ndeclare function use_old_InterfaceDeclaration_IFluidObject(\n    use: TypeOnly<old.IFluidObject>);\nuse_old_InterfaceDeclaration_IFluidObject(\n    get_current_InterfaceDeclaration_IFluidObject());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidPackage\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidPackage():\n    TypeOnly<old.IFluidPackage>;\ndeclare function use_current_InterfaceDeclaration_IFluidPackage(\n    use: TypeOnly<current.IFluidPackage>);\nuse_current_InterfaceDeclaration_IFluidPackage(\n    get_old_InterfaceDeclaration_IFluidPackage());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidPackage\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidPackage():\n    TypeOnly<current.IFluidPackage>;\ndeclare function use_old_InterfaceDeclaration_IFluidPackage(\n    use: TypeOnly<old.IFluidPackage>);\nuse_old_InterfaceDeclaration_IFluidPackage(\n    get_current_InterfaceDeclaration_IFluidPackage());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidPackageEnvironment\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidPackageEnvironment():\n    TypeOnly<old.IFluidPackageEnvironment>;\ndeclare function use_current_InterfaceDeclaration_IFluidPackageEnvironment(\n    use: TypeOnly<current.IFluidPackageEnvironment>);\nuse_current_InterfaceDeclaration_IFluidPackageEnvironment(\n    get_old_InterfaceDeclaration_IFluidPackageEnvironment());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidPackageEnvironment\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidPackageEnvironment():\n    TypeOnly<current.IFluidPackageEnvironment>;\ndeclare function use_old_InterfaceDeclaration_IFluidPackageEnvironment(\n    use: TypeOnly<old.IFluidPackageEnvironment>);\nuse_old_InterfaceDeclaration_IFluidPackageEnvironment(\n    get_current_InterfaceDeclaration_IFluidPackageEnvironment());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidRouter\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidRouter():\n    TypeOnly<typeof old.IFluidRouter>;\ndeclare function use_current_VariableDeclaration_IFluidRouter(\n    use: TypeOnly<typeof current.IFluidRouter>);\nuse_current_VariableDeclaration_IFluidRouter(\n    get_old_VariableDeclaration_IFluidRouter());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidRouter\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IFluidRouter():\n    TypeOnly<typeof current.IFluidRouter>;\ndeclare function use_old_VariableDeclaration_IFluidRouter(\n    use: TypeOnly<typeof old.IFluidRouter>);\nuse_old_VariableDeclaration_IFluidRouter(\n    get_current_VariableDeclaration_IFluidRouter());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidRouter\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidRouter():\n    TypeOnly<old.IFluidRouter>;\ndeclare function use_current_InterfaceDeclaration_IFluidRouter(\n    use: TypeOnly<current.IFluidRouter>);\nuse_current_InterfaceDeclaration_IFluidRouter(\n    get_old_InterfaceDeclaration_IFluidRouter());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidRouter\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidRouter():\n    TypeOnly<current.IFluidRouter>;\ndeclare function use_old_InterfaceDeclaration_IFluidRouter(\n    use: TypeOnly<old.IFluidRouter>);\nuse_old_InterfaceDeclaration_IFluidRouter(\n    get_current_InterfaceDeclaration_IFluidRouter());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidRunnable\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidRunnable():\n    TypeOnly<typeof old.IFluidRunnable>;\ndeclare function use_current_VariableDeclaration_IFluidRunnable(\n    use: TypeOnly<typeof current.IFluidRunnable>);\nuse_current_VariableDeclaration_IFluidRunnable(\n    get_old_VariableDeclaration_IFluidRunnable());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidRunnable\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IFluidRunnable():\n    TypeOnly<typeof current.IFluidRunnable>;\ndeclare function use_old_VariableDeclaration_IFluidRunnable(\n    use: TypeOnly<typeof old.IFluidRunnable>);\nuse_old_VariableDeclaration_IFluidRunnable(\n    get_current_VariableDeclaration_IFluidRunnable());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidRunnable\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidRunnable():\n    TypeOnly<old.IFluidRunnable>;\ndeclare function use_current_InterfaceDeclaration_IFluidRunnable(\n    use: TypeOnly<current.IFluidRunnable>);\nuse_current_InterfaceDeclaration_IFluidRunnable(\n    get_old_InterfaceDeclaration_IFluidRunnable());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidRunnable\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidRunnable():\n    TypeOnly<current.IFluidRunnable>;\ndeclare function use_old_InterfaceDeclaration_IFluidRunnable(\n    use: TypeOnly<old.IFluidRunnable>);\nuse_old_InterfaceDeclaration_IFluidRunnable(\n    get_current_InterfaceDeclaration_IFluidRunnable());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidSerializer\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_IFluidSerializer():\n    TypeOnly<typeof old.IFluidSerializer>;\ndeclare function use_current_VariableDeclaration_IFluidSerializer(\n    use: TypeOnly<typeof current.IFluidSerializer>);\nuse_current_VariableDeclaration_IFluidSerializer(\n    get_old_VariableDeclaration_IFluidSerializer());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_IFluidSerializer\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_IFluidSerializer():\n    TypeOnly<typeof current.IFluidSerializer>;\ndeclare function use_old_VariableDeclaration_IFluidSerializer(\n    use: TypeOnly<typeof old.IFluidSerializer>);\nuse_old_VariableDeclaration_IFluidSerializer(\n    get_current_VariableDeclaration_IFluidSerializer());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidSerializer\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IFluidSerializer():\n    TypeOnly<old.IFluidSerializer>;\ndeclare function use_current_InterfaceDeclaration_IFluidSerializer(\n    use: TypeOnly<current.IFluidSerializer>);\nuse_current_InterfaceDeclaration_IFluidSerializer(\n    get_old_InterfaceDeclaration_IFluidSerializer());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IFluidSerializer\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IFluidSerializer():\n    TypeOnly<current.IFluidSerializer>;\ndeclare function use_old_InterfaceDeclaration_IFluidSerializer(\n    use: TypeOnly<old.IFluidSerializer>);\nuse_old_InterfaceDeclaration_IFluidSerializer(\n    get_current_InterfaceDeclaration_IFluidSerializer());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidCodeDetailsComparer\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidCodeDetailsComparer():\n    TypeOnly<old.IProvideFluidCodeDetailsComparer>;\ndeclare function use_current_InterfaceDeclaration_IProvideFluidCodeDetailsComparer(\n    use: TypeOnly<current.IProvideFluidCodeDetailsComparer>);\nuse_current_InterfaceDeclaration_IProvideFluidCodeDetailsComparer(\n    get_old_InterfaceDeclaration_IProvideFluidCodeDetailsComparer());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidCodeDetailsComparer\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IProvideFluidCodeDetailsComparer():\n    TypeOnly<current.IProvideFluidCodeDetailsComparer>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidCodeDetailsComparer(\n    use: TypeOnly<old.IProvideFluidCodeDetailsComparer>);\nuse_old_InterfaceDeclaration_IProvideFluidCodeDetailsComparer(\n    get_current_InterfaceDeclaration_IProvideFluidCodeDetailsComparer());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"RemovedInterfaceDeclaration_IProvideFluidConfiguration\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidConfiguration():\n    TypeOnly<old.IProvideFluidConfiguration>;\ndeclare function use_current_RemovedInterfaceDeclaration_IProvideFluidConfiguration(\n    // @ts-expect-error compatibility expected to be broken\n    use: TypeOnly<current.IProvideFluidConfiguration>);\nuse_current_RemovedInterfaceDeclaration_IProvideFluidConfiguration(\n    get_old_InterfaceDeclaration_IProvideFluidConfiguration());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"RemovedInterfaceDeclaration_IProvideFluidConfiguration\": {\"backCompat\": false}\n*/\ndeclare function get_current_RemovedInterfaceDeclaration_IProvideFluidConfiguration():\n    // @ts-expect-error compatibility expected to be broken\n    TypeOnly<current.IProvideFluidConfiguration>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidConfiguration(\n    use: TypeOnly<old.IProvideFluidConfiguration>);\nuse_old_InterfaceDeclaration_IProvideFluidConfiguration(\n    get_current_RemovedInterfaceDeclaration_IProvideFluidConfiguration());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidHandle\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidHandle():\n    TypeOnly<old.IProvideFluidHandle>;\ndeclare function use_current_InterfaceDeclaration_IProvideFluidHandle(\n    use: TypeOnly<current.IProvideFluidHandle>);\nuse_current_InterfaceDeclaration_IProvideFluidHandle(\n    get_old_InterfaceDeclaration_IProvideFluidHandle());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidHandle\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IProvideFluidHandle():\n    TypeOnly<current.IProvideFluidHandle>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidHandle(\n    use: TypeOnly<old.IProvideFluidHandle>);\nuse_old_InterfaceDeclaration_IProvideFluidHandle(\n    get_current_InterfaceDeclaration_IProvideFluidHandle());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidHandleContext\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidHandleContext():\n    TypeOnly<old.IProvideFluidHandleContext>;\ndeclare function use_current_InterfaceDeclaration_IProvideFluidHandleContext(\n    use: TypeOnly<current.IProvideFluidHandleContext>);\nuse_current_InterfaceDeclaration_IProvideFluidHandleContext(\n    get_old_InterfaceDeclaration_IProvideFluidHandleContext());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidHandleContext\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IProvideFluidHandleContext():\n    TypeOnly<current.IProvideFluidHandleContext>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidHandleContext(\n    use: TypeOnly<old.IProvideFluidHandleContext>);\nuse_old_InterfaceDeclaration_IProvideFluidHandleContext(\n    get_current_InterfaceDeclaration_IProvideFluidHandleContext());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidLoadable\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidLoadable():\n    TypeOnly<old.IProvideFluidLoadable>;\ndeclare function use_current_InterfaceDeclaration_IProvideFluidLoadable(\n    use: TypeOnly<current.IProvideFluidLoadable>);\nuse_current_InterfaceDeclaration_IProvideFluidLoadable(\n    get_old_InterfaceDeclaration_IProvideFluidLoadable());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidLoadable\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IProvideFluidLoadable():\n    TypeOnly<current.IProvideFluidLoadable>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidLoadable(\n    use: TypeOnly<old.IProvideFluidLoadable>);\nuse_old_InterfaceDeclaration_IProvideFluidLoadable(\n    get_current_InterfaceDeclaration_IProvideFluidLoadable());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidRouter\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidRouter():\n    TypeOnly<old.IProvideFluidRouter>;\ndeclare function use_current_InterfaceDeclaration_IProvideFluidRouter(\n    use: TypeOnly<current.IProvideFluidRouter>);\nuse_current_InterfaceDeclaration_IProvideFluidRouter(\n    get_old_InterfaceDeclaration_IProvideFluidRouter());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidRouter\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IProvideFluidRouter():\n    TypeOnly<current.IProvideFluidRouter>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidRouter(\n    use: TypeOnly<old.IProvideFluidRouter>);\nuse_old_InterfaceDeclaration_IProvideFluidRouter(\n    get_current_InterfaceDeclaration_IProvideFluidRouter());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidRunnable\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidRunnable():\n    TypeOnly<old.IProvideFluidRunnable>;\ndeclare function use_current_InterfaceDeclaration_IProvideFluidRunnable(\n    use: TypeOnly<current.IProvideFluidRunnable>);\nuse_current_InterfaceDeclaration_IProvideFluidRunnable(\n    get_old_InterfaceDeclaration_IProvideFluidRunnable());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidRunnable\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IProvideFluidRunnable():\n    TypeOnly<current.IProvideFluidRunnable>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidRunnable(\n    use: TypeOnly<old.IProvideFluidRunnable>);\nuse_old_InterfaceDeclaration_IProvideFluidRunnable(\n    get_current_InterfaceDeclaration_IProvideFluidRunnable());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidSerializer\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IProvideFluidSerializer():\n    TypeOnly<old.IProvideFluidSerializer>;\ndeclare function use_current_InterfaceDeclaration_IProvideFluidSerializer(\n    use: TypeOnly<current.IProvideFluidSerializer>);\nuse_current_InterfaceDeclaration_IProvideFluidSerializer(\n    get_old_InterfaceDeclaration_IProvideFluidSerializer());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IProvideFluidSerializer\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IProvideFluidSerializer():\n    TypeOnly<current.IProvideFluidSerializer>;\ndeclare function use_old_InterfaceDeclaration_IProvideFluidSerializer(\n    use: TypeOnly<old.IProvideFluidSerializer>);\nuse_old_InterfaceDeclaration_IProvideFluidSerializer(\n    get_current_InterfaceDeclaration_IProvideFluidSerializer());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IRequest\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IRequest():\n    TypeOnly<old.IRequest>;\ndeclare function use_current_InterfaceDeclaration_IRequest(\n    use: TypeOnly<current.IRequest>);\nuse_current_InterfaceDeclaration_IRequest(\n    get_old_InterfaceDeclaration_IRequest());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IRequest\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IRequest():\n    TypeOnly<current.IRequest>;\ndeclare function use_old_InterfaceDeclaration_IRequest(\n    use: TypeOnly<old.IRequest>);\nuse_old_InterfaceDeclaration_IRequest(\n    get_current_InterfaceDeclaration_IRequest());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IRequestHeader\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IRequestHeader():\n    TypeOnly<old.IRequestHeader>;\ndeclare function use_current_InterfaceDeclaration_IRequestHeader(\n    use: TypeOnly<current.IRequestHeader>);\nuse_current_InterfaceDeclaration_IRequestHeader(\n    get_old_InterfaceDeclaration_IRequestHeader());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IRequestHeader\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IRequestHeader():\n    TypeOnly<current.IRequestHeader>;\ndeclare function use_old_InterfaceDeclaration_IRequestHeader(\n    use: TypeOnly<old.IRequestHeader>);\nuse_old_InterfaceDeclaration_IRequestHeader(\n    get_current_InterfaceDeclaration_IRequestHeader());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IResponse\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_IResponse():\n    TypeOnly<old.IResponse>;\ndeclare function use_current_InterfaceDeclaration_IResponse(\n    use: TypeOnly<current.IResponse>);\nuse_current_InterfaceDeclaration_IResponse(\n    get_old_InterfaceDeclaration_IResponse());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_IResponse\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_IResponse():\n    TypeOnly<current.IResponse>;\ndeclare function use_old_InterfaceDeclaration_IResponse(\n    use: TypeOnly<old.IResponse>);\nuse_old_InterfaceDeclaration_IResponse(\n    get_current_InterfaceDeclaration_IResponse());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_ISerializedHandle\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_InterfaceDeclaration_ISerializedHandle():\n    TypeOnly<old.ISerializedHandle>;\ndeclare function use_current_InterfaceDeclaration_ISerializedHandle(\n    use: TypeOnly<current.ISerializedHandle>);\nuse_current_InterfaceDeclaration_ISerializedHandle(\n    get_old_InterfaceDeclaration_ISerializedHandle());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"InterfaceDeclaration_ISerializedHandle\": {\"backCompat\": false}\n*/\ndeclare function get_current_InterfaceDeclaration_ISerializedHandle():\n    TypeOnly<current.ISerializedHandle>;\ndeclare function use_old_InterfaceDeclaration_ISerializedHandle(\n    use: TypeOnly<old.ISerializedHandle>);\nuse_old_InterfaceDeclaration_ISerializedHandle(\n    get_current_InterfaceDeclaration_ISerializedHandle());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_isFluidCodeDetails\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_isFluidCodeDetails():\n    TypeOnly<typeof old.isFluidCodeDetails>;\ndeclare function use_current_VariableDeclaration_isFluidCodeDetails(\n    use: TypeOnly<typeof current.isFluidCodeDetails>);\nuse_current_VariableDeclaration_isFluidCodeDetails(\n    get_old_VariableDeclaration_isFluidCodeDetails());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_isFluidCodeDetails\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_isFluidCodeDetails():\n    TypeOnly<typeof current.isFluidCodeDetails>;\ndeclare function use_old_VariableDeclaration_isFluidCodeDetails(\n    use: TypeOnly<typeof old.isFluidCodeDetails>);\nuse_old_VariableDeclaration_isFluidCodeDetails(\n    get_current_VariableDeclaration_isFluidCodeDetails());\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_isFluidPackage\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_VariableDeclaration_isFluidPackage():\n    TypeOnly<typeof old.isFluidPackage>;\ndeclare function use_current_VariableDeclaration_isFluidPackage(\n    use: TypeOnly<typeof current.isFluidPackage>);\nuse_current_VariableDeclaration_isFluidPackage(\n    get_old_VariableDeclaration_isFluidPackage());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken.0.42.0:\n* \"VariableDeclaration_isFluidPackage\": {\"backCompat\": false}\n*/\ndeclare function get_current_VariableDeclaration_isFluidPackage():\n    TypeOnly<typeof current.isFluidPackage>;\ndeclare function use_old_VariableDeclaration_isFluidPackage(\n    use: TypeOnly<typeof old.isFluidPackage>);\nuse_old_VariableDeclaration_isFluidPackage(\n    get_current_VariableDeclaration_isFluidPackage());\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/core-interfaces",
-  "version": "0.43.1000-60265",
+  "version": "0.43.1000",
   "description": "Fluid object interfaces",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -21,8 +21,7 @@
     "build:esnext": "tsc --project ./tsconfig.esnext.json",
     "build:full": "npm run build",
     "build:full:compile": "npm run build:compile",
-    "build:gen": "npm run build:gen:typetests",
-    "build:gen:typetests": "fluid-type-validator -d .",
+    "build:gen": "npm run typetests:gen",
     "ci:build": "npm run build:gen && npm run build:compile",
     "ci:build:docs": "api-extractor run --typescript-compiler-folder ./node_modules/typescript && copyfiles -u 1 ./_api-extractor-temp/doc-models/* ../../../_api-extractor-temp/",
     "ci:test": "echo No test for this package",
@@ -36,16 +35,15 @@
     "tsc": "tsc",
     "tsc:watch": "tsc --watch",
     "tsfmt": "tsfmt --verify",
-    "tsfmt:fix": "tsfmt --replace"
+    "tsfmt:fix": "tsfmt --replace",
+    "typetests:gen": "fluid-type-validator -d .",
+    "typetests:prepare": "fluid-type-validator -d . -p"
   },
   "devDependencies": {
     "@fluidframework/build-common": "^0.23.0",
-    "@fluidframework/build-tools": "^0.2.58041",
-    "@fluidframework/core-interfaces-0.39.8": "npm:@fluidframework/core-interfaces@0.39.8",
-    "@fluidframework/core-interfaces-0.40.0": "npm:@fluidframework/core-interfaces@0.40.0",
-    "@fluidframework/core-interfaces-0.41.0": "npm:@fluidframework/core-interfaces@0.41.0",
-    "@fluidframework/core-interfaces-0.42.0": "npm:@fluidframework/core-interfaces@0.42.0",
-    "@fluidframework/eslint-config-fluid": "^0.27.0",
+    "@fluidframework/build-tools": "^0.2.61288",
+    "@fluidframework/core-interfaces-previous": "npm:@fluidframework/core-interfaces@^0.42.0",
+    "@fluidframework/eslint-config-fluid": "^0.28.1000",
     "@microsoft/api-extractor": "^7.16.1",
     "@rushstack/eslint-config": "^2.5.1",
     "@types/node": "^14.18.0",
@@ -67,48 +65,6 @@
   "typeValidation": {
     "version": "0.43.1000",
     "broken": {
-      "0.39.8": {
-        "RemovedVariableDeclaration_IFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        },
-        "RemovedInterfaceDeclaration_IFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        },
-        "RemovedInterfaceDeclaration_IProvideFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        }
-      },
-      "0.40.0": {
-        "RemovedVariableDeclaration_IFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        },
-        "RemovedInterfaceDeclaration_IFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        },
-        "RemovedInterfaceDeclaration_IProvideFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        }
-      },
-      "0.41.0": {
-        "RemovedVariableDeclaration_IFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        },
-        "RemovedInterfaceDeclaration_IFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        },
-        "RemovedInterfaceDeclaration_IProvideFluidConfiguration": {
-          "backCompat": false,
-          "forwardCompat": false
-        }
-      },
       "0.42.0": {
         "RemovedVariableDeclaration_IFluidConfiguration": {
           "backCompat": false,

package/src/handles.ts

@@ -4,7 +4,6 @@
  */
 
 import { IRequest, IResponse } from "./fluidRouter";
-import { IFluidObject } from "./fluidObject";
 import { IFluidLoadable } from "./fluidLoadable";
 import { FluidObject } from "./provider";
 
@@ -53,7 +52,7 @@ export interface IProvideFluidHandle {
  */
 export interface IFluidHandle<
     // REVIEW: Constrain `T` to something? How do we support dds and datastores safely?
-    T = IFluidObject & FluidObject & IFluidLoadable
+    T = FluidObject & IFluidLoadable
     > extends IProvideFluidHandle {
 
     /**

package/src/provider.ts

@@ -24,9 +24,11 @@
  */
  export type FluidObjectProviderKeys<T, TProp extends keyof T = keyof T> =
     string extends TProp ? never : number extends TProp? never : // exclude indexers [key:string |number]: any
-    TProp extends keyof Exclude<T[TProp], undefined> // TProp is a property of T, and T[TProp]
-        ? TProp
-        :never;
+    TProp extends keyof Required<T>[TProp] // TProp is a property of T, and T[TProp]
+        ? Required<T>[TProp] extends Required<Required<T>[TProp]>[TProp] // T[TProp] is the same type as T[TProp][TProp]
+            ? TProp
+            : never
+        : never;
 
 /**
  * This utility type take interface(s) that follow the FluidObject pattern, and produces
@@ -58,7 +60,9 @@
  * `FluidObject<IFoo & IBar>`
  *
  */
- export type FluidObject<T = unknown> = Partial<Pick<T, FluidObjectProviderKeys<T>>>;
+ export type FluidObject<T = unknown> = {
+    [P in FluidObjectProviderKeys<T>]?: T[P];
+};
 
 /**
  * This utility type creates a type that is the union of all keys on the generic type

package/lib/test/types/validate0.39.8.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=validate0.39.8.d.ts.map

package/lib/test/types/validate0.39.8.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate0.39.8.d.ts","sourceRoot":"","sources":["../../../src/test/types/validate0.39.8.ts"],"names":[],"mappings":""}