import { Check, Expect, it, layer } from "@systemfsoftware/vitest";
import { Suite, TaskRef } from "@systemfsoftware/effect-spec-runtime";
import { Asserted } from "@systemfsoftware/vitest/integration";
import { Context, Duration, Effect, Layer, Schedule, Schema } from "effect";
import * as Effect$1 from "effect/Effect";
import * as Layer$1 from "effect/Layer";
import * as Result from "effect/Result";
import * as Scope from "effect/Scope";
//#endregion
//#region src/StepError.schema.d.ts
declare const StepError_base: Schema.Class<StepError, Schema.TaggedStruct<"StepError", {
  readonly keyword: Schema.String;
  readonly text: Schema.String;
  readonly cause: Schema.Unknown;
}>, import("effect/Cause").YieldableError>;
/**
 * Derives `message` from `keyword`, `text` and `cause`, so a step failure never prints an empty
 * headline. Declared as a getter because a `message` field would change the error's encoded shape.
 */
export declare class StepError extends StepError_base {
  get message(): string;
}
declare namespace SuiteScope_d_exports {
  export { ScopeIdentifiers$1 as ScopeIdentifiers, ScopeMap$1 as ScopeMap, ScopeServices$1 as ScopeServices, resolve };
}
type AnyValue<A = unknown> = A;
type ScopeMap$1 = Readonly<Record<string, Effect.Effect<AnyValue, never, never>>>;
type ScopeServices$1<S extends ScopeMap$1> = { readonly [K in keyof S]: S[K] extends Effect.Effect<infer A, never, infer _R> ? A : never; };
type ScopeIdentifiers$1<S extends ScopeMap$1> = { [K in keyof S]: S[K] extends Effect.Effect<infer _A, never, infer R> ? R : never; }[keyof S];
/**
 * Resolves every service named by the scope map at once, preserving the
 * record's shape and the union of the named requirements.
 */
declare function resolve<S extends ScopeMap$1>(map: S): Effect.Effect<ScopeServices$1<S>, never, ScopeIdentifiers$1<S>>;
//#endregion
//#region src/DoNotation.d.ts
interface PollOptions {
  /**
   * The interval between poll attempts.
   * Default: '50 millis'
   */
  readonly interval?: Duration.Input | undefined;
  /**
   * Maximum duration to wait before timing out and failing.
   * Default: '5 seconds'
   */
  readonly timeout?: Duration.Input | undefined;
}
export declare const pollSchedule: (opts?: PollOptions) => Schedule.Schedule<number, unknown, never, never>;
/**
 * The test's own `expect`, published by the runner for the scenario it drives. A Then step body
 * receives it as its second parameter, so no step reaches for an import and no step can assert
 * outside the check the ledger sees.
 */
export declare const StepExpect: Context.Reference<Expect | null>;
/**
 * What a Then step body answers with: the one check of the state it observed, or an Effect that
 * answers with one — a body that must await something before it can check.
 */
type StepCheck<E = never, R = never> = Check | Effect.Effect<Check, E, R>;
type VitestTaskContext<Ann = unknown> = TaskRef.VitestTaskContext<Ann>;
export declare const VitestTaskRef: Context.Reference<TaskRef.VitestTaskContext<unknown> | null>;
type NoInfer$1<A> = [A][A extends A ? 0 : never];
declare const GherkinScopeTypeId: unique symbol;
export declare const StageTypeId: unique symbol;
type InitialStage = {
  readonly [StageTypeId]: 'initial';
};
type GivenStage = {
  readonly [StageTypeId]: 'given';
};
type WhenStage = {
  readonly [StageTypeId]: 'when';
};
type ThenStage = {
  readonly [StageTypeId]: 'then';
};
type Stage = InitialStage | GivenStage | WhenStage | ThenStage;
export declare const stageInitial: InitialStage;
export declare const stageGiven: GivenStage;
export declare const stageWhen: WhenStage;
export declare const stageThen: ThenStage;
type GherkinScope<A extends object> = A & {
  readonly [GherkinScopeTypeId]: typeof GherkinScopeTypeId;
};
type StepText<A extends object = object> = string | ((scope: A) => string);
type GherkinEffect<A extends object, E, R> = Effect.Effect<GherkinScope<A>, E, R>;
type AssertedPipeline<R = never> = Effect.Effect<GherkinScope<object & ThenStage>, StepError, R>;
/**
 * A Then/And/But body asserts the state the last Given or When produced, and that state is
 * asserted once: a second assertion step before the next Given or When is refused by name.
 */
type AssertionStateRefused = '✗ a second assertion step on the same state. Assert it once in one Then: Then(text)((s, expect) => expect({ a: s.a, b: s.b }).toEqual({...})).';
/**
 * The gate an assertion step's input carries. Its `[StageTypeId]` is a stage a Given or When
 * produced, so a pipeline already past its assertion mismatches with the refusal as the property's
 * type — the compile half of the one-state rule, with the runtime half on the ledger's refusal.
 */
type AssertableScope = {
  readonly [StageTypeId]?: InitialStage[typeof StageTypeId] | GivenStage[typeof StageTypeId] | WhenStage[typeof StageTypeId] | AssertionStateRefused;
};
declare const _given: (text: StepText) => {
  <N extends string, A extends object & (InitialStage | GivenStage), B, E2, R2>(name: N, f: (a: NoInfer$1<A>) => Effect.Effect<B, E2, R2>): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & Record<N, B> & GivenStage, E1 | StepError, R1 | R2 | Asserted>;
  <A extends object & (InitialStage | GivenStage), E2 = never, R2 = never, Out = unknown>(f: (a: NoInfer$1<A>) => Effect.Effect<Out, E2, R2> | void): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & GivenStage, E1 | StepError, R1 | R2 | Asserted>;
};
declare const _then: (text: StepText) => <A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), E2 = never, R2 = never>(f: (a: NoInfer$1<A>, expect: Expect) => StepCheck<E2, R2>) => <E1, R1>(self: GherkinEffect<A, E1, R1> & AssertableScope) => GherkinEffect<Omit<A, typeof StageTypeId> & ThenStage, E1 | StepError, R1 | R2 | Asserted>;
declare const _and: (text: StepText) => <A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), E2 = never, R2 = never>(f: (a: NoInfer$1<A>, expect: Expect) => StepCheck<E2, R2>) => <E1, R1>(self: GherkinEffect<A, E1, R1> & AssertableScope) => GherkinEffect<Omit<A, typeof StageTypeId> & ThenStage, E1 | StepError, R1 | R2 | Asserted>;
declare const _but: (text: StepText) => <A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), E2 = never, R2 = never>(f: (a: NoInfer$1<A>, expect: Expect) => StepCheck<E2, R2>) => <E1, R1>(self: GherkinEffect<A, E1, R1> & AssertableScope) => GherkinEffect<Omit<A, typeof StageTypeId> & ThenStage, E1 | StepError, R1 | R2 | Asserted>;
type ScopeMap = ScopeMap$1;
type ScopeServices<S extends ScopeMap> = ScopeServices$1<S>;
type ScopeIdentifiers<S extends ScopeMap> = ScopeIdentifiers$1<S>;
declare function makeScope<S extends ScopeMap>(map: S): GherkinEffect<ScopeServices<S> & GivenStage, never, ScopeIdentifiers<S>>;
export declare const Gherkin: {
  readonly Do: Effect.Effect<GherkinScope<InitialStage>, never, never>;
  readonly startWith: <A extends object>(bindings: A) => GherkinEffect<A & GivenStage, never, never>;
  readonly scope: typeof makeScope;
  readonly Given: typeof _given;
  readonly When: ((text: StepText) => {
    <N extends string, A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), B, E2, R2>(name: N, f: (a: NoInfer$1<A>) => Effect.Effect<B, E2, R2>): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & Record<N, B> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
    <A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), E2 = never, R2 = never, Out = unknown>(f: (a: NoInfer$1<A>) => Effect.Effect<Out, E2, R2> | void): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
  }) & {
    poll: (text: StepText, opts?: PollOptions) => {
      <N extends string, A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), B, E2, R2>(name: N, f: (a: NoInfer$1<A>) => Effect.Effect<B, E2, R2>): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & Record<N, B> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
      <A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), E2 = never, R2 = never, Out = unknown>(f: (a: NoInfer$1<A>) => Effect.Effect<Out, E2, R2> | void): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
    };
  };
  readonly Then: typeof _then;
  readonly And: typeof _and;
  readonly But: typeof _but;
};
export declare const Given: typeof _given, When: ((text: StepText) => {
  <N extends string, A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), B, E2, R2>(name: N, f: (a: NoInfer$1<A>) => Effect.Effect<B, E2, R2>): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & Record<N, B> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
  <A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), E2 = never, R2 = never, Out = unknown>(f: (a: NoInfer$1<A>) => Effect.Effect<Out, E2, R2> | void): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
}) & {
  poll: (text: StepText, opts?: PollOptions) => {
    <N extends string, A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), B, E2, R2>(name: N, f: (a: NoInfer$1<A>) => Effect.Effect<B, E2, R2>): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & Record<N, B> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
    <A extends object & (InitialStage | GivenStage | WhenStage | ThenStage), E2 = never, R2 = never, Out = unknown>(f: (a: NoInfer$1<A>) => Effect.Effect<Out, E2, R2> | void): <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & WhenStage, E1 | StepError, R1 | R2 | Asserted>;
  };
}, Then: typeof _then, And: typeof _and, But: typeof _but;
//#endregion
//#region src/extensions/Pairwise.d.ts
type NoInfer<A> = [A][A extends A ? 0 : never];
type PairwiseResult<A> = {
  readonly a: A;
  readonly b: A;
  readonly aLabel: string;
  readonly bLabel: string;
};
interface PairwiseMatrix<Identifier = unknown, RA = never, RB = never> {
  readonly a: {
    readonly name: string;
    readonly layer: Layer.Layer<Identifier, never, RA>;
  };
  readonly b: {
    readonly name: string;
    readonly layer: Layer.Layer<Identifier, never, RB>;
  };
}
export declare const pairwiseFor: {
  <Identifier, Service, RA = never, RB = never>(service: Context.Service<Identifier, Service>): (matrix: PairwiseMatrix<Identifier, RA, RB>) => (text: StepText) => <N extends string, A extends object & (InitialStage | GivenStage | WhenStage), Out, E>(name: N, f: (scope: NoInfer<A>) => (svc: Service) => Effect.Effect<Out, E, never>) => <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & Record<N, PairwiseResult<Out>> & WhenStage, E1 | StepError, R1 | RA | RB | Asserted>;
  <Identifier, Service, RA = never, RB = never>(matrix: PairwiseMatrix<Identifier, RA, RB>, service: Context.Service<Identifier, Service>): (text: StepText) => <N extends string, A extends object & (InitialStage | GivenStage | WhenStage), Out, E>(name: N, f: (scope: NoInfer<A>) => (svc: Service) => Effect.Effect<Out, E, never>) => <E1, R1>(self: GherkinEffect<A, E1, R1>) => GherkinEffect<Omit<A, typeof StageTypeId> & Record<N, PairwiseResult<Out>> & WhenStage, E1 | StepError, R1 | RA | RB | Asserted>;
};
//#endregion
//#region src/FeatureRuntime.d.ts
type ScenarioOptions<RScenario = never, RExtra = never> = {
  readonly scenarioLayer?: Layer$1.Layer<RScenario>;
  readonly layer?: Layer$1.Layer<RExtra>;
  readonly live?: string;
};
type Top<T = unknown> = T;
type ScenarioBody<R = never> = Effect$1.Effect<Top, StepError, R>;
type BackgroundEffect<R = never> = Effect$1.Effect<Top, StepError, R | Asserted>;
/**
 * A registered scenario: the runner's own `expect` arrives as the argument, so every assertion
 * step inside the scenario reaches the test's check callback rather than an import. `R` is what the
 * scenario's layer provides; every marked step also needs the runner's check service, so the run
 * carries `Asserted` beside it.
 */
type ScenarioRun<R = never> = (expect: Expect) => Effect$1.Effect<void, StepError, R | Scope.Scope | Asserted>;
/**
 * A scenario title names a concrete situation in natural-language prose. Two
 * shape checks keep DAMP `Should_[Behavior]_When_[Condition]` unit-test names —
 * and every concatenated-token title shaped like one — out of the call site:
 *  1. the literal must not start with `Should`;
 *  2. the literal must contain at least one ASCII space (a single-word title is
 *     a test name, not prose).
 * Either check failing maps to `ScenarioTitleRejected`, so the call fails to
 * type-check with the rule in the diagnostic. Non-literal titles (widened
 * `string`) pass through untouched — a runtime guard would catch those, but
 * the brand is the contract this skill ships.
 */
type ScenarioTitleRejected<T extends string> = `Scenario titles are natural-language prose of a concrete situation, not DAMP Should_[Behavior]_When_[Condition] unit-test names. Got: ${T}` | `Scenario title must be natural-language prose (at least one space separates words); got: ${T}`;
type ScenarioTitle<T extends string> = T extends `Should${string}` ? ScenarioTitleRejected<T> : T extends `${string} ${string}` ? T : ScenarioTitleRejected<T>;
type OutlineCallable<RShared = never, RFresh = never, RFreshReq = never> = {
  <TName extends string, const Rows extends readonly Record<string, Top>[], RPipe extends RShared | RFresh | RFreshReq | Scope.Scope | Asserted>(name: ScenarioTitle<TName>, examples: Rows, stepFactory: (row: Rows[number]) => Effect$1.Effect<Top, StepError, RPipe>): void;
  <TName extends string, const Rows extends readonly Record<string, Top>[], RExtra, RPipe extends RShared | RFresh | RFreshReq | Scope.Scope | Asserted | RExtra>(name: ScenarioTitle<TName>, examples: Rows, stepFactory: (row: Rows[number]) => Effect$1.Effect<Top, StepError, RPipe>, opts: ScenarioOptions<RShared | RFresh | RFreshReq, RExtra>): void;
};
type OutlineFn<RShared = never, RFresh = never, RFreshReq = never> = OutlineCallable<RShared, RFresh, RFreshReq> & {
  readonly skip: OutlineCallable<RShared, RFresh, RFreshReq>;
  readonly only: OutlineCallable<RShared, RFresh, RFreshReq>;
};
type HeadlessPipelineRejected = 'Scenario pipeline must conclude with at least one Then step, not end on Given or When';
type ValidScenarioPipeline<P> = P extends GherkinEffect<infer S, infer _E, infer _R> ? S extends ThenStage ? P : HeadlessPipelineRejected : P;
type ScenarioCallable<RShared, RFresh, RFreshReq> = {
  <TName extends string, RPipe extends RShared | RFresh | RFreshReq | Scope.Scope | Asserted, P extends Effect$1.Effect<Top, StepError, RPipe>>(name: ScenarioTitle<TName>, pipeline: P & ValidScenarioPipeline<P>): void;
  <TName extends string, RExtra, RPipe extends RShared | RFresh | RFreshReq | Scope.Scope | Asserted | RExtra, P extends Effect$1.Effect<Top, StepError, RPipe>>(name: ScenarioTitle<TName>, opts: ScenarioOptions<RShared | RFresh | RFreshReq, RExtra>, pipeline: P & ValidScenarioPipeline<P>): void;
};
type ScenarioFn<RShared = never, RFresh = never, RFreshReq = never> = ScenarioCallable<RShared, RFresh, RFreshReq> & {
  readonly skip: ScenarioCallable<RShared, RFresh, RFreshReq>;
  readonly only: ScenarioCallable<RShared, RFresh, RFreshReq>;
};
type EmptyScopeMap$1 = Readonly<Record<string, never>>;
type FeatureBody<RShared = never, RFresh = never, RFreshReq = never, S extends ScopeMap = EmptyScopeMap$1> = (ctx: {
  readonly scenario: ScenarioFn<RShared, RFresh, RFreshReq>;
  readonly background: (pipeline: BackgroundEffect<RShared | RFresh | RFreshReq>) => void;
  readonly scenarioOutline: OutlineFn<RShared, RFresh, RFreshReq>;
  readonly scope: GherkinEffect<ScopeServices<S> & GivenStage, never, ScopeIdentifiers<S>>;
  readonly Do: Effect$1.Effect<object, never, never>;
}) => void;
export declare const resolveScenarioArgs: {
  <R = never>(third: Effect$1.Effect<Top, StepError, R> | undefined): (second: Effect$1.Effect<Top, StepError, R> | ScenarioOptions<never, never> | undefined) => {
    pipeline: Effect$1.Effect<Top, StepError, R>;
    opts: ScenarioOptions<never, never> | null;
  };
  <R = never>(second: Effect$1.Effect<Top, StepError, R> | ScenarioOptions<never, never> | undefined, third: Effect$1.Effect<Top, StepError, R> | undefined): {
    pipeline: Effect$1.Effect<Top, StepError, R>;
    opts: ScenarioOptions<never, never> | null;
  };
};
//#endregion
//#region src/Feature.d.ts
type EmptyScopeMap = Readonly<Record<string, never>>;
type FeatureSuiteOptions = Suite.Options;
type EffectVitestBindings = Suite.Bindings;
type FeatureBuilderBoth<RShared, RFresh, RFreshReq extends RShared, S extends ScopeMap = EmptyScopeMap> = {
  readonly live: (reason: string) => FeatureBuilderBoth<RShared, RFresh, RFreshReq, S>;
  body: (body: FeatureBody<RShared, RFresh, RFreshReq, S>) => void;
  withScope: <S2 extends ScopeMap>(map: S2) => FeatureBuilderBoth<RShared, RFresh, RFreshReq, S2>;
};
type FeatureBuilderWithLayer<RShared, S extends ScopeMap = EmptyScopeMap> = {
  readonly live: (reason: string) => FeatureBuilderWithLayer<RShared, S>;
  body: (body: FeatureBody<RShared, never, never, S>) => void;
  withScope: <S2 extends ScopeMap>(map: S2) => FeatureBuilderWithLayer<RShared, S2>;
  withScenarioLayer: <RFresh, RFreshReq extends RShared = never>(layer: Layer$1.Layer<RFresh, never, RFreshReq>) => FeatureBuilderBoth<RShared, RFresh, RFreshReq, S>;
};
type FeatureBuilderWithScenarioLayer<RFresh, RFreshReq extends Scope.Scope, S extends ScopeMap = EmptyScopeMap> = {
  readonly live: (reason: string) => FeatureBuilderWithScenarioLayer<RFresh, RFreshReq, S>;
  body: (body: FeatureBody<never, RFresh, RFreshReq, S>) => void;
  withLayer: <RShared>(layer: Layer$1.Layer<RShared>) => FeatureBuilderBoth<RShared | RFreshReq, RFresh, RFreshReq, S>;
  withScope: <S2 extends ScopeMap>(map: S2) => FeatureBuilderWithScenarioLayer<RFresh, RFreshReq, S2>;
};
type FeatureBuilder<S extends ScopeMap = EmptyScopeMap> = {
  readonly live: (reason: string) => FeatureBuilder<S>;
  body: (body: FeatureBody<never, never, never, S>) => void;
  /**
   * Provide a shared fixture layer across all scenarios in this feature suite.
   *
   * Maps to Vitest's `worker` or file-level fixture scope. Resources acquired in this layer
   * are allocated once when the suite starts and released at suite completion.
   *
   * @example
   * ```ts
   * // Bridging a Vitest callback-based fixture:
   * const DatabaseFixture = Layer.scoped(
   *   Database,
   *   Effect.acquireRelease(
   *     Effect.sync(() => createDatabase()),
   *     (db) => Effect.sync(() => db.teardown())
   *   )
   * )
   *
   * Feature('User management').withLayer(DatabaseFixture)
   * ```
   */
  withLayer: <RShared>(layer: Layer$1.Layer<RShared>) => FeatureBuilderWithLayer<RShared, S>;
  /**
   * Provide a per-scenario fresh fixture layer.
   *
   * Maps to Vitest's `test` fixture scope (`test.extend({ fixture: async ({}, use) => { ... use(val); cleanup(); } })`).
   * Resources are allocated fresh before each scenario and automatically torn down via their
   * `Scope` finalizer (`Effect.acquireRelease`) when the scenario completes, regardless of success or failure.
   *
   * @example
   * ```ts
   * const TempDirFixture = Layer.scoped(
   *   TempDirectory,
   *   Effect.acquireRelease(
   *     Effect.sync(() => makeTempDir()),
   *     (dir) => Effect.sync(() => removeTempDir(dir))
   *   )
   * )
   *
   * Feature('File processing').withScenarioLayer(TempDirFixture)
   * ```
   */
  withScenarioLayer: <RFresh, RFreshReq extends Scope.Scope = never>(layer: Layer$1.Layer<RFresh, never, RFreshReq>) => FeatureBuilderWithScenarioLayer<RFresh, RFreshReq, S>;
  withScope: <S2 extends ScopeMap>(map: S2) => FeatureBuilder<S2>;
};
type FeatureStarter = (suiteName: string, suiteOpts?: FeatureSuiteOptions) => FeatureBuilder;
type FeatureFn = FeatureStarter & {
  readonly skip: FeatureStarter;
  readonly only: FeatureStarter;
};
export declare const makeFeature: (deps: EffectVitestBindings) => FeatureFn;
//#endregion
//#region src/OutlineExpand.d.ts
type TemplateToken = {
  tag: string;
  rest: string;
};
export declare const tokenizeTemplate: (template: string) => readonly TemplateToken[];
interface OutlineRow<Row> {
  readonly row: Row;
  readonly title: string;
}
export declare const stringifyForTitle: <A = unknown>(value: A) => string;
type AnyRow<V = unknown> = Record<string, V>;
export declare const renderTitle: {
  (row: AnyRow, stringify?: <V = unknown>(value: V) => string): (template: string) => string;
  (template: string, row: AnyRow, stringify?: <V = unknown>(value: V) => string): string;
};
export declare const expandOutline: {
  <Row extends AnyRow>(rows: readonly Row[], stringify?: <V = unknown>(value: V) => string): (name: string) => Result.Result<readonly OutlineRow<Row>[], string>;
  <Row extends AnyRow>(name: string, rows: readonly Row[], stringify?: <V = unknown>(value: V) => string): Result.Result<readonly OutlineRow<Row>[], string>;
};
//#endregion
export { type AssertedPipeline, type AssertionStateRefused, type EffectVitestBindings, type FeatureBody, type FeatureBuilder, type FeatureBuilderBoth, type FeatureBuilderWithLayer, type FeatureBuilderWithScenarioLayer, type FeatureFn, type FeatureSuiteOptions, type GherkinEffect, type GherkinScope, type GivenStage, type HeadlessPipelineRejected, type InitialStage, type OutlineFn, type OutlineRow, type PairwiseMatrix, type PairwiseResult, type PollOptions, type ScenarioBody, type ScenarioFn, type ScenarioOptions, type ScenarioRun, type ScopeIdentifiers, type ScopeMap, type ScopeServices, type Stage, type StepCheck, type StepText, type TemplateToken, type ThenStage, type ValidScenarioPipeline, type VitestTaskContext, type WhenStage, it, layer };