@fluidframework/core-interfaces 2.0.0-dev.7.4.0.216897 → 2.0.0-dev.7.4.0.217212

package/dist/core-interfaces-alpha.d.ts

@@ -1,26 +1,386 @@
-/* Excluded from this release type: ExtendEventProvider */
+/* Excluded from this release type: ConfigTypes */
+
+/**
+ * Allows an interface to extend interfaces that already extend an {@link IEventProvider}.
+ *
+ * @example
+ *
+ * ``` typescript
+ * interface AEvents extends IEvent{
+ *  (event: "a-event",listener: (a: number)=>void);
+ * }
+ * interface A extends IEventProvider<AEvents>{
+ *  a: object;
+ * }
+ *
+ * interface BEvents extends IEvent{
+ *  (event: "b-event",listener: (b: string)=>void);
+ * }
+ * interface B extends ExtendEventProvider<AEvents, A, BEvents>{
+ *  b: boolean;
+ * };
+ * ```
+ *
+ * interface B will now extend interface A and its events
+ * @alpha
+ */
+export declare type ExtendEventProvider<TBaseEvent extends IEvent, TBase extends IEventProvider<TBaseEvent>, TEvent extends TBaseEvent> = Omit<Omit<Omit<TBase, "on">, "once">, "off"> & IEventProvider<TBaseEvent> & IEventProvider<TEvent>;
 
 /* Excluded from this release type: FluidErrorTypes */
 
-/* Excluded from this release type: FluidObject */
+/**
+ * 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.
+ *
+ * It is meant to be used with types that are known to implement the FluidObject pattern.
+ * A common way to specify a type implements the FluidObject pattern is to expose it as a
+ * FluidObject without a generic argument.
+ *
+ * @example
+ *
+ * For example, if we have an interface like the following:
+ *
+ * ```typescript
+ * interface IProvideFoo{
+ *  IFoo: IFoo
+ * }
+ * interface IFoo extends IProvideFoo{
+ *  foobar();
+ * }
+ * ```
+ *
+ * and a function that returns a FluidObject. You would do the following
+ *
+ * `const maybeFoo: FluidObject<IFoo> = getFluidObject()`;
+ *
+ * Either IFoo or IProvideFoo are valid generic arguments. In both case
+ * maybeFoo will be of type `{IFoo?: IFoo}`. If IFoo is not undefined,
+ * then the FluidObject provides IFoo, and it can be used.
+ *
+ * You can inspect multiple types via a intersection. For example:
+ * `FluidObject<IFoo & IBar>`
+ * @alpha
+ */
+export declare type FluidObject<T = unknown> = {
+    [P in FluidObjectProviderKeys<T>]?: T[P];
+};
 
 /* Excluded from this release type: FluidObjectKeys */
 
-/* Excluded from this release type: FluidObjectProviderKeys */
-
-/* Excluded from this release type: IDisposable */
-
-/* Excluded from this release type: IErrorBase */
-
-/* Excluded from this release type: IErrorEvent */
-
-/* Excluded from this release type: IEvent */
-
-/* Excluded from this release type: IEventProvider */
-
-/* Excluded from this release type: IEventThisPlaceHolder */
-
-/* Excluded from this release type: IEventTransformer */
+/**
+ * Produces a valid FluidObject key given a type and a property.
+ *
+ * @remarks
+ *
+ * A valid FluidObject key is a property that exists on the incoming type
+ * as well as on the type of the property itself. For example: `IProvideFoo.IFoo.IFoo`
+ * This aligns with the FluidObject pattern expected to be used with all FluidObjects.
+ *
+ * This utility type is meant for internal use by {@link FluidObject}
+ *
+ * @example
+ *
+ * ```typescript
+ * interface IProvideFoo{
+ *  IFoo: IFoo
+ * }
+ * interface IFoo extends IProvideFoo{
+ *  foobar();
+ * }
+ * ```
+ *
+ * This pattern enables discovery, and delegation in a standard way which is central
+ * to FluidObject pattern.
+ * @alpha
+ */
+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;
+
+/* Excluded from this release type: IConfigProviderBase */
+
+/**
+ * Base interface for objects that require lifetime management via explicit disposal.
+ * @alpha
+ */
+export declare interface IDisposable {
+    /**
+     * Whether or not the object has been disposed.
+     * If true, the object should be considered invalid, and its other state should be disregarded.
+     */
+    readonly disposed: boolean;
+    /**
+     * Dispose of the object and its resources.
+     * @param error - Optional error indicating the reason for the disposal, if the object was
+     * disposed as the result of an error.
+     */
+    dispose(error?: Error): void;
+}
+
+/**
+ * Base interface for all errors and warnings emitted the container.
+ *
+ * @remarks
+ *
+ * We are in the process of unifying error types across layers of the Framework. For now we have only migrated
+ * those from container-definitions. Once fully migrated, this will be a base interface for all errors and
+ * warnings emitted by the Fluid Framework. Currently only the container layer is using IErrorBase.
+ * Runtime and others will follow soon.
+ *
+ * @alpha
+ */
+export declare interface IErrorBase extends Partial<Error> {
+    /**
+     * A type tag differentiating kinds of errors emitted by the container.
+     *
+     * @see See {@link FluidErrorTypes#genericError} for some common examples.
+     * - container
+     * - runtime
+     * - drivers
+     */
+    readonly errorType: string;
+    /**
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error | Error.message}
+     *
+     * @remarks
+     *
+     * Privacy Note - This is a freeform string that we may not control in all cases (e.g. a dependency throws an error)
+     * If there are known cases where this contains privacy-sensitive data it will be tagged and included in the result
+     * of getTelemetryProperties. When logging, consider fetching it that way rather than straight from this field.
+     */
+    readonly message: string;
+    /**
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name | Error.name}
+     */
+    readonly name?: string;
+    /**
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/stack | Error.stack}
+     */
+    readonly stack?: string;
+    /**
+     * Returns all properties of this error object that are fit for logging.
+     * Some may be tagged to indicate they contain some kind of sensitive data.
+     */
+    getTelemetryProperties?(): ITelemetryBaseProperties;
+}
+
+/**
+ * Base interface for error event emitters.
+ * @alpha
+ */
+export declare interface IErrorEvent extends IEvent {
+    /**
+     * Base error event emitter signature.
+     *
+     * @eventProperty
+     */
+    (event: "error", listener: (message: any) => void): any;
+}
+
+/**
+ * Base interface for event emitters.
+ * @alpha
+ */
+export declare interface IEvent {
+    /**
+     * Base event emitter signature.
+     *
+     * @remarks The event emitter polyfill and the node event emitter have different event types:
+     * `string | symbol` vs. `string | number`.
+     *
+     * So for our typing we'll contrain to string, that way we work with both.
+     *
+     * @eventProperty
+     */
+    (event: string, listener: (...args: any[]) => void): any;
+}
+
+/**
+ * Base interface for event providers.
+ * @alpha
+ */
+export declare interface IEventProvider<TEvent extends IEvent> {
+    /**
+     * Registers a callback to be invoked when the corresponding event is triggered.
+     */
+    readonly on: IEventTransformer<this, TEvent>;
+    /**
+     * Registers a callback to be invoked the first time (after registration) the corresponding event is triggered.
+     */
+    readonly once: IEventTransformer<this, TEvent>;
+    /**
+     * Removes the corresponding event if it has been registered.
+     */
+    readonly off: IEventTransformer<this, TEvent>;
+}
+
+/**
+ * The placeholder type that should be used instead of `this` in events.
+ * @alpha
+ */
+export declare type IEventThisPlaceHolder = {
+    thisPlaceHolder: "thisPlaceHolder";
+};
+
+/**
+ * This type is a conditional type for transforming all the overloads provided in `TEvent`.
+ *
+ * @remarks
+ * Due to limitations of the TypeScript typing system, we need to handle each number of overload individually.
+ * It currently supports the max of 15 event overloads which is more than we use anywhere.
+ * At more than 15 overloads we start to hit {@link https://github.com/microsoft/TypeScript/issues/37209 | TS2589}.
+ * If we need to move beyond 15 we should evaluate using a mapped type pattern like `{"event":(listenerArgs)=>void}`
+ * @alpha
+ */
+export declare type IEventTransformer<TThis, TEvent extends IEvent> = TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: infer E8, listener: (...args: infer A8) => void): any;
+    (event: infer E9, listener: (...args: infer A9) => void): any;
+    (event: infer E10, listener: (...args: infer A10) => void): any;
+    (event: infer E11, listener: (...args: infer A11) => void): any;
+    (event: infer E12, listener: (...args: infer A12) => void): any;
+    (event: infer E13, listener: (...args: infer A13) => void): any;
+    (event: infer E14, listener: (...args: infer A14) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> & TransformedEvent<TThis, E8, A8> & TransformedEvent<TThis, E9, A9> & TransformedEvent<TThis, E10, A10> & TransformedEvent<TThis, E11, A11> & TransformedEvent<TThis, E12, A12> & TransformedEvent<TThis, E13, A13> & TransformedEvent<TThis, E14, A14> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: infer E8, listener: (...args: infer A8) => void): any;
+    (event: infer E9, listener: (...args: infer A9) => void): any;
+    (event: infer E10, listener: (...args: infer A10) => void): any;
+    (event: infer E11, listener: (...args: infer A11) => void): any;
+    (event: infer E12, listener: (...args: infer A12) => void): any;
+    (event: infer E13, listener: (...args: infer A13) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> & TransformedEvent<TThis, E8, A8> & TransformedEvent<TThis, E9, A9> & TransformedEvent<TThis, E10, A10> & TransformedEvent<TThis, E11, A11> & TransformedEvent<TThis, E12, A12> & TransformedEvent<TThis, E13, A13> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: infer E8, listener: (...args: infer A8) => void): any;
+    (event: infer E9, listener: (...args: infer A9) => void): any;
+    (event: infer E10, listener: (...args: infer A10) => void): any;
+    (event: infer E11, listener: (...args: infer A11) => void): any;
+    (event: infer E12, listener: (...args: infer A12) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> & TransformedEvent<TThis, E8, A8> & TransformedEvent<TThis, E9, A9> & TransformedEvent<TThis, E10, A10> & TransformedEvent<TThis, E11, A11> & TransformedEvent<TThis, E12, A12> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: infer E8, listener: (...args: infer A8) => void): any;
+    (event: infer E9, listener: (...args: infer A9) => void): any;
+    (event: infer E10, listener: (...args: infer A10) => void): any;
+    (event: infer E11, listener: (...args: infer A11) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> & TransformedEvent<TThis, E8, A8> & TransformedEvent<TThis, E9, A9> & TransformedEvent<TThis, E10, A10> & TransformedEvent<TThis, E11, A11> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: infer E8, listener: (...args: infer A8) => void): any;
+    (event: infer E9, listener: (...args: infer A9) => void): any;
+    (event: infer E10, listener: (...args: infer A10) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> & TransformedEvent<TThis, E8, A8> & TransformedEvent<TThis, E9, A9> & TransformedEvent<TThis, E10, A10> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: infer E8, listener: (...args: infer A8) => void): any;
+    (event: infer E9, listener: (...args: infer A9) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> & TransformedEvent<TThis, E8, A8> & TransformedEvent<TThis, E9, A9> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: infer E8, listener: (...args: infer A8) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> & TransformedEvent<TThis, E8, A8> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: infer E7, listener: (...args: infer A7) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> & TransformedEvent<TThis, E7, A7> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: infer E6, listener: (...args: infer A6) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> & TransformedEvent<TThis, E6, A6> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: infer E5, listener: (...args: infer A5) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> & TransformedEvent<TThis, E5, A5> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: infer E4, listener: (...args: infer A4) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> & TransformedEvent<TThis, E4, A4> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: infer E3, listener: (...args: infer A3) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> & TransformedEvent<TThis, E3, A3> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: infer E2, listener: (...args: infer A2) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> & TransformedEvent<TThis, E2, A2> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: infer E1, listener: (...args: infer A1) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> & TransformedEvent<TThis, E1, A1> : TEvent extends {
+    (event: infer E0, listener: (...args: infer A0) => void): any;
+    (event: string, listener: (...args: any[]) => void): any;
+} ? TransformedEvent<TThis, E0, A0> : TransformedEvent<TThis, string, any[]>;
 
 /* Excluded from this release type: IFluidCodeDetails */
 
@@ -38,7 +398,19 @@
 
 /* Excluded from this release type: IFluidPackageEnvironment */
 
-/* Excluded from this release type: IFluidRouter */
+/**
+ * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+ * @alpha
+ */
+export declare const IFluidRouter: keyof IProvideFluidRouter;
+
+/**
+ * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+ * @alpha
+ */
+export declare interface IFluidRouter extends IProvideFluidRouter {
+    request(request: IRequest): Promise<IResponse>;
+}
 
 /* Excluded from this release type: IFluidRunnable */
 
@@ -54,15 +426,44 @@
 
 /* Excluded from this release type: IProvideFluidLoadable */
 
-/* Excluded from this release type: IProvideFluidRouter */
+/**
+ * Request routing
+ * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+ * @alpha
+ */
+export declare interface IProvideFluidRouter {
+    readonly IFluidRouter: IFluidRouter;
+}
 
 /* Excluded from this release type: IProvideFluidRunnable */
 
-/* Excluded from this release type: IRequest */
-
-/* Excluded from this release type: IRequestHeader */
-
-/* Excluded from this release type: IResponse */
+/**
+ * @alpha
+ */
+export declare interface IRequest {
+    url: string;
+    headers?: IRequestHeader;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IRequestHeader {
+    [index: string]: any;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IResponse {
+    mimeType: string;
+    status: number;
+    value: any;
+    headers?: {
+        [key: string]: any;
+    };
+    stack?: string;
+}
 
 /* Excluded from this release type: isFluidCodeDetails */
 
@@ -70,11 +471,33 @@
 
 /* Excluded from this release type: ITaggedTelemetryPropertyType */
 
-/* Excluded from this release type: ITelemetryBaseEvent */
-
-/* Excluded from this release type: ITelemetryBaseLogger */
-
-/* Excluded from this release type: ITelemetryBaseProperties */
+/**
+ * Base interface for logging telemetry statements.
+ * Can contain any number of properties that get serialized as json payload.
+ * @param category - category of the event, like "error", "performance", "generic", etc.
+ * @param eventName - name of the event.
+ * @alpha
+ */
+export declare interface ITelemetryBaseEvent extends ITelemetryBaseProperties {
+    category: string;
+    eventName: string;
+}
+
+/**
+ * Interface to output telemetry events.
+ * Implemented by hosting app / loader
+ * @alpha
+ */
+export declare interface ITelemetryBaseLogger {
+    send(event: ITelemetryBaseEvent, logLevel?: LogLevel): void;
+    minLogLevel?: LogLevel;
+}
+
+/**
+ * JSON-serializable properties, which will be logged with telemetry.
+ * @alpha
+ */
+export declare type ITelemetryBaseProperties = ITelemetryProperties;
 
 /* Excluded from this release type: ITelemetryErrorEvent */
 
@@ -84,24 +507,74 @@
 
 /* Excluded from this release type: ITelemetryPerformanceEvent */
 
-/* Excluded from this release type: ITelemetryProperties */
+/**
+ * {@inheritDoc ITelemetryBaseProperties}
+ *
+ * @deprecated Renamed to {@link ITelemetryBaseProperties}
+ * @alpha
+ */
+export declare interface ITelemetryProperties {
+    [index: string]: TelemetryEventPropertyType | Tagged<TelemetryEventPropertyType>;
+}
 
 /* Excluded from this release type: IThrottlingWarning */
 
 /* Excluded from this release type: IUsageError */
 
-/* Excluded from this release type: LogLevel */
-
-/* Excluded from this release type: ReplaceIEventThisPlaceHolder */
-
-/* Excluded from this release type: Tagged */
+/**
+ * Specify levels of the logs.
+ * @alpha
+ */
+export declare const LogLevel: {
+    readonly verbose: 10;
+    readonly default: 20;
+    readonly error: 30;
+};
+
+/**
+ * Specify a level to the log to filter out logs based on the level.
+ * @alpha
+ */
+export declare type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+
+/**
+ * Does the type replacement by changing types of {@link IEventThisPlaceHolder} to `TThis`
+ * @alpha
+ */
+export declare type ReplaceIEventThisPlaceHolder<L extends any[], TThis> = L extends any[] ? {
+    [K in keyof L]: L[K] extends IEventThisPlaceHolder ? TThis : L[K];
+} : L;
+
+/**
+ * A property to be logged to telemetry may require a tag indicating the value may contain sensitive data.
+ * This type wraps a value of the given type V in an object along with a string tag (type can be further specified as T).
+ *
+ * This indicates that the value should be organized or handled differently by loggers in various first or third
+ * party scenarios. For example, tags are used to mark data that should not be stored in logs for privacy reasons.
+ * @alpha
+ */
+export declare interface Tagged<V, T extends string = string> {
+    value: V;
+    tag: T;
+}
 
 /* Excluded from this release type: TelemetryBaseEventPropertyType */
 
 /* Excluded from this release type: TelemetryEventCategory */
 
-/* Excluded from this release type: TelemetryEventPropertyType */
-
-/* Excluded from this release type: TransformedEvent */
+/**
+ * {@inheritDoc TelemetryBaseEventPropertyType}
+ *
+ * @deprecated Renamed to {@link TelemetryBaseEventPropertyType}
+ * @alpha
+ */
+export declare type TelemetryEventPropertyType = string | number | boolean | undefined;
+
+/**
+ * Transforms the event overload by replacing {@link IEventThisPlaceHolder} with `TThis` in the event listener
+ * arguments and having the overload return `TTHis` as well
+ * @alpha
+ */
+export declare type TransformedEvent<TThis, E, A extends any[]> = (event: E, listener: (...args: ReplaceIEventThisPlaceHolder<A, TThis>) => void) => TThis;
 
 export { }

package/dist/core-interfaces-beta.d.ts

@@ -1,3 +1,5 @@
+/* Excluded from this release type: ConfigTypes */
+
 /* Excluded from this release type: ExtendEventProvider */
 
 /* Excluded from this release type: FluidErrorTypes */
@@ -8,6 +10,8 @@
 
 /* Excluded from this release type: FluidObjectProviderKeys */
 
+/* Excluded from this release type: IConfigProviderBase */
+
 /* Excluded from this release type: IDisposable */
 
 /* Excluded from this release type: IErrorBase */

package/dist/core-interfaces-public.d.ts

@@ -1,3 +1,5 @@
+/* Excluded from this release type: ConfigTypes */
+
 /* Excluded from this release type: ExtendEventProvider */
 
 /* Excluded from this release type: FluidErrorTypes */
@@ -8,6 +10,8 @@
 
 /* Excluded from this release type: FluidObjectProviderKeys */
 
+/* Excluded from this release type: IConfigProviderBase */
+
 /* Excluded from this release type: IDisposable */
 
 /* Excluded from this release type: IErrorBase */