@hot-updater/test-utils 1.0.0-rc.16 → 1.0.0-rc.21

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { ArtifactInfo, Bundle, ReleaseCatalog } from "@hot-updater/core";
-import { DatabaseAdapter, DatabaseReadCount, PhysicalTable } from "@hot-updater/plugin-core/internal";
-import { BundleRow, ChannelRow, DeployReleasePolicy, EngineDatabase, HotUpdaterCoreApi, InsightsModel, ReleaseRow, StoragePlugin } from "@hot-updater/plugin-core";
+import { ArtifactInfo, Bundle } from "@hot-updater/protocol";
+import { AnyHotUpdaterPlugin, BundlePatchRow, BundleRow, ChannelRow, ClientAuth, DatabaseAdapter, DeployReleasePolicy, EngineDatabase, HotUpdaterCoreApi, HotUpdaterDatabase, KeyValueStore, ModuleSchema, PhysicalTable, PluginApis, ReadMeasurement, ReleaseRow, StorageAdapter, StorageOperation } from "@hot-updater/plugin-core";
+import { BundleEventRow, InsightsModel } from "@hot-updater/plugin-insights/server";
 //#region src/httpTestClient.d.ts
 type HttpTestRequestInit = NonNullable<ConstructorParameters<typeof Request>[1]>;
 type HttpTestRequest = (path: string, init?: HttpTestRequestInit) => Promise<Response>;
@@ -71,37 +71,6 @@ declare const setupCoreAdminTestSuite: (options: {
   readonly getClient: () => HttpTestClient;
 }) => void;
 //#endregion
-//#region src/setupInsightsHttpTestSuite.d.ts
-/**
- * The Insights plugin's routes on a database: a client reports an event, and
- * the admin routes read it back. The server must run `insights()`.
- */
-declare const setupInsightsHttpTestSuite: (options: {
-  readonly getClient: () => HttpTestClient;
-}) => void;
-//#endregion
-//#region src/databaseTestRunner.d.ts
-type Awaitable<T> = Promise<T> | T;
-/** How a suite gets a provider's database, and gives it back. */
-type DatabaseTestLifecycle<TDatabase> = {
-  readonly name: string;
-  /** Creates the provider's tables and settings rows, before `createDatabase`. */
-  readonly migrate: () => Awaitable<void>;
-  /** The provider's database, as its factory returns it. */
-  readonly createDatabase: () => Awaitable<TDatabase>;
-  /** Empties every table between tests. */
-  readonly reset: (database: TDatabase) => Awaitable<void>;
-  readonly dispose: (database: TDatabase) => Awaitable<void>;
-};
-//#endregion
-//#region src/setupInsightsModelTestSuite.d.ts
-/**
- * The Insights report contract on one database: pass the Insights plugin's
- * model over it, `createInsightsModel(createDatabasePluginApis(database,
- * [insights()]).insights)`, as `createDatabase`.
- */
-declare const setupInsightsModelTestSuite: (lifecycle: DatabaseTestLifecycle<InsightsModel>) => void;
-//#endregion
 //#region src/setupSemverSatisfiesTestSuite.d.ts
 /**
  *
@@ -124,29 +93,50 @@ declare const setupSemverSatisfiesTestSuite: ({ semverSatisfies }: {
   semverSatisfies: (targetAppVersion: string, currentVersion: string) => Promise<boolean> | boolean;
 }) => void;
 //#endregion
+//#region src/databaseTestRunner.d.ts
+type Awaitable<T> = Promise<T> | T;
+/** How a suite gets a provider's database, and gives it back. */
+type DatabaseTestLifecycle<TDatabase> = {
+  readonly name: string;
+  /** Creates the provider's tables and settings rows, before `createDatabase`. */
+  readonly migrate: () => Awaitable<void>;
+  /** The provider's database, as its factory returns it. */
+  readonly createDatabase: () => Awaitable<TDatabase>;
+  /** Empties every table between tests. */
+  readonly reset: (database: TDatabase) => Awaitable<void>;
+  readonly dispose: (database: TDatabase) => Awaitable<void>;
+};
+//#endregion
 //#region src/setupDatabaseTestSuite.d.ts
+/**
+ * A server plugin's tests on a provider's database, such as the Insights
+ * plugin's `insightsTestSuite()`. The provider's HTTP server must run the
+ * plugin.
+ */
+interface DatabasePluginTestSuite<TDatabase = unknown> {
+  readonly name: string;
+  register(context: {
+    readonly getClient: () => HttpTestClient;
+    readonly getDatabase: () => TDatabase;
+  }): void;
+}
 type DatabaseTestSuiteOptions<TDatabase extends EngineDatabase = EngineDatabase> = DatabaseTestLifecycle<TDatabase> & {
   /**
-   * Serves the handlers of `createHotUpdater({ database, storage, plugins:
-   * [insights()], clientAccess: "public" })` over HTTP: in process, or in the
-   * runtime the provider deploys to.
+   * Serves the handlers of `createHotUpdater({ database, storage, plugins,
+   * clientAccess: "public" })` over HTTP, in process or in the runtime the
+   * provider deploys to, with the plugins whose suites `plugins` lists.
    */
   readonly createHttpClient: (options: {
     readonly database: TDatabase;
-    readonly storage: readonly StoragePlugin[];
+    readonly storage: readonly StorageAdapter[];
   }) => HttpTestServer | Promise<HttpTestServer>;
-  /**
-   * The Insights plugin's model on the database, to run the Insights report
-   * contract on its tables: `(database) => createInsightsModel(
-   * createDatabasePluginApis(database, [insights()]).insights)`.
-   */
-  readonly createInsightsModel?: (database: TDatabase) => InsightsModel;
+  /** The suites of the server plugins the provider opts in to test. */
+  readonly plugins?: readonly DatabasePluginTestSuite<TDatabase>[];
 };
 /**
  * A provider's database under Hot Updater's server: core's operations, the
- * Release Catalog contract, bundles, and Insights, all through HTTP, on the
- * tables the provider's tooling creates; with `createInsightsModel`, also the
- * Insights report contract in process.
+ * Release Catalog contract, and bundles, all through HTTP, on the tables the
+ * provider's tooling creates, then each opted-in plugin's suite.
  */
 declare const setupDatabaseTestSuite: <TDatabase extends EngineDatabase>(options: DatabaseTestSuiteOptions<TDatabase>) => void;
 //#endregion
@@ -167,9 +157,17 @@ interface DatabaseAdapterConformanceOptions {
   readonly maxOps?: number;
   /** Concurrent writers in the contention cases (default 32). */
   readonly writers?: number;
+  /**
+   * How the backend deletes rows past a table's retention: `prune` (the
+   * default) through the adapter, or `ttl`, natively on every item, with no
+   * `prune` on the adapter.
+   */
+  readonly retention?: "prune" | "ttl";
 }
 declare const conformanceItems: PhysicalTable;
 declare const conformanceCounters: PhysicalTable;
+/** Rows expire 1,000 ms after `at`; a null `at` never expires. */
+declare const conformanceExpiring: PhysicalTable;
 /**
  * The storage-adapter conformance contract (PRD S3 and S4 cases). Every
  * adapter runs it through `verifyAdapter`, which also checks each read and
@@ -177,9 +175,38 @@ declare const conformanceCounters: PhysicalTable;
  */
 declare const setupDatabaseAdapterConformanceSuite: (options: DatabaseAdapterConformanceOptions) => void;
 //#endregion
+//#region src/setupStorageAdapterTestSuite.d.ts
+interface StorageAdapterTestSuiteOptions {
+  readonly name: string;
+  /**
+   * Returns the adapter over an empty bucket or base path. Every case creates
+   * its own and calls `cleanup` after it.
+   */
+  readonly createStorage: () => Promise<{
+    readonly storage: StorageAdapter;
+    /**
+     * The base path the adapter stores keys below. With it, every URI `put`
+     * returns must have the key `<basePath>/<key>`.
+     */
+    readonly basePath?: string;
+    readonly cleanup?: () => Promise<void>;
+  }>;
+  /**
+   * The operations the adapter implements. The suite requires them, with
+   * `put` and `get`, and skips the cases of every other operation. Without
+   * it, the suite skips the cases of the operations the adapter lacks.
+   */
+  readonly operations?: readonly StorageOperation[];
+}
+/**
+ * The storage adapter contract that deploy, patch, the Console, the server,
+ * and `storage prune` rely on. Every official storage adapter runs it.
+ */
+declare const setupStorageAdapterTestSuite: (options: StorageAdapterTestSuiteOptions) => void;
+//#endregion
 //#region src/sqlRowsExamined.d.ts
 /**
- * Rows a SQL database examined for the reads a storage adapter made: what
+ * Rows a SQL database examined for the reads a database adapter made: what
  * read-budget suites compare with the rows the adapter read.
  */
 interface RowsExamined {
@@ -239,70 +266,17 @@ declare const mysqlRowsExamined: (query: SqlQuery) => {
 };
 //#endregion
 //#region src/setupReadBudgetTestSuite.d.ts
-/** Core's API with the client routes' reads, which the public API leaves out. */
-type ReadBudgetCore = HotUpdaterCoreApi & {
-  getReleaseCatalog(input: {
-    readonly strategy: "APP_VERSION";
-    readonly platform: "ios" | "android";
-    readonly channelKey: string;
-    readonly appVersion: string;
-  }): Promise<ReleaseCatalog | null>;
-  getArtifactInfo(targetBundleId: string, currentBundleId: string, artifactProtocolVersion: 1): Promise<ArtifactInfo | null>;
-  latestReleaseId(scopeKey: string): Promise<string | null>;
-};
-/** How core reads bundle manifests and resolves file URLs. */
-interface ReadBudgetStorage {
-  readonly readStorageText?: (storageUri: string) => Promise<string | null>;
-  readonly resolveFileUrl: (storageUri: string | null) => Promise<string | null>;
-}
-/** What `createMeasuredDatabase` returns: core and the plugins on one engine in verify mode. */
-interface ReadBudgetDatabase {
-  readonly core: ReadBudgetCore;
-  readonly api: Readonly<Record<string, unknown>>;
-  readonly clientAuth?: {
-    authenticate(headers: Headers): Promise<boolean>;
-  };
-  measureReads<T>(read: () => Promise<T>): Promise<{
-    readonly result: T;
-    readonly adapter: DatabaseReadCount;
-    readonly engine: {
-      readonly calls: number;
-      readonly rows: number;
-    };
-  }>;
-}
-/**
- * What the suite takes from `@hot-updater/server`; pass those exports, which
- * keeps test-utils free of a dependency on the server.
- */
-interface ReadBudgetServer {
-  /** `createMeasuredDatabase` from `@hot-updater/server/db`. */
-  createMeasuredDatabase(adapter: DatabaseAdapter, plugins: readonly unknown[], options: {
-    readonly now: () => number;
-    readonly storage: ReadBudgetStorage;
-  }): ReadBudgetDatabase;
-  /** `builtInSchema` from `@hot-updater/server/database`: the tables to create. */
-  readonly builtInSchema: {
-    readonly tables: readonly PhysicalTable[];
-  };
-  /** `[insights(), apiKeys()]`, the built-in plugins whose reads have budgets. */
-  readonly plugins: readonly unknown[];
-  /** `targetBaseCandidateKey` from `@hot-updater/server/db`. */
-  targetBaseCandidateKey(target: {
-    readonly channel: string;
-    readonly platform: "ios" | "android";
-    readonly fingerprintHash: string | null;
-    readonly appVersion: string | null;
-  }): string | null;
-}
 interface ReadBudgetAdapterContext {
+  /**
+   * Core's tables, those of the plugins the suite measures, and the settings
+   * table, where the retention passes keep their lease.
+   */
   readonly tables: readonly PhysicalTable[];
   /** Test-only: the adapter must fetch at most this many rows per native page. */
   readonly nativePageSize: number;
 }
 interface ReadBudgetSuiteOptions {
   readonly name: string;
-  readonly server: ReadBudgetServer;
   /** Returns an adapter over freshly created, empty tables. */
   readonly createAdapter: (context: ReadBudgetAdapterContext) => Promise<{
     readonly adapter: DatabaseAdapter;
@@ -317,14 +291,33 @@ interface ReadBudgetSuiteOptions {
   }>;
 }
 /**
- * The read-budget suite (PRD S4) on one backend: core and the built-in
- * plugins in verify mode over the backend's adapter, native pages capped at
- * two rows. Every API in the read-budget list reads exactly its budget at the
- * adapter and at the engine; with `examined`, the database examines no more
- * rows than the adapter read, within the backend's native multipliers.
+ * The read-budget suite (PRD S4) on one backend: core and the server's
+ * built-in plugins on `createMeasuredDatabase` over the backend's adapter,
+ * native pages capped at two rows. Every API in the read-budget list reads
+ * exactly its budget at the adapter and at the engine; with `examined`, the
+ * database examines no more rows than the adapter read, within the backend's
+ * native multipliers. It loads `@hot-updater/server`, an optional peer.
  */
 declare const setupReadBudgetTestSuite: (options: ReadBudgetSuiteOptions) => void;
 //#endregion
+//#region src/setupAggregateBatchingTestSuite.d.ts
+interface AggregateBatchingSuiteOptions {
+  readonly name: string;
+  /** Returns an adapter over an empty store; each case calls it once. */
+  readonly createAdapter: () => Promise<{
+    readonly adapter: DatabaseAdapter;
+    readonly cleanup?: () => Promise<void>;
+  }>;
+  /** Aggregate rows one transaction changes in the too-large case: more than one write takes. */
+  readonly oversizedRows: number;
+}
+/**
+ * Aggregates declared `batched` on a key-value store: log rows the store
+ * writes with each transaction and a compaction merges once, and a memory
+ * buffer, read back exactly as transactional writes read.
+ */
+declare const setupAggregateBatchingTestSuite: ({ name, createAdapter, oversizedRows }: AggregateBatchingSuiteOptions) => void;
+//#endregion
 //#region src/runContentionHarness.d.ts
 /** Delays every adapter call by `ms`, like a round trip to a remote database. */
 declare const withAdapterLatency: (adapter: DatabaseAdapter, ms: number) => DatabaseAdapter;
@@ -351,75 +344,160 @@ interface ContentionReport {
  */
 declare const runContentionHarness: (options: ContentionOptions) => Promise<ContentionReport>;
 //#endregion
-//#region src/createPluginTestHarness.d.ts
-interface HarnessModule {
-  readonly id: string;
-  readonly schema: object;
-  readonly namespace?: string;
+//#region src/createMeasuredDatabase.d.ts
+/** How core reads bundle manifests and resolves the file URLs of `storage://` URIs. */
+interface MeasuredDatabaseStorage {
+  readonly readStorageText?: (storageUri: string) => Promise<string | null>;
+  readonly resolveFileUrl: (storageUri: string) => Promise<string>;
 }
-interface HarnessEngine {
-  database(module: HarnessModule): unknown;
-  measureReads<T>(read: () => Promise<T>): Promise<{
-    readonly result: T;
-    readonly adapter: DatabaseReadCount;
-    readonly engine: {
-      readonly calls: number;
-      readonly rows: number;
-    };
-  }>;
+interface MeasuredDatabaseOptions {
+  /**
+   * The plugins' clock, which they read through `ctx.now`. Core's
+   * timestamps and the retention passes run on `Date.now`.
+   */
+  readonly now?: () => number;
+  /**
+   * The storage of `storage://` URIs, for reads that resolve them, such as
+   * artifact resolution; without it those reads fail.
+   */
+  readonly storage?: MeasuredDatabaseStorage;
+}
+/** Core and the plugins' APIs on `createHotUpdater`, with the database's read meter. */
+interface MeasuredDatabase<TApi = Readonly<Record<string, unknown>>> {
+  readonly core: HotUpdaterCoreApi;
+  readonly api: TApi;
+  /** The client-route policy, when a plugin provides one. */
+  readonly clientAuth?: ClientAuth;
+  /** Runs `read` and reports what it read at the adapter and at the engine. */
+  measureReads<T>(read: () => Promise<T>): Promise<ReadMeasurement<T>>;
 }
 /**
- * What the harness takes from `@hot-updater/server/database`; pass that
- * module, which keeps test-utils free of a dependency on the server.
+ * Core and the plugins over `adapter` as `createHotUpdater` runs them: what
+ * read-budget suites measure. The database is `meterReads` over
+ * `verifyAdapter(adapter)`, so every adapter call is checked against the
+ * contract and `measureReads` reports each call's reads; the adapter runs
+ * as given, without the schema fence. It loads `@hot-updater/server`, an
+ * optional peer, when called.
  */
-interface PluginTestEngine {
-  resolveSchema(modules: readonly HarnessModule[]): {
-    readonly tables: readonly PhysicalTable[];
-  };
-  createDatabaseEngine(options: {
-    readonly adapter: DatabaseAdapter;
-    readonly schema: never;
-    readonly verify?: boolean;
-  }): HarnessEngine;
-}
+declare const createMeasuredDatabase: <const TPlugins extends readonly AnyHotUpdaterPlugin[]>(adapter: DatabaseAdapter, plugins: TPlugins, options?: MeasuredDatabaseOptions) => Promise<MeasuredDatabase<PluginApis<TPlugins>>>;
+//#endregion
+//#region src/createPluginTestHarness.d.ts
 interface HarnessPlugin {
   readonly id: string;
-  readonly schema: object;
+  readonly schemaVersion: string;
+  readonly schema: ModuleSchema;
+  /** `false` keeps the declared table names, as `createHotUpdater` does. */
+  readonly namespace?: false;
   init(context: never): {
     readonly api: unknown;
   };
 }
 interface PluginTestHarnessOptions {
-  /** `import * as engine from "@hot-updater/server/database"`. */
-  readonly engine: PluginTestEngine;
   /** Defaults to a fresh memory adapter. */
   readonly adapter?: DatabaseAdapter;
   /** The plugin's clock; `setNow` changes it later. */
   readonly now?: () => number;
 }
 /**
- * Runs one plugin the way `createHotUpdater` does, on a memory adapter in
- * verify mode, so tests can call its API and measure what each call reads.
+ * Runs one plugin on `createEngine`, the storage engine `createHotUpdater`
+ * runs its plugins on, so tests can call its API and measure what each call
+ * reads. Every adapter call is checked against the adapter contract
+ * (`verifyAdapter`), and `ctx.core` is empty: core's reads need a server.
+ * The engine gets the adapter without `prune`, as a store that expires rows
+ * itself would give it, so no retention pass adds to what a call reads and
+ * writes; rows stay past their retention.
  */
-declare const createPluginTestHarness: <TPlugin extends HarnessPlugin>(plugin: TPlugin, options: PluginTestHarnessOptions) => Promise<{
+declare const createPluginTestHarness: <TPlugin extends HarnessPlugin>(plugin: TPlugin, options?: PluginTestHarnessOptions) => Promise<{
   api: ReturnType<TPlugin["init"]>["api"];
   instance: ReturnType<TPlugin["init"]>;
-  /** The plugin's own database handle; cast it to its `HotUpdaterDatabase` type. */
-  db: unknown;
+  /** The plugin's own database handle. */
+  db: HotUpdaterDatabase<TPlugin["schema"]>;
   adapter: DatabaseAdapter;
-  tables: readonly PhysicalTable[];
-  /** Reads at both boundaries while `read` runs. */
-  measureReads: <T>(read: () => Promise<T>) => Promise<{
-    readonly result: T;
-    readonly adapter: DatabaseReadCount;
-    readonly engine: {
-      readonly calls: number;
-      readonly rows: number;
-    };
-  }>;
-  setNow: (now: () => number) => void;
+  /** The plugin's physical tables. */
+  tables: import("@hot-updater/plugin-core").PhysicalTable[];
+  /** Reads at the adapter and at the engine while `read` runs. */
+  measureReads: <T>(read: () => Promise<T>) => Promise<import("@hot-updater/plugin-core").ReadMeasurement<T>>;
+  setNow: (next: () => number) => void;
+}>;
+//#endregion
+//#region src/databaseTestFixtures.d.ts
+declare const createChannelRowFixture: (name?: string) => ChannelRow;
+declare const createBundleRowFixture: (suffix: string, _channel?: string) => BundleRow;
+declare const createBundlePatchRowFixture: (suffix: string, bundleId: string, baseBundleId: string, orderIndex?: number) => BundlePatchRow;
+declare const createReleaseRowFixture: (suffix: string, bundle: BundleRow, channel: ChannelRow) => ReleaseRow;
+declare const createBundleFixture: (suffix: string, _channel?: string) => Bundle;
+//#endregion
+//#region src/storeBundles.d.ts
+/**
+ * Stores bundles and their patches with no release, as a database holds an
+ * artifact that no release uses. `deploy` always adds a release, and
+ * deleting a bundle's last release deletes the bundle, so tests store such
+ * bundles through the engine. A patch's base comes before it in `bundles`.
+ */
+declare const storeBundles: (database: EngineDatabase, bundles: readonly Bundle[]) => Promise<void>;
+//#endregion
+//#region src/insights/expectInsightsIndex.d.ts
+/** Allow committed secondary indexes to catch up; query failures still fail. */
+declare const expectInsightsIndex: <T>(query: () => Promise<T>, expected: T) => Promise<void>;
+//#endregion
+//#region src/insights/fixtures.d.ts
+/** An applied update from install `suffix`, received at `receivedAtMs`. */
+declare const createBundleEventRowFixture: (suffix: string, receivedAtMs: number) => Extract<BundleEventRow, {
+  type: "UPDATE_APPLIED" | "RECOVERED";
 }>;
 //#endregion
+//#region src/insights/setupInsightsHttpTestSuite.d.ts
+/**
+ * The Insights plugin's routes on a database: a client reports an event, and
+ * the admin routes read it back. The server must run `insights()`.
+ */
+declare const setupInsightsHttpTestSuite: (options: {
+  readonly getClient: () => HttpTestClient;
+}) => void;
+//#endregion
+//#region src/insights/setupInsightsModelTestSuite.d.ts
+/**
+ * The Insights report contract on one database: pass the Insights plugin's
+ * model over it, `createInsightsModel(createHotUpdater({ database, plugins:
+ * [insights()], clientAccess: "public" }).api.insights)`, as `createDatabase`.
+ */
+declare const setupInsightsModelTestSuite: (lifecycle: DatabaseTestLifecycle<InsightsModel>) => void;
+//#endregion
+//#region src/insights/index.d.ts
+/**
+ * The Insights plugin's tests, for `setupDatabaseTestSuite`'s `plugins`: its
+ * HTTP routes on the provider's server, which must run `insights()`, and
+ * with `createModel` its report contract on the provider's database, such as
+ * `(database) => createInsightsModel(createHotUpdater({ database, plugins:
+ * [insights()], clientAccess: "public" }).api.insights)`.
+ */
+declare const insightsTestSuite: <TDatabase = EngineDatabase>(options?: {
+  readonly createModel?: (database: TDatabase) => InsightsModel;
+}) => {
+  name: string;
+  register: (context: {
+    readonly getClient: () => HttpTestClient;
+    readonly getDatabase: () => TDatabase;
+  }) => void;
+};
+//#endregion
+//#region src/kvTestStore.d.ts
+interface MemoryKeyValueStoreOptions {
+  /** Test-only: the most items one `query` page returns. */
+  readonly nativePageSize?: number;
+  readonly limits?: KeyValueStore["limits"];
+}
+/**
+ * An in-memory key-value store that behaves like DynamoDB where the adapter
+ * can tell: a write checks every condition against the state before it,
+ * refuses two ops on one item, and applies all ops or none.
+ */
+declare const createMemoryKeyValueStore: (options?: MemoryKeyValueStoreOptions) => KeyValueStore & {
+  readonly items: () => number;
+  /** Each item's expiry, as a store's native TTL would hold it, by `[pk, sk]` JSON. */
+  readonly expiries: () => ReadonlyMap<string, number>;
+};
+//#endregion
 //#region src/setupReleaseCatalogTestSuite.d.ts
 /**
  * Server conformance through HTTP only, on admin API protocol 2. The caller
@@ -447,6 +525,6 @@ declare const releaseCatalogArtifact: (bundle: BundleRow) => ArtifactInfo;
 /** Install these storage objects in the test server, independently of its DB. */
 declare const RELEASE_CATALOG_STORAGE_FIXTURES: Readonly<Record<string, string>>;
 /** Storage boundary shared by provider and separately spawned server tests. */
-declare const createReleaseCatalogTestStorage: () => StoragePlugin;
+declare const createReleaseCatalogTestStorage: () => StorageAdapter;
 //#endregion
-export { AdminApiTestClient, ContentionOptions, ContentionReport, DatabaseAdapterConformanceContext, DatabaseAdapterConformanceOptions, type DatabaseTestLifecycle, DatabaseTestSuiteOptions, HttpTestClient, HttpTestHandlers, HttpTestRequest, HttpTestRequestInit, HttpTestServer, PluginTestEngine, PluginTestHarnessOptions, RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, ReadBudgetAdapterContext, ReadBudgetDatabase, ReadBudgetServer, ReadBudgetStorage, ReadBudgetSuiteOptions, RowsExamined, SqlExecutorLike, SqlQuery, SqlStatementLike, conformanceCounters, conformanceItems, createAdminApiTestClient, createHandlerHttpTestClient, createHttpTestClient, createPluginTestHarness, createReleaseCatalogTestStorage, jsonRequest, mysqlRowsExamined, postgresRowsExamined, releaseCatalogArtifact, releaseCatalogDownloadUrl, runContentionHarness, setupBundleMethodsTestSuite, setupCoreAdminTestSuite, setupDatabaseAdapterConformanceSuite, setupDatabaseTestSuite, setupInsightsHttpTestSuite, setupInsightsModelTestSuite, setupReadBudgetTestSuite, setupReleaseCatalogTestSuite, setupSemverSatisfiesTestSuite, startHttpTestServer, toDeployBundle, withAdapterLatency };
+export { AdminApiTestClient, AggregateBatchingSuiteOptions, ContentionOptions, ContentionReport, DatabaseAdapterConformanceContext, DatabaseAdapterConformanceOptions, DatabasePluginTestSuite, type DatabaseTestLifecycle, DatabaseTestSuiteOptions, HttpTestClient, HttpTestHandlers, HttpTestRequest, HttpTestRequestInit, HttpTestServer, MeasuredDatabase, MeasuredDatabaseOptions, MeasuredDatabaseStorage, MemoryKeyValueStoreOptions, PluginTestHarnessOptions, RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, ReadBudgetAdapterContext, ReadBudgetSuiteOptions, RowsExamined, SqlExecutorLike, SqlQuery, SqlStatementLike, StorageAdapterTestSuiteOptions, conformanceCounters, conformanceExpiring, conformanceItems, createAdminApiTestClient, createBundleEventRowFixture, createBundleFixture, createBundlePatchRowFixture, createBundleRowFixture, createChannelRowFixture, createHandlerHttpTestClient, createHttpTestClient, createMeasuredDatabase, createMemoryKeyValueStore, createPluginTestHarness, createReleaseCatalogTestStorage, createReleaseRowFixture, expectInsightsIndex, insightsTestSuite, jsonRequest, mysqlRowsExamined, postgresRowsExamined, releaseCatalogArtifact, releaseCatalogDownloadUrl, runContentionHarness, setupAggregateBatchingTestSuite, setupBundleMethodsTestSuite, setupCoreAdminTestSuite, setupDatabaseAdapterConformanceSuite, setupDatabaseTestSuite, setupInsightsHttpTestSuite, setupInsightsModelTestSuite, setupReadBudgetTestSuite, setupReleaseCatalogTestSuite, setupSemverSatisfiesTestSuite, setupStorageAdapterTestSuite, startHttpTestServer, storeBundles, toDeployBundle, withAdapterLatency };