import { Expression, ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
import parse from "@cucumber/tag-expressions";
import { IdGenerator } from "@cucumber/messages";
import DataTable from "./data_table";
import { CypressCucumberError } from "./helpers/error";
import { ICaseHookBody, ICaseHookOptions, ICaseHookParameter, IParameterTypeDefinition, IRunHookBody, IStepDefinitionBody, IStepHookBody, IStepHookParameter } from "./public-member-types";
import { Position } from "./helpers/source-map";
export interface IStepDefinition<T extends unknown[], C extends Mocha.Context> {
    id: string;
    expression: Expression;
    implementation: IStepDefinitionBody<T, C>;
    position?: Position;
}
export declare class MissingDefinitionError extends CypressCucumberError {
}
export declare class MultipleDefinitionsError extends CypressCucumberError {
}
export type RunHookKeyword = "BeforeAll" | "AfterAll";
export type CaseHookKeyword = "Before" | "After";
export type StepHookKeyword = "BeforeStep" | "AfterStep";
type Node = ReturnType<typeof parse>;
export interface IRunHook {
    implementation: IRunHookBody;
    keyword: RunHookKeyword;
    position?: Position;
}
export interface ICaseHook {
    id: string;
    node: Node;
    implementation: ICaseHookBody;
    keyword: CaseHookKeyword;
    position?: Position;
    tags?: string;
    name?: string;
}
export interface IStepHook {
    node: Node;
    implementation: IStepHookBody;
    keyword: StepHookKeyword;
    position?: Position;
    tags?: string;
    name?: string;
}
export declare class Registry {
    private experimentalSourceMap;
    parameterTypeRegistry: ParameterTypeRegistry;
    private preliminaryStepDefinitions;
    stepDefinitions: IStepDefinition<unknown[], Mocha.Context>[];
    private preliminaryHooks;
    runHooks: IRunHook[];
    caseHooks: ICaseHook[];
    stepHooks: IStepHook[];
    constructor(experimentalSourceMap: boolean);
    finalize(newId: IdGenerator.NewId): void;
    defineStep(description: string | RegExp, implementation: () => void): void;
    defineParameterType<T, C extends Mocha.Context>({ name, regexp, transformer, }: IParameterTypeDefinition<T, C>): void;
    defineCaseHook(keyword: CaseHookKeyword, options: ICaseHookOptions, fn: ICaseHookBody): void;
    defineBefore(options: ICaseHookOptions, fn: ICaseHookBody): void;
    defineAfter(options: ICaseHookOptions, fn: ICaseHookBody): void;
    defineStepHook(keyword: StepHookKeyword, options: ICaseHookOptions, fn: IStepHookBody): void;
    defineBeforeStep(options: ICaseHookOptions, fn: IStepHookBody): void;
    defineAfterStep(options: ICaseHookOptions, fn: IStepHookBody): void;
    defineRunHook(keyword: RunHookKeyword, fn: IRunHookBody): void;
    defineBeforeAll(fn: IRunHookBody): void;
    defineAfterAll(fn: IRunHookBody): void;
    getMatchingStepDefinitions(text: string): IStepDefinition<unknown[], Mocha.Context>[];
    resolveStepDefintion(text: string): IStepDefinition<unknown[], Mocha.Context>;
    runStepDefininition(world: Mocha.Context, text: string, argument?: DataTable | string): unknown;
    resolveCaseHooks(keyword: CaseHookKeyword, tags: string[]): ICaseHook[];
    resolveBeforeHooks(tags: string[]): ICaseHook[];
    resolveAfterHooks(tags: string[]): ICaseHook[];
    runCaseHook(world: Mocha.Context, hook: ICaseHook, options: ICaseHookParameter): void;
    resolveStepHooks(keyword: StepHookKeyword, tags: string[]): IStepHook[];
    resolveBeforeStepHooks(tags: string[]): IStepHook[];
    resolveAfterStepHooks(tags: string[]): IStepHook[];
    runStepHook(world: Mocha.Context, hook: IStepHook, options: IStepHookParameter): void;
    resolveRunHooks(keyword: RunHookKeyword): IRunHook[];
    resolveBeforeAllHooks(): IRunHook[];
    resolveAfterAllHooks(): IRunHook[];
    runRunHook(world: Mocha.Context, hook: IRunHook): void;
}
export declare function withRegistry(experimentalSourceMap: boolean, fn: () => void): Registry;
export declare function assignRegistry(registry: Registry): void;
export declare function freeRegistry(): void;
export declare function getRegistry(): Registry;
export {};