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

package/lib/test-utils-untrimmed.d.ts

@@ -1,15 +1,16 @@
-import { ConfigTypes } from '@fluidframework/telemetry-utils';
+import { ConfigTypes } from '@fluidframework/core-interfaces';
 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 { IConfigProviderBase } from '@fluidframework/core-interfaces';
 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 { IDataStore } from '@fluidframework/runtime-definitions';
 import { IDocumentService } from '@fluidframework/driver-definitions';
 import { IDocumentServiceFactory } from '@fluidframework/driver-definitions';
 import { IDocumentStorageService } from '@fluidframework/driver-definitions';
@@ -48,6 +49,9 @@ import { Loader } from '@fluidframework/container-loader';
 import { NamedFluidDataStoreRegistryEntries } from '@fluidframework/runtime-definitions';
 import { RuntimeRequestHandler } from '@fluidframework/request-handler';
 
+/**
+ * @internal
+ */
 export declare type ChannelFactoryRegistry = Iterable<[string | undefined, IChannelFactory]>;
 
 /**
@@ -55,11 +59,13 @@ export declare type ChannelFactoryRegistry = Iterable<[string | undefined, IChan
  * @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.
+ * @internal
  */
 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
+ * @internal
  */
 export declare const createContainerRuntimeFactoryWithDefaultDataStore: (Base: typeof ContainerRuntimeFactoryWithDefaultDataStore | undefined, ctorArgs: {
     defaultFactory: IFluidDataStoreFactory;
@@ -70,6 +76,9 @@ export declare const createContainerRuntimeFactoryWithDefaultDataStore: (Base: t
     provideEntryPoint?: ((runtime: IContainerRuntime) => Promise<FluidObject>) | undefined;
 }) => ContainerRuntimeFactoryWithDefaultDataStore;
 
+/**
+ * @internal
+ */
 export declare const createDocumentId: () => string;
 
 /**
@@ -78,6 +87,7 @@ export declare const createDocumentId: () => string;
  * @param documentServiceFactory - the driver factory to use
  * @param urlResolver - the url resolver to use
  * @param options - loader options
+ * @internal
  */
 export declare function createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, documentServiceFactory: IDocumentServiceFactory, urlResolver: IUrlResolver, logger?: ITelemetryBaseLogger, options?: ILoaderOptions): IHostLoader;
 
@@ -86,6 +96,7 @@ export declare function createLoader(packageEntries: Iterable<[IFluidCodeDetails
  * 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.
+ * @internal
  */
 export declare function createSummarizer(provider: ITestObjectProvider, container: IContainer, config?: ITestContainerConfig, summaryVersion?: string, logger?: ITelemetryBaseLogger): Promise<{
     container: IContainer;
@@ -96,6 +107,7 @@ export declare function createSummarizer(provider: ITestObjectProvider, containe
  * 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.
+ * @internal
  */
 export declare function createSummarizerFromFactory(provider: ITestObjectProvider, container: IContainer, dataStoreFactory: IFluidDataStoreFactory, summaryVersion?: string, containerRuntimeFactoryType?: typeof ContainerRuntimeFactoryWithDefaultDataStore, registryEntries?: NamedFluidDataStoreRegistryEntries, logger?: ITelemetryBaseLogger, configProvider?: IConfigProviderBase): Promise<{
     container: IContainer;
@@ -104,6 +116,7 @@ export declare function createSummarizerFromFactory(provider: ITestObjectProvide
 
 /**
  * Create a container runtime factory class that allows you to set runtime options
+ * @internal
  */
 export declare const createTestContainerRuntimeFactory: (containerRuntimeCtor: typeof ContainerRuntime) => {
     new (type: string, dataStoreFactory: IFluidDataStoreFactory, runtimeOptions?: IContainerRuntimeOptions, requestHandlers?: RuntimeRequestHandler[]): {
@@ -120,11 +133,17 @@ export declare const createTestContainerRuntimeFactory: (containerRuntimeCtor: t
     };
 };
 
+/**
+ * @internal
+ */
 export declare enum DataObjectFactoryType {
     Primed = 0,
     Test = 1
 }
 
+/**
+ * @internal
+ */
 export declare const defaultTimeoutDurationMs = 250;
 
 /**
@@ -132,6 +151,7 @@ export declare const defaultTimeoutDurationMs = 250;
  * 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.
+ * @internal
  */
 export declare class EventAndErrorTrackingLogger implements ITelemetryBaseLogger {
     private readonly baseLogger;
@@ -154,17 +174,56 @@ export declare class EventAndErrorTrackingLogger implements ITelemetryBaseLogger
     };
 }
 
+/**
+ * @internal
+ */
 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
+ * @internal
  */
 export declare function getContainerEntryPointBackCompat<T>(container: IContainer): Promise<T>;
 
+/**
+ * This function should ONLY be used for back compat purposes
+ * Older supported versions of IDataStore do not have the "entryPoint" property, so we need to fallback to "request"
+ * This function can be removed once back-compat support for IDataStore moves to 2.0.0-internal.7.0.0
+ *
+ * @internal
+ */
+export declare function getDataStoreEntryPointBackCompat<T>(dataStore: IDataStore): Promise<T>;
+
+/**
+ * @internal
+ */
 export declare function getUnexpectedLogErrorException(logger: EventAndErrorTrackingLogger | undefined, prefix?: string): Error | undefined;
 
+/**
+ * Used to retrieve, update, and reset document id based on the type of driver being used.
+ *
+ * @internal
+ */
+export declare interface IDocumentIdStrategy {
+    /**
+     * Get document id
+     */
+    get(): string;
+    /**
+     * Update the document ID from the resolved container's URL and reset the ID property
+     */
+    update(resolvedUrl?: IResolvedUrl): void;
+    /**
+     * Reset document id to a new document id
+     */
+    reset(): void;
+}
+
+/**
+ * @internal
+ */
 export declare interface IOpProcessingController {
     processIncoming(...containers: IContainer[]): Promise<void>;
     processOutgoing(...containers: IContainer[]): Promise<void>;
@@ -172,10 +231,16 @@ export declare interface IOpProcessingController {
     resumeProcessing(...containers: IContainer[]): void;
 }
 
+/**
+ * @internal
+ */
 export declare interface IProvideTestFluidObject {
     readonly ITestFluidObject: ITestFluidObject;
 }
 
+/**
+ * @internal
+ */
 export declare interface ITestContainerConfig {
     /** TestFluidDataObject instead of PrimedDataStore */
     fluidDataObjectType?: DataObjectFactoryType;
@@ -189,6 +254,9 @@ export declare interface ITestContainerConfig {
     loaderProps?: Partial<ILoaderProps>;
 }
 
+/**
+ * @internal
+ */
 export declare interface ITestFluidObject extends IProvideTestFluidObject, IFluidLoadable {
     root: ISharedMap;
     readonly runtime: IFluidDataStoreRuntime;
@@ -197,34 +265,109 @@ export declare interface ITestFluidObject extends IProvideTestFluidObject, IFlui
     getSharedObject<T = any>(id: string): Promise<T>;
 }
 
+/**
+ * @internal
+ */
 export declare interface ITestObjectProvider {
+    /**
+     * Indicates which type of test object provider is being used.
+     */
+    type: "TestObjectProvider" | "TestObjectProviderWithVersionedLoad";
+    /**
+     * The document id to retrieve or create containers
+     */
+    documentId: string;
+    /**
+     * Creates the document service after extracting different endpoints URLs from a resolved URL.
+     */
+    documentServiceFactory: IDocumentServiceFactory;
+    /**
+     * Test driver used to create the IDocumentServiceFactory. Varies depending on the test type.
+     */
+    driver: ITestDriver;
+    /**
+     * Logger used to track expected and unexpected events.
+     */
+    logger: EventAndErrorTrackingLogger | undefined;
+    /**
+     * Used to create a url for the created container with any data store path given in the relative url.
+     */
+    urlResolver: IUrlResolver;
+    /**
+     * Default IFluidCodeDetails used to create containers.
+     */
+    defaultCodeDetails: IFluidCodeDetails;
+    /**
+     * Contains functions to pause/resume op processing.
+     */
+    opProcessingController: IOpProcessingController;
+    /**
+     * Represents the entry point for a Fluid container.
+     */
     createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint;
+    /**
+     * 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>): IHostLoader;
+    /**
+     * 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>;
+    /**
+     * Loads a container using the default document id
+     */
     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.
+     * 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): IHostLoader;
+    /**
+     * 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>;
     /**
-     *
-     * @param url - Resolved container URL
+     * Update the document ID from the resolved container's URL and reset the ID property
      */
     updateDocumentId(url: IResolvedUrl | undefined): void;
-    logger: ITelemetryBaseLogger;
-    documentServiceFactory: IDocumentServiceFactory;
-    urlResolver: IUrlResolver;
-    defaultCodeDetails: IFluidCodeDetails;
-    opProcessingController: IOpProcessingController;
+    /**
+     * Make sure all the tracked containers are synchronized.
+     */
     ensureSynchronized(timeoutDuration?: number): Promise<void>;
+    /**
+     * Reset the tracker, closing all containers and stop tracking them.
+     */
+    resetLoaderContainerTracker(syncSummarizerClients?: boolean): any;
+    /**
+     * Resets and closes all tracked containers and class states.
+     */
     reset(): void;
-    documentId: string;
-    driver: ITestDriver;
 }
 
+/**
+ * @internal
+ */
 export declare class LoaderContainerTracker implements IOpProcessingController {
     private readonly syncSummarizerClients;
     private readonly containers;
@@ -367,6 +510,7 @@ export declare class LoaderContainerTracker implements IOpProcessingController {
 /**
  * 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.
+ * @internal
  */
 export declare class LocalCodeLoader implements ICodeDetailsLoader {
     private readonly fluidPackageCache;
@@ -379,6 +523,9 @@ export declare class LocalCodeLoader implements ICodeDetailsLoader {
     load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
 }
 
+/**
+ * @internal
+ */
 export declare const mockConfigProvider: (settings?: Record<string, ConfigTypes>) => IConfigProviderBase;
 
 /**
@@ -391,6 +538,7 @@ export declare const mockConfigProvider: (settings?: Record<string, ConfigTypes>
  * @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
+ * @internal
  */
 export declare const retryWithEventualValue: <T>(callback: () => Promise<T>, check: (value: T) => boolean, defaultValue: T, maxTries?: number, backOffMs?: number) => Promise<T>;
 
@@ -401,6 +549,7 @@ export declare const retryWithEventualValue: <T>(callback: () => Promise<T>, che
  * @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".
+ * @internal
  */
 export declare function summarizeNow(summarizer: ISummarizer, inputs?: string | IOnDemandSummarizeOptions): Promise<{
     summaryTree: ISummaryTree;
@@ -408,10 +557,14 @@ export declare function summarizeNow(summarizer: ISummarizer, inputs?: string |
     summaryRefSeq: number;
 }>;
 
+/**
+ * @internal
+ */
 export declare type SupportedExportInterfaces = Partial<IProvideRuntimeFactory & IProvideFluidDataStoreFactory & IProvideFluidDataStoreRegistry & IProvideFluidCodeDetailsComparer>;
 
 /**
  * A container runtime factory that allows you to set runtime options
+ * @internal
  */
 export declare const TestContainerRuntimeFactory: {
     new (type: string, dataStoreFactory: IFluidDataStoreFactory, runtimeOptions?: IContainerRuntimeOptions, requestHandlers?: RuntimeRequestHandler[]): {
@@ -432,6 +585,7 @@ export declare const TestContainerRuntimeFactory: {
  * 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.
+ * @internal
  */
 export declare class TestFluidObject implements ITestFluidObject {
     readonly runtime: IFluidDataStoreRuntime;
@@ -497,6 +651,7 @@ export declare class TestFluidObject implements ITestFluidObject {
  * `describeCompat` aims to provide:
  * `SharedMap`s always reference the current version of SharedMap.
  * AB#4670 tracks improving this situation.
+ * @internal
  */
 export declare class TestFluidObjectFactory implements IFluidDataStoreFactory {
     private readonly factoryEntries;
@@ -514,11 +669,22 @@ export declare class TestFluidObjectFactory implements IFluidDataStoreFactory {
 
 /**
  * Shared base class for test object provider.  Contain code for loader and container creation and loading
+ * @internal
  */
 export declare class TestObjectProvider implements ITestObjectProvider {
-    readonly LoaderConstructor: typeof Loader;
+    private readonly LoaderConstructor;
+    /**
+     * {@inheritDoc ITestObjectProvider.driver}
+     */
     readonly driver: ITestDriver;
+    /**
+     * {@inheritDoc ITestObjectProvider.createFluidEntryPoint}
+     */
     readonly createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint;
+    /**
+     * {@inheritDoc ITestObjectProvider."type"}
+     */
+    readonly type = "TestObjectProvider";
     private _loaderContainerTracker;
     private _documentServiceFactory;
     private _urlResolver;
@@ -530,59 +696,192 @@ export declare class TestObjectProvider implements ITestObjectProvider {
      * @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);
+    constructor(LoaderConstructor: typeof Loader, 
+    /**
+     * {@inheritDoc ITestObjectProvider.driver}
+     */
+    driver: ITestDriver, 
+    /**
+     * {@inheritDoc ITestObjectProvider.createFluidEntryPoint}
+     */
+    createFluidEntryPoint: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint);
+    /**
+     * {@inheritDoc ITestObjectProvider.logger}
+     */
     get logger(): EventAndErrorTrackingLogger;
-    set logger(logger: EventAndErrorTrackingLogger);
+    private set logger(value);
+    /**
+     * {@inheritDoc ITestObjectProvider.documentServiceFactory}
+     */
     get documentServiceFactory(): IDocumentServiceFactory;
+    /**
+     * {@inheritDoc ITestObjectProvider.urlResolver}
+     */
     get urlResolver(): IUrlResolver;
+    /**
+     * {@inheritDoc ITestObjectProvider.documentId}
+     */
     get documentId(): string;
+    /**
+     * {@inheritDoc ITestObjectProvider.defaultCodeDetails}
+     */
     get defaultCodeDetails(): IFluidCodeDetails;
+    /**
+     * {@inheritDoc ITestObjectProvider.opProcessingController}
+     */
     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.
+     * {@inheritDoc ITestObjectProvider.createLoader}
      */
     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.
+     * {@inheritDoc ITestObjectProvider.createContainer}
+     */
+    createContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>): Promise<IContainer>;
+    /**
+     * {@inheritDoc ITestObjectProvider.loadContainer}
+     */
+    loadContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>, requestHeader?: IRequestHeader): Promise<IContainer>;
+    private resolveContainer;
+    /**
+     * {@inheritDoc ITestObjectProvider.makeTestLoader}
+     */
+    makeTestLoader(testContainerConfig?: ITestContainerConfig): Loader;
+    /**
+     * {@inheritDoc ITestObjectProvider.makeTestContainer}
+     */
+    makeTestContainer(testContainerConfig?: ITestContainerConfig): Promise<IContainer>;
+    /**
+     * {@inheritDoc ITestObjectProvider.loadTestContainer}
+     */
+    loadTestContainer(testContainerConfig?: ITestContainerConfig, requestHeader?: IRequestHeader): Promise<IContainer>;
+    /**
+     * {@inheritDoc ITestObjectProvider.reset}
+     */
+    reset(): void;
+    /**
+     * {@inheritDoc ITestObjectProvider.ensureSynchronized}
+     */
+    ensureSynchronized(): Promise<void>;
+    private waitContainerToCatchUp;
+    /**
+     * {@inheritDoc ITestObjectProvider.updateDocumentId}
+     */
+    updateDocumentId(resolvedUrl: IResolvedUrl | undefined): void;
+    /**
+     * {@inheritDoc ITestObjectProvider.resetLoaderContainerTracker}
+     */
+    resetLoaderContainerTracker(syncSummarizerClients?: boolean): void;
+}
+
+/**
+ * Implements {@link ITestObjectProvider}, but uses different versions to create and load containers.
+ *
+ * @internal
+ */
+export declare class TestObjectProviderWithVersionedLoad implements ITestObjectProvider {
+    private readonly LoaderConstructorForCreating;
+    private readonly LoaderConstructorForLoading;
+    private readonly driverForCreating;
+    private readonly driverForLoading;
+    private readonly createFluidEntryPointForCreating;
+    private readonly createFluidEntryPointForLoading;
+    /**
+     * {@inheritDoc ITestObjectProvider."type"}
+     */
+    readonly type = "TestObjectProviderWithVersionedLoad";
+    private _loaderContainerTracker;
+    private _logger;
+    private readonly _documentIdStrategy;
+    private _documentServiceFactory;
+    private _urlResolver;
+    private _documentCreated;
+    /**
+     * `_loadCount` is used to alternate which version we load the next container with.
+     * loadCount is even then we will load with the "create" version, and if odd we load with the "load" version.
+     * After each test we will reset loadCount to 0 to ensure we always create the first container with the create version.
      *
-     * @param packageEntries - list of code details and fluidEntryPoint pairs.
+     * Note: This will only affect tests that load a container more than two times.
+     */
+    private _loadCount;
+    constructor(LoaderConstructorForCreating: typeof Loader, LoaderConstructorForLoading: typeof Loader, driverForCreating: ITestDriver, driverForLoading: ITestDriver, createFluidEntryPointForCreating: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint, createFluidEntryPointForLoading: (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint);
+    /**
+     * {@inheritDoc ITestObjectProvider.logger}
+     */
+    get logger(): EventAndErrorTrackingLogger;
+    /**
+     * {@inheritDoc ITestObjectProvider.documentServiceFactory}
+     */
+    get documentServiceFactory(): IDocumentServiceFactory;
+    /**
+     * {@inheritDoc ITestObjectProvider.urlResolver}
+     */
+    get urlResolver(): IUrlResolver;
+    /**
+     * {@inheritDoc ITestObjectProvider.documentId}
+     */
+    get documentId(): string;
+    /**
+     * {@inheritDoc ITestObjectProvider.defaultCodeDetails}
+     */
+    get defaultCodeDetails(): IFluidCodeDetails;
+    /**
+     * {@inheritDoc ITestObjectProvider.opProcessingController}
+     */
+    get opProcessingController(): IOpProcessingController;
+    /**
+     * {@inheritDoc ITestObjectProvider.driver}
+     */
+    get driver(): ITestDriver;
+    /**
+     * {@inheritDoc ITestObjectProvider.createFluidEntryPoint}
+     */
+    get createFluidEntryPoint(): (testContainerConfig?: ITestContainerConfig) => fluidEntryPoint;
+    private createLoaderForCreating;
+    private createLoaderForLoading;
+    /**
+     * {@inheritDoc ITestObjectProvider.createLoader}
+     */
+    createLoader(packageEntries: Iterable<[IFluidCodeDetails, fluidEntryPoint]>, loaderProps?: Partial<ILoaderProps>): Loader;
+    /**
+     * {@inheritDoc ITestObjectProvider.createContainer}
      */
     createContainer(entryPoint: fluidEntryPoint, loaderProps?: Partial<ILoaderProps>): Promise<IContainer>;
+    /**
+     * {@inheritDoc ITestObjectProvider.loadContainer}
+     */
     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
+     * {@inheritDoc ITestObjectProvider.makeTestLoader}
      */
     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
+     * {@inheritDoc ITestObjectProvider.makeTestContainer}
      */
     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
+     * {@inheritDoc ITestObjectProvider.loadTestContainer}
      */
     loadTestContainer(testContainerConfig?: ITestContainerConfig, requestHeader?: IRequestHeader): Promise<IContainer>;
+    /**
+     * {@inheritDoc ITestObjectProvider.reset}
+     */
     reset(): void;
+    /**
+     * {@inheritDoc ITestObjectProvider.ensureSynchronized}
+     */
     ensureSynchronized(): Promise<void>;
-    waitContainerToCatchUp(container: IContainer): Promise<boolean>;
+    private waitContainerToCatchUp;
+    /**
+     * {@inheritDoc ITestObjectProvider.updateDocumentId}
+     */
     updateDocumentId(resolvedUrl: IResolvedUrl | undefined): void;
+    /**
+     * {@inheritDoc ITestObjectProvider.resetLoaderContainerTracker}
+     */
     resetLoaderContainerTracker(syncSummarizerClients?: boolean): void;
+    private nextLoaderShouldCreate;
 }
 
 /**
@@ -595,6 +894,7 @@ export declare class TestObjectProvider implements ITestObjectProvider {
  * 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.
+ * @internal
  */
 export declare function timeoutAwait<T = void>(promise: PromiseLike<T>, timeoutOptions?: TimeoutWithError | TimeoutWithValue<T>): Promise<T>;
 
@@ -606,9 +906,13 @@ export declare function timeoutAwait<T = void>(promise: PromiseLike<T>, timeoutO
  * @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.
+ * @internal
  */
 export declare function timeoutPromise<T = void>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void, timeoutOptions?: TimeoutWithError | TimeoutWithValue<T>): Promise<T>;
 
+/**
+ * @internal
+ */
 export declare interface TimeoutWithError {
     /**
      * Timeout duration in milliseconds, if it is great than 0 and not Infinity
@@ -620,6 +924,9 @@ export declare interface TimeoutWithError {
     errorMsg?: string;
 }
 
+/**
+ * @internal
+ */
 export declare interface TimeoutWithValue<T = void> {
     /**
      * Timeout duration in milliseconds, if it is great than 0 and not Infinity
@@ -651,6 +958,7 @@ export declare interface TimeoutWithValue<T = void> {
  * - 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.
+ * @internal
  */
 export declare function waitForContainerConnection(container: IContainer, failOnContainerClose?: boolean, timeoutOptions?: TimeoutWithError): Promise<void>;
 
@@ -660,6 +968,7 @@ export declare function waitForContainerConnection(container: IContainer, failOn
  * the client.
  * The document storage service that is created in `connectToStorage` is wrapped by calling `wrapDocumentStorageService`
  * to pass in the `uploadSummaryCb`.
+ * @internal
  */
 export declare function wrapDocumentService(innerDocService: IDocumentService, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentService;
 
@@ -669,6 +978,7 @@ export declare function wrapDocumentService(innerDocService: IDocumentService, u
  * uploaded by the client.
  * The document service that is created in `createDocumentService` is wrapped by calling `wrapDocumentService` to
  * pass in the `uploadSummaryCb`.
+ * @internal
  */
 export declare function wrapDocumentServiceFactory(innerDocServiceFactory: IDocumentServiceFactory, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentServiceFactory;
 
@@ -676,6 +986,7 @@ export declare function wrapDocumentServiceFactory(innerDocServiceFactory: IDocu
  * 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.
+ * @internal
  */
 export declare function wrapDocumentStorageService(innerDocStorageService: IDocumentStorageService, uploadSummaryCb: (summaryTree: ISummaryTree, context: ISummaryContext) => ISummaryContext): IDocumentStorageService;