/**
 * This file provides type definitions for use with the Flow type checker.
 *
 * @flow
 */
declare class Stage {
    and(): this;
    but(): this;
    with(): this;
    given(): this;
    when(): this;
    then(): this;
}

type ScenariosParam<G, W, T> = {
    given: () => G;
    when: () => W;
    then: () => T;
};

type ScenarioFunc = SimpleScenarioFunc | ParametrizedScenarioFuncWithParameters;

type SimpleScenarioFunc = {
    (): void;
};

type ParametrizedScenarioFuncWithParameters = {
    func: (...args: any[]) => void;
    parameters: Array<Array<any>>;
};

type StagesParam<G, W, T> = [Class<G>, Class<W>, Class<T>] | Class<G & W & T>;

type ScenariosDescriptions<G, W, T> = {
    (scenariosParam: ScenariosParam<G, W, T>): {[key:string]: ScenarioDescription};
};

type ScenarioDescription = {
    scenarioFunction: ScenarioFunc;
};

type ScenarioOptions = {};
declare function scenario(options: $Shape<ScenarioOptions>, scenarioFunction: ScenarioFunc): ScenarioDescription;

declare function scenarios<G: Stage, W: Stage, T: Stage>(groupName: string, stagesParam: StagesParam<G, W, T>, scenarioFunc: ScenariosDescriptions<G, W, T>): void;

type StateType = {
    (target: any, key: string, descriptor: any): any;
    addProperty: (target: Class<Stage>, propertyName: string) => void;
};
declare var State: StateType;

declare function setupForRspec(describe: any, it: any): void;
declare function setupForAva(test: any): void;

declare function parametrized(parameters: Array<Array<any>>, func: () => void): ParametrizedScenarioFuncWithParameters;
declare function parametrized1<T>(parameters: T[], func: (a: T) => void): ParametrizedScenarioFuncWithParameters;
declare function parametrized2<A, B>(parameters: Array<[A, B]>, func: (a: A, b: B) => void): ParametrizedScenarioFuncWithParameters;
declare function parametrized3<A, B, C>(parameters: Array<[A, B, C]>, func: (a: A, b: B, c: C) => void): ParametrizedScenarioFuncWithParameters;
declare function parametrized4<A, B, C, D>(parameters: Array<[A, B, C, D]>, func: (a: A, b: B, c: C, d: D) => void): ParametrizedScenarioFuncWithParameters;
declare function parametrized5<A, B, C, D, E>(parameters: Array<[A, B, C, D, E]>, func: (a: A, b: B, c: C, d: D, e: E) => void): ParametrizedScenarioFuncWithParameters;
declare function parametrized6<A, B, C, D, E, F>(parameters: Array<[A, B, C, D, E, F]>, func: (a: A, b: B, c: C, d: D, e: E, f: F) => void): ParametrizedScenarioFuncWithParameters;
declare function parametrized7<A, B, C, D, E, F, G>(parameters: Array<[A, B, C, D, E, F, G]>, func: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): ParametrizedScenarioFuncWithParameters;

declare function doAsync(action: () => Promise<*>): void;

export {
    scenario,
    scenarios,
    Stage,
    State,
    setupForRspec,
    setupForAva,
    parametrized,
    parametrized1,
    parametrized2,
    parametrized3,
    parametrized4,
    parametrized5,
    parametrized6,
    parametrized7,
    doAsync,
};