@fluidframework/core-interfaces 2.0.0-internal.7.2.2 → 2.0.0-internal.7.4.0

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

@@ -0,0 +1,782 @@
+/**
+ * Types supported by {@link IConfigProviderBase}.
+ * @alpha
+ */
+export declare type ConfigTypes = string | number | boolean | number[] | string[] | boolean[] | undefined;
+
+/**
+ * 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 */
+
+/**
+ * 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];
+};
+
+/**
+ * This utility type creates a type that is the union of all keys on the generic type
+ * which implement the FluidObject pattern.
+ *
+ * See {@link FluidObject}
+ *
+ * For example `FluidObjectKeys<IFoo & IBar>` would result in `"IFoo" | "IBar"`
+ * @alpha
+ */
+export declare type FluidObjectKeys<T> = keyof FluidObject<T>;
+
+/**
+ * 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;
+
+/**
+ * Base interface for providing configurations to enable/disable/control features.
+ * @alpha
+ */
+export declare interface IConfigProviderBase {
+    /**
+     * For the specified config name this function gets the value.
+     *
+     * This type is meant be easy to implement by Fluid Framework consumers
+     * so the returned valued needs minimal type coercion, and allows consumers to
+     * return values in a natural way from whatever source they retrieve them.
+     *
+     * For instance a value of 1 maybe be returned as a string or a number.
+     * For array types a json string or an object are allowable.
+     *
+     * It should return undefined if there is no value available for the config name.
+     *
+     * @param name - The name of the config to get the value for.
+     *
+     * @privateRemarks Generally, this type should only be taken as input, and be wrapped by an
+     * internal monitoring context from the fluidframework/telemetry-utils package. That will provide
+     * a wrapper with provides strongly typed access to values via consistent type coercion.
+     */
+    getRawConfig(name: string): ConfigTypes;
+}
+
+/**
+ * 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 */
+
+/* Excluded from this release type: IFluidCodeDetailsComparer */
+
+/* Excluded from this release type: IFluidCodeDetailsConfig */
+
+/**
+ * @alpha
+ */
+export declare const IFluidHandle: keyof IProvideFluidHandle;
+
+/**
+ * Handle to a shared {@link FluidObject}.
+ * @alpha
+ */
+export declare interface IFluidHandle<T = FluidObject & IFluidLoadable> extends IProvideFluidHandle {
+    /**
+     * @deprecated Do not use handle's path for routing. Use `get` to get the underlying object.
+     *
+     * The absolute path to the handle context from the root.
+     */
+    readonly absolutePath: string;
+    /**
+     * Flag indicating whether or not the entity has services attached.
+     */
+    readonly isAttached: boolean;
+    /**
+     * @deprecated To be removed. This is part of an internal API surface and should not be called.
+     *
+     * Runs through the graph and attach the bounded handles.
+     */
+    attachGraph(): void;
+    /**
+     * Returns a promise to the Fluid Object referenced by the handle.
+     */
+    get(): Promise<T>;
+    /**
+     * @deprecated To be removed. This is part of an internal API surface and should not be called.
+     *
+     * Binds the given handle to this one or attach the given handle if this handle is attached.
+     * A bound handle will also be attached once this handle is attached.
+     */
+    bind(handle: IFluidHandle): void;
+}
+
+/**
+ * @alpha
+ */
+export declare const IFluidHandleContext: keyof IProvideFluidHandleContext;
+
+/**
+ * Describes a routing context from which other `IFluidHandleContext`s are defined.
+ * @alpha
+ */
+export declare interface IFluidHandleContext extends IProvideFluidHandleContext {
+    /**
+     * The absolute path to the handle context from the root.
+     */
+    readonly absolutePath: string;
+    /**
+     * The parent IFluidHandleContext that has provided a route path to this IFluidHandleContext or undefined
+     * at the root.
+     */
+    readonly routeContext?: IFluidHandleContext;
+    /**
+     * Flag indicating whether or not the entity has services attached.
+     */
+    readonly isAttached: boolean;
+    /**
+     * Runs through the graph and attach the bounded handles.
+     */
+    attachGraph(): void;
+    resolveHandle(request: IRequest): Promise<IResponse>;
+}
+
+/**
+ * @alpha
+ */
+export declare const IFluidLoadable: keyof IProvideFluidLoadable;
+
+/**
+ * A shared FluidObject has a URL from which it can be referenced
+ * @alpha
+ */
+export declare interface IFluidLoadable extends IProvideFluidLoadable {
+    handle: IFluidHandle;
+}
+
+/* Excluded from this release type: IFluidPackage */
+
+/* Excluded from this release type: IFluidPackageEnvironment */
+
+/**
+ * @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 */
+
+/* Excluded from this release type: IGenericError */
+
+/* Excluded from this release type: ILoggingError */
+
+/* Excluded from this release type: IProvideFluidCodeDetailsComparer */
+
+/**
+ * @alpha
+ */
+export declare interface IProvideFluidHandle {
+    readonly IFluidHandle: IFluidHandle;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IProvideFluidHandleContext {
+    readonly IFluidHandleContext: IFluidHandleContext;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IProvideFluidLoadable {
+    readonly IFluidLoadable: IFluidLoadable;
+}
+
+/**
+ * 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 */
+
+/**
+ * @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 */
+
+/* Excluded from this release type: isFluidPackage */
+
+/* Excluded from this release type: ITaggedTelemetryPropertyType */
+
+/**
+ * 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;
+
+/**
+ * Error telemetry event.
+ * Maps to category = "error"
+ *
+ * @deprecated For internal use within FluidFramework, use ITelemetryErrorEventExt in \@fluidframework/telemetry-utils.
+ * No replacement intended for FluidFramework consumers.
+ * @alpha
+ */
+export declare interface ITelemetryErrorEvent extends ITelemetryProperties {
+    eventName: string;
+}
+
+/**
+ * Informational (non-error) telemetry event
+ * Maps to category = "generic"
+ *
+ * @deprecated For internal use within FluidFramework, use ITelemetryGenericEventExt in \@fluidframework/telemetry-utils.
+ * No replacement intended for FluidFramework consumers.
+ * @alpha
+ */
+export declare interface ITelemetryGenericEvent extends ITelemetryProperties {
+    eventName: string;
+    category?: TelemetryEventCategory;
+}
+
+/**
+ * ITelemetryLogger interface contains various helper telemetry methods,
+ * encoding in one place schemas for various types of Fluid telemetry events.
+ * Creates sub-logger that appends properties to all events
+ *
+ * @deprecated For internal use within FluidFramework, use ITelemetryLoggerExt in \@fluidframework/telemetry-utils.
+ * No replacement intended for FluidFramework consumers.
+ * @alpha
+ */
+export declare interface ITelemetryLogger extends ITelemetryBaseLogger {
+    /**
+     * Actual implementation that sends telemetry event
+     * Implemented by derived classes
+     * @param event - Telemetry event to send over
+     * @param logLevel - optional level of the log.
+     */
+    send(event: ITelemetryBaseEvent, logLevel?: LogLevel): void;
+    /**
+     * Send information telemetry event
+     * @param event - Event to send
+     * @param error - optional error object to log
+     * @param logLevel - optional level of the log.
+     */
+    sendTelemetryEvent(event: ITelemetryGenericEvent, error?: any, logLevel?: typeof LogLevel.verbose | typeof LogLevel.default): void;
+    /**
+     * Send error telemetry event
+     * @param event - Event to send
+     * @param error - optional error object to log
+     */
+    sendErrorEvent(event: ITelemetryErrorEvent, error?: any): void;
+    /**
+     * Send performance telemetry event
+     * @param event - Event to send
+     * @param error - optional error object to log
+     * @param logLevel - optional level of the log.
+     */
+    sendPerformanceEvent(event: ITelemetryPerformanceEvent, error?: any, logLevel?: typeof LogLevel.verbose | typeof LogLevel.default): void;
+}
+
+/**
+ * Performance telemetry event.
+ * Maps to category = "performance"
+ *
+ * @deprecated For internal use within FluidFramework, use ITelemetryPerformanceEventExt in \@fluidframework/telemetry-utils.
+ * No replacement intended for FluidFramework consumers.
+ * @alpha
+ */
+export declare interface ITelemetryPerformanceEvent extends ITelemetryGenericEvent {
+    duration?: number;
+}
+
+/**
+ * {@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 */
+
+/**
+ * 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 */
+
+/**
+ * Examples of known categories, however category can be any string for extensibility.
+ *
+ * @deprecated Moved to \@fluidframework/telemetry-utils package
+ * @alpha
+ */
+export declare type TelemetryEventCategory = "generic" | "error" | "performance";
+
+/**
+ * {@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 { }