@systemfsoftware/xstate-test 0.0.0-stage → 2.0.0-beta.2

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { $ as TestReference, A as ParallelPropertyCommandsResult, B as TestActorOutcome, C as formatTestStatistics, D as LinearizabilityOptions, E as LinearizabilityModel, G as TestEventGenerators, H as TestCampaignError, I as PropertyScenarioRunner, J as TestFailureStore, K as TestFailureExtras, L as PropertyTargetObservation, M as runParallelPropertyCommands, N as ModelTestFailure, O as LinearizabilityResult, P as PropertyExecutionConfig, Q as TestMode, S as formatTestCoverageJUnit, T as LinearizabilityEntry, U as TestCommand, V as TestAdapter, W as TestEventDescriptor, X as TestInvariant, Y as TestFixture, Z as TestInvariantContext, _ as TestCoverageJSON, _t as TestCoverage, at as TestStopCondition, b as formatTestCoverage, bt as AnyTestEventDescriptor, c as TestSuiteReplayResult, ct as TestSutSendContext, d as replayTestSuite, dt as TestTrace, et as TestReferenceSession, f as replayTestSuiteFixture, ft as replayTest, g as FormatTestCoverageOptions, h as FormatTestCoverageJUnitOptions, i as DescribeTestSuiteOptions, it as TestStep, j as checkLinearizable, k as ParallelPropertyCommandsOptions, l as describeTestSuite, lt as TestSutSession, m as FormatTestCoverageHTMLOptions, nt as TestStateAssertion, o as ReplayTestSuiteOptions, ot as TestSut, p as serializeTestSuite, pt as serializeTestTrace, q as TestFailureFormatOptions, r as TestPathsResult, rt as TestStateAssertions, s as TestSuite, st as TestSutContext, t as TestPathRunResult, tt as TestReplayMetadata, u as parseTestSuite, ut as TestTemporal, v as TestCoverageThresholds, vt as TestCoverageDimension, w as testCoverageToJSON, x as formatTestCoverageHTML, xt as TestPickDescriptor, y as assertTestCoverage, yt as TestExplorationBounds, z as ReplayNotReproducedError } from "./index-CSbyUxJr.js";
+import { a as extractReplayPath, i as FastCheckSchedulerReport, n as FastCheckGeneratorKind, o as fastCheckAdapter, r as FastCheckSchedulerOptions, t as FastCheckAdapterOptions } from "./adapter-Dd4Go0U3.js";
+import { a as propertyTest, c as FailuresOption, i as generateTestSuite, l as createFailureDatabase, n as FastCheckPropertyTestOptions, o as testPaths, r as FastCheckTestPathsOptions, s as FailureDatabaseOptions, t as FastCheckGenerateTestSuiteOptions } from "./propertyTest-BHnBV8ax.js";
+import { EventsFromSchemasOptions, SchemaConverter, arbitraryFromSchema, eventsFromSchemas, mergeEventGenerators } from "./schema.js";
+import { EventObject, Snapshot } from "@systemfsoftware/xstate";
+import * as fc from "fast-check";
+/**
+ * An event case whose payload refers to something in the current snapshot,
+ * such as an item that is already in a cart. `select` lists the candidates;
+ * the case is inapplicable when it returns none. `toPayload` turns the picked
+ * candidate into the event payload, and defaults to using it as the payload.
+ *
+ * The index into the candidates is generated with `fc.nat()`, so a failing
+ * run shrinks towards the first candidate. The snapshot type is inferred from
+ * the `events` map it is assigned to.
+ *
+ * ```ts
+ * events: {
+ *   REMOVE: pick(
+ *     (snapshot) => Object.keys(snapshot.context.items),
+ *     (sku) => ({ sku })
+ *   )
+ * }
+ * ```
+ *
+ * @experimental
+ */
+export declare function pick<TSnapshot extends Snapshot<unknown>, TPayload>(select: (snapshot: TSnapshot) => readonly TPayload[]): TestPickDescriptor<fc.Arbitrary<number>, TSnapshot, TPayload>;
+export declare function pick<TSnapshot extends Snapshot<unknown>, TItem, TPayload>(select: (snapshot: TSnapshot) => readonly TItem[], toPayload: (item: TItem, snapshot: TSnapshot) => TPayload): TestPickDescriptor<fc.Arbitrary<number>, TSnapshot, TPayload>;
+/**
+ * The scheduler fast-check generated for the run currently in flight, or
+ * `undefined` when the adapter was not configured with `scheduler`.
+ *
+ * Only defined while a scheduled run is executing, which is exactly when a
+ * system under test is created and driven.
+ *
+ * @experimental
+ */
+export declare function getCurrentScheduler(): fc.Scheduler | undefined;
+/**
+ * Wraps a {@link TestSut} so its asynchronous boundaries (`send`, `read`,
+ * `settle`, `advance`) resolve in an order chosen by the run's fast-check
+ * scheduler instead of in plain microtask order.
+ *
+ * The wrapper binds to {@link getCurrentScheduler} when the session is created,
+ * so it is inert unless the adapter was configured with `scheduler`.
+ *
+ * @experimental
+ */
+export declare function withScheduledSut<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject>(sut: TestSut<TSnapshot, TEvent>): TestSut<TSnapshot, TEvent>;
+/**
+ * Wraps a reference oracle the way {@link withScheduledSut} wraps a system
+ * under test: its `transition` and `read` calls resolve under the run's
+ * scheduler.
+ *
+ * @experimental
+ */
+export declare function withScheduledReference<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject>(reference: TestReference<TSnapshot, TEvent>): TestReference<TSnapshot, TEvent>;
+export { type AnyTestEventDescriptor, type DescribeTestSuiteOptions, type EventsFromSchemasOptions, type FailureDatabaseOptions, type FailuresOption, type FastCheckAdapterOptions, type FastCheckGenerateTestSuiteOptions, type FastCheckGeneratorKind, type FastCheckPropertyTestOptions, type FastCheckSchedulerOptions, type FastCheckSchedulerReport, type FastCheckTestPathsOptions, type FormatTestCoverageHTMLOptions, type FormatTestCoverageJUnitOptions, type FormatTestCoverageOptions, type LinearizabilityEntry, type LinearizabilityModel, type LinearizabilityOptions, type LinearizabilityResult, ModelTestFailure, type ParallelPropertyCommandsOptions, type ParallelPropertyCommandsResult, type PropertyExecutionConfig, PropertyScenarioRunner, type PropertyTargetObservation, ReplayNotReproducedError, type ReplayTestSuiteOptions, type SchemaConverter, type TestActorOutcome, type TestAdapter, TestCampaignError, type TestCommand, type TestCoverage, type TestCoverageDimension, type TestCoverageJSON, type TestCoverageThresholds, type TestEventDescriptor, type TestEventGenerators, type TestExplorationBounds, type TestFailureExtras, type TestFailureFormatOptions, type TestFailureStore, type TestFixture, type TestInvariant, type TestInvariantContext, type TestMode, type TestPathRunResult, type TestPathsResult, type TestPickDescriptor, type TestReference, type TestReferenceSession, type TestReplayMetadata, type TestStateAssertion, type TestStateAssertions, type TestStep, type TestStopCondition, type TestSuite, type TestSuiteReplayResult, type TestSut, type TestSutContext, type TestSutSendContext, type TestSutSession, type TestTemporal, type TestTrace, arbitraryFromSchema, assertTestCoverage, checkLinearizable, createFailureDatabase, describeTestSuite, eventsFromSchemas, extractReplayPath, fastCheckAdapter, formatTestCoverage, formatTestCoverageHTML, formatTestCoverageJUnit, formatTestStatistics, generateTestSuite, mergeEventGenerators, parseTestSuite, propertyTest, replayTest, replayTestSuite, replayTestSuiteFixture, runParallelPropertyCommands, serializeTestSuite, serializeTestTrace, testCoverageToJSON, testPaths };

package/dist/index.mjs

@@ -0,0 +1,178 @@
+import { D as formatTestStatistics, E as formatTestCoverageJUnit, O as testCoverageToJSON, S as assertTestCoverage, T as formatTestCoverageHTML, _ as ReplayNotReproducedError, a as extractReplayPath, b as replayTest, c as withScheduledReference, d as parseTestSuite, f as replayTestSuite, g as PropertyScenarioRunner, h as ModelTestFailure, i as createFailureDatabase, k as createPickDescriptor, l as withScheduledSut, m as serializeTestSuite, n as propertyTest, o as fastCheckAdapter, p as replayTestSuiteFixture, r as testPaths, s as getCurrentScheduler, t as generateTestSuite, u as describeTestSuite, v as TestCampaignError, w as formatTestCoverage, x as serializeTestTrace, y as defaultEquivalent } from "./propertyTest-5bO0RsUu.mjs";
+import { t as ensuringFinalizerWins } from "./finalizerError-DOptAIDs.mjs";
+import { arbitraryFromSchema, eventsFromSchemas, mergeEventGenerators } from "./schema.mjs";
+import { dual } from "effect/Function";
+import { initialTransition, transition } from "@systemfsoftware/xstate";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as fc from "fast-check";
+// src/engine/propertyLinearizability.ts
+/**
+* Awaits `value` as an Effect. A value and a thenable are both accepted, and a
+* rejection stays the same error object when the effect is run.
+*/
+const awaited = (value) => Effect.promise(() => Promise.resolve(value));
+const DEFAULT_MAXIMUM_EXPLORED = 1e5;
+function defaultSerializeState(state) {
+	try {
+		return JSON.stringify(state);
+	} catch {
+		return;
+	}
+}
+/** Identity of a model snapshot: everything a transition can depend on. */
+function serializeSnapshotIdentity(state) {
+	if (state === null || typeof state !== "object") return defaultSerializeState(state);
+	const snapshot = state;
+	return defaultSerializeState({
+		value: snapshot.value,
+		context: snapshot.context,
+		status: snapshot.status
+	});
+}
+/**
+* Decides whether a concurrent `history` is linearizable against a sequential
+* `model`: whether some total order of the operations, consistent with the
+* real-time order of non-overlapping operations, produces exactly the observed
+* responses.
+*
+* The search is the Wing–Gong just-in-time linearization: depth-first over the
+* operations that could come next (those starting no later than the earliest
+* end time still outstanding), backtracking whenever a response disagrees with
+* the model, and memoizing `(state, completed set)` pairs so equivalent
+* branches are explored once.
+* @experimental
+*/
+const checkLinearizable = dual((args) => args.length >= 3 || Array.isArray(args[0]), function checkLinearizable(history, model, options = {}) {
+	const maxExplored = options.maxExplored ?? DEFAULT_MAXIMUM_EXPLORED;
+	const equalResponse = model.equalResponse ?? defaultEquivalent;
+	const serializeState = model.serializeState ?? defaultSerializeState;
+	const entries = history.slice();
+	const remaining = entries.map(() => true);
+	const witness = [];
+	const seen = /* @__PURE__ */ new Set();
+	let explored = 0;
+	let truncated = false;
+	function memoKey(state) {
+		const serializedState = serializeState(state);
+		if (serializedState === void 0) return;
+		return `${entries.map((_, index) => remaining[index] === true ? "0" : "1").join("")}|${serializedState}`;
+	}
+	function search(state) {
+		if (remaining.every((isRemaining) => !isRemaining)) return true;
+		const key = memoKey(state);
+		if (key !== void 0) {
+			if (seen.has(key)) return false;
+			seen.add(key);
+		}
+		let earliestEnd = Infinity;
+		for (let index = 0; index < entries.length; index++) {
+			const entry = entries[index];
+			if (entry === void 0) continue;
+			if (remaining[index] === true && entry.end < earliestEnd) earliestEnd = entry.end;
+		}
+		for (let index = 0; index < entries.length; index++) {
+			const entry = entries[index];
+			if (entry === void 0) continue;
+			if (remaining[index] !== true || entry.start > earliestEnd) continue;
+			if (explored >= maxExplored) {
+				truncated = true;
+				return false;
+			}
+			explored++;
+			const applied = model.apply(state, entry.invocation);
+			if (!equalResponse(applied.response, entry.response)) continue;
+			remaining[index] = false;
+			witness.push(entry);
+			if (search(applied.state)) return true;
+			witness.pop();
+			remaining[index] = true;
+			if (truncated) return false;
+		}
+		return false;
+	}
+	const linearizable = search(model.initial);
+	return {
+		linearizable,
+		witness: linearizable ? witness.slice() : void 0,
+		explored,
+		truncated
+	};
+});
+/**
+* Runs a sequential prefix and then N branches concurrently against a system
+* under test, records the resulting concurrent history, and checks it against
+* the machine's own pure `transition()` as the sequential specification.
+*
+* This is the analogue of `parallel_commands` in QuickCheck State Machine and
+* PropEr: the prefix puts the system in an interesting state, the branches
+* race, and linearizability decides whether the observed responses could have
+* come from any sequential interleaving.
+* @experimental
+*/
+const runParallelPropertyCommands = dual(2, function runParallelPropertyCommands(logic, options) {
+	return Effect.runPromise(Effect.gen(function* () {
+		const projectSut = options.sut.projectSut ?? ((observed) => observed);
+		const session = yield* awaited(options.sut.create({
+			logic,
+			input: options.input,
+			snapshot: void 0,
+			label: () => {},
+			classify: () => {},
+			target: () => {}
+		}));
+		const clock = yield* Ref.make(0);
+		const history = [];
+		const invoke = (event) => Effect.gen(function* () {
+			const sent = yield* awaited(session.send(event));
+			if (sent !== void 0) return projectSut(sent);
+			return projectSut(session.read !== void 0 ? yield* awaited(session.read()) : void 0);
+		});
+		const nextClock = Ref.getAndUpdate(clock, (value) => value + 1);
+		const run = Effect.gen(function* () {
+			for (const event of options.prefix ?? []) yield* invoke(event);
+			yield* Effect.forEach(options.branches, (branch, branchIndex) => Effect.gen(function* () {
+				for (const [eventIndex, event] of branch.entries()) {
+					if (event === void 0) continue;
+					const start = yield* nextClock;
+					const response = yield* invoke(event);
+					const end = yield* nextClock;
+					history.push({
+						id: `${branchIndex}:${eventIndex}`,
+						actor: `branch-${branchIndex}`,
+						invocation: event,
+						response,
+						start,
+						end
+					});
+				}
+			}), {
+				concurrency: "unbounded",
+				discard: true
+			});
+		});
+		yield* ensuringFinalizerWins(run, Effect.promise(() => Promise.resolve(session.dispose?.())));
+		const initialModelState = initialTransition(logic, options.input)[0];
+		const modelState = (options.prefix ?? []).reduce((state, event) => transition(logic, state, event)[0], initialModelState);
+		return {
+			...checkLinearizable(history, {
+				initial: modelState,
+				apply: (state, event) => {
+					const [next] = transition(logic, state, event);
+					return {
+						state: next,
+						response: options.sut.projectModel(next)
+					};
+				},
+				equalResponse: options.equalResponse,
+				serializeState: (state) => options.serializeState !== void 0 ? options.serializeState(state) : serializeSnapshotIdentity(state)
+			}, { maxExplored: options.maxExplored }),
+			history
+		};
+	}));
+});
+// src/pick.ts
+function pick(select, toPayload) {
+	return createPickDescriptor(fc.nat(), select, toPayload);
+}
+export { ModelTestFailure, PropertyScenarioRunner, ReplayNotReproducedError, TestCampaignError, arbitraryFromSchema, assertTestCoverage, checkLinearizable, createFailureDatabase, describeTestSuite, eventsFromSchemas, extractReplayPath, fastCheckAdapter, formatTestCoverage, formatTestCoverageHTML, formatTestCoverageJUnit, formatTestStatistics, generateTestSuite, getCurrentScheduler, mergeEventGenerators, parseTestSuite, pick, propertyTest, replayTest, replayTestSuite, replayTestSuiteFixture, runParallelPropertyCommands, serializeTestSuite, serializeTestTrace, testCoverageToJSON, testPaths, withScheduledReference, withScheduledSut };

package/dist/playwright.d.ts

@@ -0,0 +1,204 @@
+import { ot as TestSut } from "./index-CSbyUxJr.js";
+import { EventObject, Snapshot } from "@systemfsoftware/xstate";
+/**
+ * The subset of the Playwright `Page` API this package uses.
+ *
+ * A real `Page` from `playwright` or `@playwright/test` is assignable to this
+ * type, so no Playwright import is needed at runtime or at type-check time.
+ * Everything is optional because only the parts your configuration reaches for
+ * are used.
+ *
+ * @experimental
+ */
+export interface PlaywrightPage {
+  readonly waitForLoadState?: (state?: any, options?: any) => Promise<void>;
+  readonly screenshot?: (options?: any) => Promise<any>;
+  readonly route?: (url: any, handler: any, options?: any) => Promise<unknown>;
+  readonly unroute?: (url: any, handler?: any) => Promise<void>;
+  readonly clock?: {
+    readonly runFor?: (ticks: any) => Promise<void>;
+  };
+  readonly context?: () => {
+    readonly tracing?: {
+      readonly start?: (options?: any) => Promise<void>;
+      readonly stop?: (options?: any) => Promise<void>;
+    };
+  };
+  readonly on?: (event: any, listener: any) => unknown;
+  readonly off?: (event: any, listener: any) => unknown;
+  readonly addInitScript?: (script: any, arg?: any) => Promise<unknown>;
+}
+/**
+ * The subset of Playwright's `TestInfo` this package uses. The `testInfo`
+ * fixture of `@playwright/test` is assignable to it.
+ *
+ * @experimental
+ */
+export interface PlaywrightTestInfo {
+  readonly attach: (name: string, options: {
+    /** A string or a `Buffer`. */
+    readonly body?: any;
+    readonly path?: string;
+    readonly contentType?: string;
+  }) => Promise<void>;
+  readonly outputPath: (...pathSegments: string[]) => string;
+}
+/**
+ * The page-level oracles `createPlaywrightSut()` checks after every stable
+ * step. Keys left out are off.
+ *
+ * @experimental
+ */
+export interface PlaywrightOracles {
+  /** Fails on uncaught exceptions in the page (`pageerror`). */
+  readonly pageError?: boolean;
+  /** Fails on console messages of this level or above. */
+  readonly console?: 'error' | 'warn' | false;
+  /**
+   * Fails on responses with at least this status code. Responses to requests
+   * a `mocks` route handled are ignored.
+   */
+  readonly http?: number | false;
+  /** Fails on unhandled promise rejections in the page. */
+  readonly unhandledRejection?: boolean;
+}
+/**
+ * Thrown by a session's `check()` when a page-level oracle fails.
+ *
+ * @experimental
+ */
+declare const PlaywrightOracleErrorBase: new (args: {
+  readonly message: string;
+  readonly cause: readonly string[];
+}) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@systemfsoftware/xstate-test/playwright/PlaywrightOracleError";
+} & Readonly<{
+  readonly message: string;
+  readonly cause: readonly string[];
+}>;
+export declare class PlaywrightOracleError extends PlaywrightOracleErrorBase {
+  readonly messages: readonly string[];
+  readonly name = "PlaywrightOracleError";
+  constructor(messages: readonly string[]);
+}
+/**
+ * A Playwright action bound to a generated event.
+ *
+ * @experimental
+ */
+export type PlaywrightEventAction<TPage extends PlaywrightPage, TEvent extends EventObject> = (page: TPage, event: TEvent) => void | Promise<void>;
+/**
+ * Per-event-case network stubbing, applied before the event action runs.
+ *
+ * @experimental
+ */
+export type PlaywrightMock<TPage extends PlaywrightPage> = (page: TPage) => void | Promise<unknown>;
+/** @experimental */
+export interface PlaywrightSutConfig<TPage extends PlaywrightPage, TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  /** Performs each event against the page. */
+  readonly events: { readonly [TType in TEvent['type']]?: PlaywrightEventAction<TPage, TEvent extends {
+    type: TType;
+  } ? TEvent : never>; };
+  /**
+   * Projects the DOM to a value comparable with the model projection. Omit it
+   * (together with `projectModel`) to assert through `states` instead.
+   */
+  readonly read?: (page: TPage) => unknown | Promise<unknown>;
+  /** Projects the model snapshot to a value comparable with the page projection. */
+  readonly projectModel?: (snapshot: TSnapshot) => unknown;
+  /**
+   * Per-state assertions run after every stable step, keyed by state value (or
+   * `'#id'`), with `'*'` as the fallthrough.
+   */
+  readonly states?: {
+    readonly [stateKey: string]: (page: TPage, snapshot: TSnapshot) => void | Promise<void>;
+  };
+  /** Normalizes the value read from the page before comparison. */
+  readonly projectSut?: (observed: unknown) => unknown;
+  /** Compares model and page projections. Defaults to deep equality. */
+  readonly equivalent?: (model: unknown, sut: unknown) => boolean | Promise<boolean>;
+  /**
+   * Waits for the page to become quiescent before every comparison. Defaults to
+   * `page.waitForLoadState('load')` followed by a microtask flush. Pass a
+   * function to wait for something specific, such as a locator.
+   */
+  readonly settle?: (page: TPage) => void | Promise<void>;
+  /**
+   * Advances page time. Defaults to `page.clock.runFor(milliseconds)` when
+   * Playwright's clock API is installed, and returns no events.
+   */
+  readonly advance?: (page: TPage, milliseconds: number) => readonly TEvent[] | Promise<readonly TEvent[]>;
+  /**
+   * Records a checkpoint. Defaults to a screenshot written to the
+   * configured screenshot directory.
+   */
+  readonly checkpoint?: (page: TPage, label: string) => void | Promise<void>;
+  /** Directory for default checkpoint screenshots. */
+  readonly screenshotDir?: string;
+  /** Runs once when a scenario session is created. */
+  readonly reset?: (page: TPage) => void | Promise<void>;
+  /** Runs when a scenario stops. */
+  readonly stop?: (page: TPage) => void | Promise<void>;
+  /** Runs when a scenario session is disposed. */
+  readonly dispose?: (page: TPage) => void | Promise<void>;
+  /**
+   * Per-case `page.route()` setup. When the property runner supplies the
+   * generated event case, the key is looked up as `"<type>.<case>"` first and
+   * then as `"<case>"`; otherwise (prefix, clock and replayed events) the key
+   * is the case resolved by `caseOf`. Use it to steer an invoked service to
+   * success or failure on different generated paths.
+   *
+   * Routes installed by a mock are unrouted before another case's mock is
+   * applied and when the scenario session is disposed, so handlers do not
+   * leak across cases or runs.
+   */
+  readonly mocks?: {
+    readonly [caseId: string]: PlaywrightMock<TPage>;
+  };
+  /**
+   * Resolves the mock case for an event. Defaults to `event.case` when present,
+   * otherwise `event.type`.
+   */
+  readonly caseOf?: (event: TEvent) => string | undefined;
+  /**
+   * Page-level oracles checked after every stable step. `'defaults'` (the
+   * default) fails on uncaught exceptions, console errors, unhandled
+   * rejections, and responses with a status of 400 or above. `false` turns
+   * them all off.
+   */
+  readonly oracles?: 'defaults' | false | PlaywrightOracles;
+  /**
+   * Where failure artifacts are attached. Pass Playwright's `testInfo`
+   * fixture. Required when `trace` or `screenshots` is on.
+   */
+  readonly testInfo?: PlaywrightTestInfo;
+  /**
+   * Records a Playwright trace per run. `'retain-on-failure'` attaches the
+   * trace of the failing run; `'on'` also attaches the last run's trace when
+   * the campaign passes. Defaults to `'retain-on-failure'` with `testInfo`,
+   * and `'off'` without.
+   */
+  readonly trace?: 'off' | 'retain-on-failure' | 'on';
+  /**
+   * `'on-failure'` attaches a screenshot of the page when the failing run
+   * ends; `'every-step'` attaches one per stable step of the failing run.
+   * Defaults to `'on-failure'` with `testInfo`, and `'off'` without.
+   */
+  readonly screenshots?: 'off' | 'on-failure' | 'every-step';
+  /**
+   * Wraps each event action, such as Playwright's `test.step`, so the report
+   * shows one step per event.
+   */
+  readonly step?: (name: string, body: () => Promise<void>) => Promise<unknown>;
+}
+/**
+ * Creates a `TestSut` that drives a Playwright page as the system under
+ * test for `propertyTest()` and `testPaths()`.
+ *
+ * @experimental
+ */
+export declare const createPlaywrightSut: {
+  <TPage extends PlaywrightPage, TSnapshot extends Snapshot<unknown> = Snapshot<unknown>, TEvent extends EventObject = EventObject>(config: PlaywrightSutConfig<TPage, TSnapshot, TEvent>): (page: TPage) => TestSut<TSnapshot, TEvent>;
+  <TPage extends PlaywrightPage, TSnapshot extends Snapshot<unknown> = Snapshot<unknown>, TEvent extends EventObject = EventObject>(page: TPage, config: PlaywrightSutConfig<TPage, TSnapshot, TEvent>): TestSut<TSnapshot, TEvent>;
+};
+export {};