@fluidframework/test-utils 2.0.0-dev.7.4.0.215930 → 2.0.0-dev.7.4.0.216897

package/dist/test-utils-public.d.ts

@@ -1,682 +1,180 @@
-import { ConfigTypes } from '@fluidframework/telemetry-utils';
-import { ContainerRuntime } from '@fluidframework/container-runtime';
-import { ContainerRuntimeFactoryWithDefaultDataStore } from '@fluidframework/aqueduct';
-import { FluidDataStoreRuntime } from '@fluidframework/datastore';
-import { FluidObject } from '@fluidframework/core-interfaces';
-import { IChannelFactory } from '@fluidframework/datastore-definitions';
-import { ICodeDetailsLoader } from '@fluidframework/container-definitions';
-import { IConfigProviderBase } from '@fluidframework/telemetry-utils';
-import { IContainer } from '@fluidframework/container-definitions';
-import { IContainerContext } from '@fluidframework/container-definitions';
-import { IContainerRuntime } from '@fluidframework/container-runtime-definitions';
-import { IContainerRuntimeOptions } from '@fluidframework/container-runtime';
-import { IDocumentService } from '@fluidframework/driver-definitions';
-import { IDocumentServiceFactory } from '@fluidframework/driver-definitions';
-import { IDocumentStorageService } from '@fluidframework/driver-definitions';
-import { IFluidCodeDetails } from '@fluidframework/container-definitions';
-import { IFluidDataStoreChannel } from '@fluidframework/runtime-definitions';
-import { IFluidDataStoreContext } from '@fluidframework/runtime-definitions';
-import { IFluidDataStoreFactory } from '@fluidframework/runtime-definitions';
-import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
-import { IFluidHandle } from '@fluidframework/core-interfaces';
-import { IFluidLoadable } from '@fluidframework/core-interfaces';
-import { IFluidModule } from '@fluidframework/container-definitions';
-import { IFluidModuleWithDetails } from '@fluidframework/container-definitions';
-import { IHostLoader } from '@fluidframework/container-definitions';
-import { ILoaderOptions } from '@fluidframework/container-definitions';
-import { ILoaderProps } from '@fluidframework/container-loader';
-import { IOnDemandSummarizeOptions } from '@fluidframework/container-runtime';
-import { IProvideFluidCodeDetailsComparer } from '@fluidframework/container-definitions';
-import { IProvideFluidDataStoreFactory } from '@fluidframework/runtime-definitions';
-import { IProvideFluidDataStoreRegistry } from '@fluidframework/runtime-definitions';
-import { IProvideRuntimeFactory } from '@fluidframework/container-definitions';
-import { IRequest } from '@fluidframework/core-interfaces';
 import { IRequestHeader } from '@fluidframework/core-interfaces';
-import { IResolvedUrl } from '@fluidframework/driver-definitions';
-import { IResponse } from '@fluidframework/core-interfaces';
-import { IRuntime } from '@fluidframework/container-definitions';
-import { ISharedMap } from '@fluidframework/map';
-import { ISummarizer } from '@fluidframework/container-runtime';
-import { ISummaryContext } from '@fluidframework/driver-definitions';
 import { ISummaryTree } from '@fluidframework/protocol-definitions';
-import { ITelemetryBaseEvent } from '@fluidframework/core-interfaces';
-import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
-import { ITelemetryGenericEvent } from '@fluidframework/core-interfaces';
-import { ITestDriver } from '@fluidframework/test-driver-definitions';
-import { IUrlResolver } from '@fluidframework/driver-definitions';
-import { Loader } from '@fluidframework/container-loader';
-import { NamedFluidDataStoreRegistryEntries } from '@fluidframework/runtime-definitions';
-import { RuntimeRequestHandler } from '@fluidframework/request-handler';
-
-export declare type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFactory]>;
-
-/**
- * Creates a detached Container and attaches it.
- * @param source - The code details used to create the Container.
- * @param loader - The loader to use to initialize the container.
- * @param attachRequest - The request to create new from.
- */
-export declare function createAndAttachContainer(source: IFluidCodeDetails, loader: IHostLoader, attachRequest: IRequest): Promise<IContainer>;
-
-/**
- * ! Note: This function is purely needed for back-compat as the constructor argument structure was changed
- */
-export declare const createContainerRuntimeFactoryWithDefaultDataStore: (Base: typeof ContainerRuntimeFactoryWithDefaultDataStore | undefined, ctorArgs: {
-    defaultFactory: IFluidDataStoreFactory;
-    registryEntries: NamedFluidDataStoreRegistryEntries;
-    dependencyContainer?: any;
-    requestHandlers?: RuntimeRequestHandler[] | undefined;
-    runtimeOptions?: IContainerRuntimeOptions | undefined;
-    provideEntryPoint?: ((runtime: IContainerRuntime) => Promise<FluidObject>) | undefined;
-}) => ContainerRuntimeFactoryWithDefaultDataStore;
-
-export declare const createDocumentId: () => string;
-
-/**
- * Creates a loader with the given package entries and driver.
- * @param packageEntries - A list of code details to Fluid entry points.
- * @param documentServiceFactory - the driver factory to use
- * @param urlResolver - the url resolver to use
- * @param options - loader options
- */
-export declare function createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, documentServiceFactory: IDocumentServiceFactory, urlResolver: IUrlResolver, logger?: ITelemetryBaseLogger, options?: ILoaderOptions): IHostLoader;
-
-/**
- * Creates a summarizer client from the given container and returns the summarizer client's IContainer and ISummarizer.
- * The ISummarizer can be used to generate on-demand summaries. The IContainer can be used to fetch data stores, etc.
- *
- * Can pass in a test config provider to enable/disable features.
- */
-export declare function createSummarizer(provider: ITestObjectProvider, container: IContainer, config?: ITestContainerConfig, summaryVersion?: string, logger?: ITelemetryBaseLogger): Promise<{
-    container: IContainer;
-    summarizer: ISummarizer;
-}>;
-
-/**
- * Creates a summarizer client from the given container and data store factory, and returns the summarizer client's
- * IContainer and ISummarizer.
- * The ISummarizer can be used to generate on-demand summaries. The IContainer can be used to fetch data stores, etc.
- */
-export declare function createSummarizerFromFactory(provider: ITestObjectProvider, container: IContainer, dataStoreFactory: IFluidDataStoreFactory, summaryVersion?: string, containerRuntimeFactoryType?: typeof ContainerRuntimeFactoryWithDefaultDataStore, registryEntries?: NamedFluidDataStoreRegistryEntries, logger?: ITelemetryBaseLogger, configProvider?: IConfigProviderBase): Promise<{
-    container: IContainer;
-    summarizer: ISummarizer;
-}>;
-
-/**
- * Create a container runtime factory class that allows you to set runtime options
- */
-export declare const createTestContainerRuntimeFactory: (containerRuntimeCtor: typeof ContainerRuntime) => {
-    new (type: string, dataStoreFactory: IFluidDataStoreFactory, runtimeOptions?: IContainerRuntimeOptions, requestHandlers?: RuntimeRequestHandler[]): {
-        type: string;
-        dataStoreFactory: IFluidDataStoreFactory;
-        runtimeOptions: IContainerRuntimeOptions;
-        requestHandlers: RuntimeRequestHandler[];
-        instantiateFirstTime(runtime: ContainerRuntime): Promise<void>;
-        instantiateFromExisting(runtime: ContainerRuntime): Promise<void>;
-        preInitialize(context: IContainerContext, existing: boolean): Promise<IRuntime & IContainerRuntime>;
-        readonly IRuntimeFactory: any;
-        instantiateRuntime(context: IContainerContext, existing: boolean): Promise<IRuntime>;
-        hasInitialized(_runtime: IContainerRuntime): Promise<void>;
-    };
-};
-
-export declare enum DataObjectFactoryType {
-    Primed = 0,
-    Test = 1
-}
-
-export declare const defaultTimeoutDurationMs = 250;
-
-/**
- * This class tracks events. It allows specifying expected events, which will be looked for in order.
- * It also tracks all unexpected errors.
- * At any point you call reportAndClearTrackedEvents which will provide all unexpected errors, and
- * any expected events that have not occurred.
- */
-export declare class EventAndErrorTrackingLogger implements ITelemetryBaseLogger {
-    private readonly baseLogger;
-    /**
-     * Even if these error events are logged, tests should still be allowed to pass
-     * Additionally, if downgrade is true, then log as generic (e.g. to avoid polluting the e2e test logs)
-     */
-    private readonly allowedErrors;
-    constructor(baseLogger: ITelemetryBaseLogger);
-    private readonly expectedEvents;
-    private readonly unexpectedErrors;
-    registerExpectedEvent(...orderedExpectedEvents: ITelemetryGenericEvent[]): void;
-    send(event: ITelemetryBaseEvent): void;
-    reportAndClearTrackedEvents(): {
-        expectedNotFound: ({
-            index: number;
-            event: ITelemetryGenericEvent | undefined;
-        } | undefined)[];
-        unexpectedErrors: ITelemetryBaseEvent[];
-    };
-}
-
-export declare type fluidEntryPoint = SupportedExportInterfaces | IFluidModule;
-
-/**
- * This function should ONLY be used for back compat purposes
- * LTS versions of the Loader/Container will not have the "getEntryPoint" method, so we need to fallback to "request"
- * This function can be removed once LTS version of Loader moves to 2.0.0-internal.7.0.0
- */
-export declare function getContainerEntryPointBackCompat<T>(container: IContainer): Promise<T>;
-
-export declare function getUnexpectedLogErrorException(logger: EventAndErrorTrackingLogger | undefined, prefix?: string): Error | undefined;
-
-export declare interface IOpProcessingController {
-    processIncoming(...containers: IContainer[]): Promise<void>;
-    processOutgoing(...containers: IContainer[]): Promise<void>;
-    pauseProcessing(...containers: IContainer[]): Promise<void>;
-    resumeProcessing(...containers: IContainer[]): void;
-}
-
-export declare interface IProvideTestFluidObject {
-    readonly ITestFluidObject: ITestFluidObject;
-}
-
-export declare interface ITestContainerConfig {
-    /** TestFluidDataObject instead of PrimedDataStore */
-    fluidDataObjectType?: DataObjectFactoryType;
-    /** An array of channel name and DDS factory pair to create on container creation time */
-    registry?: ChannelFactoryRegistry;
-    /** Container runtime options for the container instance */
-    runtimeOptions?: IContainerRuntimeOptions;
-    /** Whether this runtime should be instantiated using a mixed-in attributor class */
-    enableAttribution?: boolean;
-    /** Loader options for the loader used to create containers */
-    loaderProps?: Partial<ILoaderProps>;
-}
-
-export declare interface ITestFluidObject extends IProvideTestFluidObject, IFluidLoadable {
-    root: ISharedMap;
-    readonly runtime: IFluidDataStoreRuntime;
-    readonly channel: IFluidDataStoreChannel;
-    readonly context: IFluidDataStoreContext;
-    getSharedObject<T = any>(id: string): Promise<T>;
-}
-
-export declare interface ITestObjectProvider {
-    createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint;
-    createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, loaderProps?: Partial<ILoaderProps>): IHostLoader;
-    createContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>): Promise<IContainer>;
-    loadContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>, requestHeader?: IRequestHeader): Promise<IContainer>;
-    /**
-     * Used to create a test Container. The Loader/ContainerRuntime/DataRuntime might be different versioned.
-     * In generateLocalCompatTest(), this Container and its runtime will be arbitrarily-versioned.
-     */
-    makeTestLoader(testContainerConfig?: ITestContainerConfig): IHostLoader;
-    makeTestContainer(testContainerConfig?: ITestContainerConfig): Promise<IContainer>;
-    loadTestContainer(testContainerConfig?: ITestContainerConfig, requestHeader?: IRequestHeader): Promise<IContainer>;
-    /**
-     *
-     * @param url - Resolved container URL
-     */
-    updateDocumentId(url: IResolvedUrl | undefined): void;
-    logger: ITelemetryBaseLogger;
-    documentServiceFactory: IDocumentServiceFactory;
-    urlResolver: IUrlResolver;
-    defaultCodeDetails: IFluidCodeDetails;
-    opProcessingController: IOpProcessingController;
-    ensureSynchronized(timeoutDuration?: number): Promise<void>;
-    reset(): void;
-    documentId: string;
-    driver: ITestDriver;
-}
-
-export declare class LoaderContainerTracker implements IOpProcessingController {
-    private readonly syncSummarizerClients;
-    private readonly containers;
-    private lastProposalSeqNum;
-    constructor(syncSummarizerClients?: boolean);
-    /**
-     * Add a loader to start to track any container created from them
-     * @param loader - loader to start tracking any container created.
-     */
-    add<LoaderType extends IHostLoader>(loader: LoaderType): void;
-    /**
-     * Utility function to add container to be tracked.
-     *
-     * @param container - container to add
-     */
-    private addContainer;
-    /**
-     * Keep track of the trailing NoOp that was sent so we can discount them in the clientSequenceNumber tracking.
-     * The server might coalesce them with other ops, or a single NoOp, or delay it if it don't think it is necessary.
-     *
-     * @param container - the container to track
-     * @param record - the record to update the trailing op information
-     */
-    private trackTrailingNoOps;
-    private trackLastProposal;
-    /**
-     * Reset the tracker, closing all containers and stop tracking them.
-     */
-    reset(): void;
-    /**
-     * Make sure all the tracked containers are synchronized.
-     *
-     * No isDirty (non-readonly) containers
-     * No extra clientId in quorum of any container that is not tracked and still opened.
-     * - i.e. no pending Join/Leave message.
-     * No unresolved proposal (minSeqNum \>= lastProposalSeqNum)
-     * lastSequenceNumber of all container is the same
-     * clientSequenceNumberObserved is the same as clientSequenceNumber sent
-     * - this overlaps with !isDirty, but include task scheduler ops.
-     * - Trailing NoOp is tracked and don't count as pending ops.
-     *
-     * Containers that are already pause will resume process and paused again once
-     * everything is synchronized.  Containers that aren't paused will remain unpaused when this
-     * function returns.
-     */
-    ensureSynchronized(...containers: IContainer[]): Promise<void>;
-    /**
-     * Utility to calculate the set of clientId per container in quorum that is NOT associated with
-     * any container we tracked, indicating there is a pending join or leave op that we need to wait.
-     *
-     * @param containersToApply - the set of containers to check
-     */
-    private getPendingClients;
-    /**
-     * Utility to check synchronization based on sequence number
-     * See ensureSynchronized for more detail
-     *
-     * @param containersToApply - the set of containers to check
-     */
-    private needSequenceNumberSynchronize;
-    private containerIndexStrings;
-    /**
-     * Utility to wait for any clientId in quorum that is NOT associated with any container we
-     * tracked, indicating there is a pending join or leave op that we need to wait.
-     *
-     * Note that this function doesn't account for container that got added after we started waiting
-     *
-     * @param containersToApply - the set of containers to wait for any inbound ops for
-     */
-    private waitForPendingClients;
-    /**
-     * Utility to wait for any inbound ops from a set of containers
-     * @param containersToApply - the set of containers to wait for any inbound ops for
-     */
-    private waitForAnyInboundOps;
-    /**
-     * Resume all queue activities on all paused tracked containers and return them
-     */
-    resumeProcessing(...containers: IContainer[]): IContainer[];
-    /**
-     * Pause all queue activities on the containers given, or all tracked containers
-     * Any containers given that is not tracked will be ignored.
-     *
-     * When a container is paused, it is assumed that we want fine grain control over op
-     * sequencing.  This function will prepare the container and force it into write mode to
-     * avoid missing join messages or change the sequence of event when switching from read to
-     * write mode.
-     */
-    pauseProcessing(...containers: IContainer[]): Promise<void>;
-    /**
-     * When a container is paused, it is assumed that we want fine grain control over op
-     * sequencing.  This function will prepare the container and force it into write mode to
-     * avoid missing join messages or change the sequence of event when switching from read to
-     * write mode.
-     *
-     * @param container - the container to pause
-     * @param record - the record for the container
-     */
-    private pauseContainer;
-    /**
-     * Pause all queue activities on all tracked containers, and resume only
-     * inbound to process ops until it is idle. All queues are left in the paused state
-     * after the function.
-     *
-     * Pausing will switch the container to write mode. See `pauseProcessing`
-     */
-    processIncoming(...containers: IContainer[]): Promise<void>;
-    /**
-     * Pause all queue activities on all tracked containers, and resume only
-     * outbound to process ops until it is idle. All queues are left in the paused state
-     * after the function.
-     *
-     * Pausing will switch the container to write mode. See `pauseProcessing`
-     */
-    processOutgoing(...containers: IContainer[]): Promise<void>;
-    /**
-     * Implementation of processIncoming and processOutgoing
-     */
-    private processQueue;
-    /**
-     * Utility to set up listener to track the outbound ops until it round trip back
-     * Returns a function to remove the handler after it is done.
-     *
-     * @param container - the container to setup
-     * @param inflightTracker - a map to track the clientSequenceNumber per container it expect to get ops back
-     */
-    private setupInOutTracker;
-    /**
-     * Setup debug traces for connection and ops
-     */
-    private setupTrace;
-    /**
-     * Filter out the opened containers based on param.
-     * @param containers - The container to filter to.  If the array is empty, it means don't filter and return
-     * all open containers.
-     */
-    private getContainers;
-}
-
-/**
- * A simple code loader that caches a mapping of package name to a Fluid entry point.
- * On load, it retrieves the entry point matching the package name in the given code details.
- */
-export declare class LocalCodeLoader implements ICodeDetailsLoader {
-    private readonly fluidPackageCache;
-    constructor(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, runtimeOptions?: IContainerRuntimeOptions);
-    /**
-     * It finds the entry point for the package name in the given source and return it
-     * as a Fluid module.
-     * @param source - Details of where to find chaincode
-     */
-    load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
-}
-
-export declare const mockConfigProvider: (settings?: Record<string, ConfigTypes>) => IConfigProviderBase;
-
-/**
- * Simple retry mechanism with linear back off to call
- * a function which may eventually return an accepted value.
- *
- * @param callback - the function to execute
- * @param check - the function to check if the value is acceptable
- * @param defaultValue - the default value
- * @param maxTries - maximum number of attempts
- * @param backOffMs - back off between attempts in milliseconds
- * @returns the actual value from the callback when successful or the default value otherwise
- */
-export declare const retryWithEventualValue: <T>(callback: () => Promise<T>, check: (value: T) => boolean, defaultValue: T, maxTries?: number, backOffMs?: number) => Promise<T>;
-
-/**
- * Summarizes on demand and returns the summary tree, the version number and the reference sequence number of the
- * submitted summary.
- *
- * @param summarizer - The ISummarizer to use to summarize on demand
- * @param inputs - Either the reason string or the full IOnDemandSummarizeOptions.
- * Defaults to the reason "end-to-end test".
- */
-export declare function summarizeNow(summarizer: ISummarizer, inputs?: string | IOnDemandSummarizeOptions): Promise<{
-    summaryTree: ISummaryTree;
-    summaryVersion: string;
-    summaryRefSeq: number;
-}>;
-
-export declare type SupportedExportInterfaces = Partial<IProvideRuntimeFactory & IProvideFluidDataStoreFactory & IProvideFluidDataStoreRegistry & IProvideFluidCodeDetailsComparer>;
-
-/**
- * A container runtime factory that allows you to set runtime options
- */
-export declare const TestContainerRuntimeFactory: {
-    new (type: string, dataStoreFactory: IFluidDataStoreFactory, runtimeOptions?: IContainerRuntimeOptions, requestHandlers?: RuntimeRequestHandler[]): {
-        type: string;
-        dataStoreFactory: IFluidDataStoreFactory;
-        runtimeOptions: IContainerRuntimeOptions;
-        requestHandlers: RuntimeRequestHandler[];
-        instantiateFirstTime(runtime: ContainerRuntime): Promise<void>;
-        instantiateFromExisting(runtime: ContainerRuntime): Promise<void>;
-        preInitialize(context: IContainerContext, existing: boolean): Promise<IRuntime & IContainerRuntime>;
-        readonly IRuntimeFactory: any;
-        instantiateRuntime(context: IContainerContext, existing: boolean): Promise<IRuntime>;
-        hasInitialized(_runtime: IContainerRuntime): Promise<void>;
-    };
-};
-
-/**
- * A test Fluid object that will create a shared object for each key-value pair in the factoryEntries passed to load.
- * The shared objects can be retrieved by passing the key of the entry to getSharedObject.
- * It exposes the IFluidDataStoreContext and IFluidDataStoreRuntime.
- */
-export declare class TestFluidObject implements ITestFluidObject {
-    readonly runtime: IFluidDataStoreRuntime;
-    readonly channel: IFluidDataStoreChannel;
-    readonly context: IFluidDataStoreContext;
-    private readonly factoryEntriesMap;
-    get ITestFluidObject(): this;
-    get IFluidLoadable(): this;
-    /**
-     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
-     */
-    get IFluidRouter(): this;
-    get handle(): IFluidHandle<this>;
-    root: ISharedMap;
-    private readonly innerHandle;
-    private initializeP;
-    /**
-     * Creates a new TestFluidObject.
-     * @param runtime - The data store runtime.
-     * @param context - The data store context.
-     * @param factoryEntries - A list of id to IChannelFactory mapping. For each item in the list,
-     * a shared object is created which can be retrieved by calling getSharedObject() with the id;
-     */
-    constructor(runtime: IFluidDataStoreRuntime, channel: IFluidDataStoreChannel, context: IFluidDataStoreContext, factoryEntriesMap: Map<string, IChannelFactory>);
-    /**
-     * Retrieves a shared object with the given id.
-     * @param id - The id of the shared object to retrieve.
-     */
-    getSharedObject<T = any>(id: string): Promise<T>;
-    /**
-     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
-     */
-    request(request: IRequest): Promise<IResponse>;
-    initialize(existing: boolean): Promise<void>;
-}
-
-/**
- * Creates a factory for a TestFluidObject with the given object factory entries. It creates a data store runtime
- * with the object factories in the entry list. All the entries with an id other than undefined are passed to the
- * Fluid object so that it can create a shared object for each.
- *
- * @example
- *
- * The following will create a Fluid object that creates and loads a SharedString and SharedDirectory.
- * It will add SparseMatrix to the data store's factory so that it can be created later.
- *
- * ```typescript
- * new TestFluidObjectFactory([
- *  [ "sharedString", SharedString.getFactory() ],
- *  [ "sharedDirectory", SharedDirectory.getFactory() ],
- *  [ undefined, SparseMatrix.getFactory() ],
- * ]);
- * ```
- *
- * The SharedString and SharedDirectory can be retrieved via getSharedObject() on the TestFluidObject as follows:
- *
- * ```typescript
- * sharedString = testFluidObject.getSharedObject<SharedString>("sharedString");
- * sharedDir = testFluidObject.getSharedObject<SharedDirectory>("sharedDirectory");
- * ```
- *
- * @privateRemarks Beware that using this class generally forfeits some compatibility coverage
- * `describeCompat` aims to provide:
- * `SharedMap`s always reference the current version of SharedMap.
- * AB#4670 tracks improving this situation.
- */
-export declare class TestFluidObjectFactory implements IFluidDataStoreFactory {
-    private readonly factoryEntries;
-    readonly type: string;
-    get IFluidDataStoreFactory(): this;
-    /**
-     * Creates a new TestFluidObjectFactory.
-     * @param factoryEntries - A list of id to IChannelFactory mapping. It creates a data store runtime with each
-     * IChannelFactory. Entries with string ids are passed to the Fluid object so that it can create a shared object
-     * for it.
-     */
-    constructor(factoryEntries: ChannelFactoryRegistry, type?: string);
-    instantiateDataStore(context: IFluidDataStoreContext, existing: boolean): Promise<FluidDataStoreRuntime>;
-}
-
-/**
- * Shared base class for test object provider.  Contain code for loader and container creation and loading
- */
-export declare class TestObjectProvider implements ITestObjectProvider {
-    readonly LoaderConstructor: typeof Loader;
-    readonly driver: ITestDriver;
-    readonly createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint;
-    private _loaderContainerTracker;
-    private _documentServiceFactory;
-    private _urlResolver;
-    private _logger;
-    private readonly _documentIdStrategy;
-    private _documentCreated;
-    /**
-     * Manage objects for loading and creating container, including the driver, loader, and OpProcessingController
-     * @param createFluidEntryPoint - callback to create a fluidEntryPoint, with an optional set of channel name
-     * and factory for TestFluidObject
-     */
-    constructor(LoaderConstructor: typeof Loader, driver: ITestDriver, createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint);
-    get logger(): EventAndErrorTrackingLogger;
-    set logger(logger: EventAndErrorTrackingLogger);
-    get documentServiceFactory(): IDocumentServiceFactory;
-    get urlResolver(): IUrlResolver;
-    get documentId(): string;
-    get defaultCodeDetails(): IFluidCodeDetails;
-    get opProcessingController(): IOpProcessingController;
-    /**
-     * Create a loader. Containers created/loaded through this loader will be added to the OpProcessingController.
-     *
-     * Only the version of the loader will vary based on compat config. The version of
-     * containerRuntime/dataRuntime used in fluidEntryPoint will be used as is from what is passed in.
-     *
-     * @param packageEntries - list of code details and fluidEntryPoint pairs.
-     */
-    createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, loaderProps?: Partial<ILoaderProps>): Loader;
-    /**
-     * Create a container using a default document id and code details.
-     * Container created is automatically added to the OpProcessingController to manage op flow
-     *
-     * Only the version of the loader will vary based on compat config. The version of
-     * containerRuntime/dataRuntime used in fluidEntryPoint will be used as is from what is passed in.
-     *
-     * @param packageEntries - list of code details and fluidEntryPoint pairs.
-     */
-    createContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>): Promise<IContainer>;
-    loadContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>, requestHeader?: IRequestHeader): Promise<IContainer>;
-    private resolveContainer;
-    /**
-     * Make a test loader. Containers created/loaded through this loader will be added to the OpProcessingController.
-     * The version of the loader/containerRuntime/dataRuntime may vary based on compat config of the current run
-     * @param testContainerConfig - optional configuring the test Container
-     */
-    makeTestLoader(testContainerConfig?: ITestContainerConfig): Loader;
-    /**
-     * Make a container using a default document id and code details
-     * Container loaded is automatically added to the OpProcessingController to manage op flow
-     * @param testContainerConfig - optional configuring the test Container
-     */
-    makeTestContainer(testContainerConfig?: ITestContainerConfig): Promise<IContainer>;
-    /**
-     * Load a container using a default document id and code details.
-     * IContainer loaded is automatically added to the OpProcessingController to manage op flow
-     * @param testContainerConfig - optional configuring the test Container
-     * @param requestHeader - optional headers to be supplied to the loader
-     */
-    loadTestContainer(testContainerConfig?: ITestContainerConfig, requestHeader?: IRequestHeader): Promise<IContainer>;
-    reset(): void;
-    ensureSynchronized(): Promise<void>;
-    waitContainerToCatchUp(container: IContainer): Promise<boolean>;
-    updateDocumentId(resolvedUrl: IResolvedUrl | undefined): void;
-    resetLoaderContainerTracker(syncSummarizerClients?: boolean): void;
-}
-
-/**
- * Wraps the given promise around with promise that will complete after a specific timeout if the original promise does
- * not resolve by then. By default, it uses the mocha test timeout and complete the promise just before that so that
- * tests don't time out because of unpredictable awaits.
- * The timeout can be overridden via timeoutOptions but it's recommended to use the default value.
- * @param promise - The promise to be awaited.
- * @param timeoutOptions - Options that can be used to override the timeout and / or define the behavior
- * when the promise is not fulfilled. For example, instead of rejecting the promise, resolve with a
- * specific value.
- * @returns A new promise that will complete when the given promise resolves or the timeout expires.
- */
-export declare function timeoutAwait<T = void>(promise: PromiseLike<T>, timeoutOptions?: TimeoutWithError | TimeoutWithValue<T>): Promise<T>;
-
-/**
- * Creates a promise from the given executor that will complete after a specific timeout. By default, it uses the mocha
- * test timeout and complete the promise just before that so that tests don't time out because of unpredictable awaits.
- * The timeout can be overridden via timeoutOptions but it's recommended to use the default value.
- * @param executor - The executor for the promise.
- * @param timeoutOptions - Options that can be used to override the timeout and / or define the behavior when
- * the promise is not fulfilled. For example, instead of rejecting the promise, resolve with a specific value.
- * @returns A new promise that will complete when the given executor resolves or the timeout expires.
- */
-export declare function timeoutPromise<T = void>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void, timeoutOptions?: TimeoutWithError | TimeoutWithValue<T>): Promise<T>;
-
-export declare interface TimeoutWithError {
-    /**
-     * Timeout duration in milliseconds, if it is great than 0 and not Infinity
-     * If it is undefined, then it will use test timeout if we are in side the test function
-     * Otherwise, there is no timeout
-     */
-    durationMs?: number;
-    reject?: true;
-    errorMsg?: string;
-}
-
-export declare interface TimeoutWithValue<T = void> {
-    /**
-     * Timeout duration in milliseconds, if it is great than 0 and not Infinity
-     * If it is undefined, then it will use test timeout if we are in side the test function
-     * Otherwise, there is no timeout
-     */
-    durationMs?: number;
-    reject: false;
-    value: T;
-}
-
-/**
- * Utility function to wait for the specified Container to be in Connected state.
- * If the Container is already connected, the Promise returns immediately; otherwise it resolves when the Container emits
- * its 'connected' event.
- * If failOnContainerClose === true, the returned Promise will be rejected if the container emits a 'closed' event
- * before a 'connected' event.
- * @param container - The container to wait for.
- * @param failOnContainerClose - If true, the returned Promise will be rejected if the container emits a 'closed' event
- * before a 'connected' event.
- * Defaults to true.
- * @param timeoutOptions - Options related to the behavior of the timeout.
- * If provided, the returned Promise will reject if the container hasn't emitted relevant events in timeoutOptions.durationMs.
- * If not provided, the Promise will wait indefinitely for the Container to emit its 'connected' (or 'closed', if
- * failOnContainerClose === true) event.
- *
- * @returns A Promise that either:
- * - Resolves when the specified container emits a 'connected' event (or immediately if the Container is already connected).
- * - Rejects if failOnContainerClose === true and the container emits a 'closed' event before a 'connected' event.
- * - Rejects after timeoutOptions.durationMs if timeoutOptions !== undefined and the container does not emit relevant
- * events, within that timeframe.
- */
-export declare function waitForContainerConnection(container: IContainer, failOnContainerClose?: boolean, timeoutOptions?: TimeoutWithError): Promise<void>;
-
-/**
- * Wraps the given IDocumentService to override the `connectToStorage` method. The intent is to plumb the
- * `uploadSummaryCb` to the IDocumentStorageService so that it is called whenever a summary is uploaded by
- * the client.
- * The document storage service that is created in `connectToStorage` is wrapped by calling `wrapDocumentStorageService`
- * to pass in the `uploadSummaryCb`.
- */
-export declare function wrapDocumentService(innerDocService: IDocumentService, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentService;
-
-/**
- * Wraps the given IDocumentServiceFactory to override the `createDocumentService` method. The intent is to plumb
- * the `uploadSummaryCb` all the way to the IDocumentStorageService so that it is called whenever a summary is
- * uploaded by the client.
- * The document service that is created in `createDocumentService` is wrapped by calling `wrapDocumentService` to
- * pass in the `uploadSummaryCb`.
- */
-export declare function wrapDocumentServiceFactory(innerDocServiceFactory: IDocumentServiceFactory, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentServiceFactory;
-
-/**
- * Wraps the given IDocumentStorageService to override the `uploadSummaryWithContext` method. It calls the
- * `uploadSummaryCb` whenever a summary is uploaded by the client. The summary context can be updated in the
- * callback before it is uploaded to the server.
- */
-export declare function wrapDocumentStorageService(innerDocStorageService: IDocumentStorageService, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentStorageService;
+
+/* Excluded from this release type: ChannelFactoryRegistry */
+
+/* Excluded from this release type: ConfigTypes */
+
+/* Excluded from this release type: ContainerRuntime */
+
+/* Excluded from this release type: ContainerRuntimeFactoryWithDefaultDataStore */
+
+/* Excluded from this release type: createAndAttachContainer */
+
+/* Excluded from this release type: createContainerRuntimeFactoryWithDefaultDataStore */
+
+/* Excluded from this release type: createDocumentId */
+
+/* Excluded from this release type: createLoader */
+
+/* Excluded from this release type: createSummarizer */
+
+/* Excluded from this release type: createSummarizerFromFactory */
+
+/* Excluded from this release type: createTestContainerRuntimeFactory */
+
+/* Excluded from this release type: DataObjectFactoryType */
+
+/* Excluded from this release type: defaultTimeoutDurationMs */
+
+/* Excluded from this release type: EventAndErrorTrackingLogger */
+
+/* Excluded from this release type: FluidDataStoreRuntime */
+
+/* Excluded from this release type: fluidEntryPoint */
+
+/* Excluded from this release type: FluidObject */
+
+/* Excluded from this release type: getContainerEntryPointBackCompat */
+
+/* Excluded from this release type: getDataStoreEntryPointBackCompat */
+
+/* Excluded from this release type: getUnexpectedLogErrorException */
+
+/* Excluded from this release type: IChannelFactory */
+
+/* Excluded from this release type: ICodeDetailsLoader */
+
+/* Excluded from this release type: IConfigProviderBase */
+
+/* Excluded from this release type: IContainer */
+
+/* Excluded from this release type: IContainerContext */
+
+/* Excluded from this release type: IContainerRuntime */
+
+/* Excluded from this release type: IContainerRuntimeOptions */
+
+/* Excluded from this release type: IDataStore */
+
+/* Excluded from this release type: IDocumentIdStrategy */
+
+/* Excluded from this release type: IDocumentService */
+
+/* Excluded from this release type: IDocumentServiceFactory */
+
+/* Excluded from this release type: IDocumentStorageService */
+
+/* Excluded from this release type: IFluidCodeDetails */
+
+/* Excluded from this release type: IFluidDataStoreChannel */
+
+/* Excluded from this release type: IFluidDataStoreContext */
+
+/* Excluded from this release type: IFluidDataStoreFactory */
+
+/* Excluded from this release type: IFluidDataStoreRuntime */
+
+/* Excluded from this release type: IFluidHandle */
+
+/* Excluded from this release type: IFluidLoadable */
+
+/* Excluded from this release type: IFluidModule */
+
+/* Excluded from this release type: IFluidModuleWithDetails */
+
+/* Excluded from this release type: IHostLoader */
+
+/* Excluded from this release type: ILoaderOptions */
+
+/* Excluded from this release type: ILoaderProps */
+
+/* Excluded from this release type: IOnDemandSummarizeOptions */
+
+/* Excluded from this release type: IOpProcessingController */
+
+/* Excluded from this release type: IProvideFluidCodeDetailsComparer */
+
+/* Excluded from this release type: IProvideFluidDataStoreFactory */
+
+/* Excluded from this release type: IProvideFluidDataStoreRegistry */
+
+/* Excluded from this release type: IProvideRuntimeFactory */
+
+/* Excluded from this release type: IProvideTestFluidObject */
+
+/* Excluded from this release type: IRequest */
+
+/* Excluded from this release type: IResolvedUrl */
+
+/* Excluded from this release type: IResponse */
+
+/* Excluded from this release type: IRuntime */
+
+/* Excluded from this release type: ISharedMap */
+
+/* Excluded from this release type: ISummarizer */
+
+/* Excluded from this release type: ISummaryContext */
+
+/* Excluded from this release type: ITelemetryBaseEvent */
+
+/* Excluded from this release type: ITelemetryBaseLogger */
+
+/* Excluded from this release type: ITelemetryGenericEvent */
+
+/* Excluded from this release type: ITestContainerConfig */
+
+/* Excluded from this release type: ITestDriver */
+
+/* Excluded from this release type: ITestFluidObject */
+
+/* Excluded from this release type: ITestObjectProvider */
+
+/* Excluded from this release type: IUrlResolver */
+
+/* Excluded from this release type: Loader */
+
+/* Excluded from this release type: LoaderContainerTracker */
+
+/* Excluded from this release type: LocalCodeLoader */
+
+/* Excluded from this release type: mockConfigProvider */
+
+/* Excluded from this release type: NamedFluidDataStoreRegistryEntries */
+
+/* Excluded from this release type: retryWithEventualValue */
+
+/* Excluded from this release type: RuntimeRequestHandler */
+
+/* Excluded from this release type: summarizeNow */
+
+/* Excluded from this release type: SupportedExportInterfaces */
+
+/* Excluded from this release type: TestContainerRuntimeFactory */
+
+/* Excluded from this release type: TestFluidObject */
+
+/* Excluded from this release type: TestFluidObjectFactory */
+
+/* Excluded from this release type: TestObjectProvider */
+
+/* Excluded from this release type: TestObjectProviderWithVersionedLoad */
+
+/* Excluded from this release type: timeoutAwait */
+
+/* Excluded from this release type: timeoutPromise */
+
+/* Excluded from this release type: TimeoutWithError */
+
+/* Excluded from this release type: TimeoutWithValue */
+
+/* Excluded from this release type: waitForContainerConnection */
+
+/* Excluded from this release type: wrapDocumentService */
+
+/* Excluded from this release type: wrapDocumentServiceFactory */
+
+/* Excluded from this release type: wrapDocumentStorageService */
 
 export { }