import { Scalar } from '@letsrunit/utils';

type Modifier = 'Control' | 'Shift' | 'Alt' | 'Meta';
type Key = Modifier | 'Enter' | 'Escape' | 'Tab' | 'Backspace' | 'Delete' | 'Space' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'PageUp' | 'PageDown' | 'Home' | 'End' | `F${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12}`;
type KeyCombo = {
    /** Modifiers pressed and held before the final key. */
    modifiers: Modifier[];
    /** The final key to press (e.g. 'Enter', 'S', 'ArrowUp', 'F5', etc.). */
    key: Key | string;
};

interface ParameterTypeDefinition<T> {
    name: string;
    placeholder: string;
    regexp: readonly RegExp[] | readonly string[] | RegExp | string;
    transformer?: (...match: string[]) => T;
    useForSnippets?: boolean;
    preferForRegexpMatch?: boolean;
}
declare function booleanParameter(trueValue: string, falseValue: string, regexp?: RegExp): ParameterTypeDefinition<boolean>;
declare function enumParameter<const T extends readonly string[]>(values: T, regexp?: RegExp): ParameterTypeDefinition<T[number]>;
declare function valueParameter(name?: string): ParameterTypeDefinition<Scalar | Scalar[]>;
declare function locatorParameter(name?: string): ParameterTypeDefinition<string>;
declare function keysParameter(name?: string): ParameterTypeDefinition<KeyCombo>;

interface Feature {
    name?: string;
    description?: string;
    comments?: string;
    background?: string[];
    steps: string[];
}
declare function makeFeature({ name, description, comments, background, steps }: Feature): string;
declare function parseFeature(input: string): Feature;
declare function deltaSteps(steps: string[], newSteps: string[]): string[];

declare function computeStepId(normalizedText: string): string;
declare function computeScenarioId(stepIds: string[]): string;
declare function computeFeatureId(scenarioIds: string[]): string;
declare function computeRuleId(scenarioIds: string[]): string;
declare function computeOutlineId(stepIds: string[]): string;
declare function computeExampleRowId(values: string[]): string;

declare function sanitizeStepDefinition<T extends string | RegExp>(step: T): T;

declare function normalizeStep(keyword: string, text: string, docString?: {
    content: string;
}, dataTable?: {
    rows: ReadonlyArray<{
        cells: ReadonlyArray<{
            value: string;
        }>;
    }>;
}): string;

interface StepInput {
    keyword: string;
    text: string;
    docString?: {
        content: string;
    };
    dataTable?: {
        rows: ReadonlyArray<{
            cells: ReadonlyArray<{
                value: string;
            }>;
        }>;
    };
}
declare function normalizeSteps(steps: ReadonlyArray<StepInput>, initialKeyword?: string): string[];

declare function scenarioIdFromGherkin(input: string): string;

interface ExecutableScenario {
    id: string;
    name: string;
}
declare function listExecutableScenarios(input: string, uri?: string): ExecutableScenario[];
declare function executableScenarioIds(input: string, uri?: string): Set<string>;

export { type ExecutableScenario, type Feature, type KeyCombo, type ParameterTypeDefinition, type StepInput, booleanParameter, computeExampleRowId, computeFeatureId, computeOutlineId, computeRuleId, computeScenarioId, computeStepId, deltaSteps, enumParameter, executableScenarioIds, keysParameter, listExecutableScenarios, locatorParameter, makeFeature, normalizeStep, normalizeSteps, parseFeature, sanitizeStepDefinition, scenarioIdFromGherkin, valueParameter };