declare module "js-given" {
    class Stage {
        constructor();

        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 Class<T> = {
        new(): T;
    }

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

    type ScenarioDescription = {
        scenarioFunction: ScenarioFunc;
    };

    type ScenarioOptions = {};
    function scenario(options: ScenarioOptions, scenarioFunction: ScenarioFunc): ScenarioDescription;

    function scenarios<S>(groupName: string, stagesParam: Class<S>, scenarioFunc: ScenariosDescriptions<S, S, S>): void;
    function scenarios<G, W, T>(groupName: string, stagesParam: [Class<G>, Class<W>, Class<T>], scenarioFunc: ScenariosDescriptions<G, W, T>): void;


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

    type StateType = {
        (target: object, decoratedPropertyKey: string, descriptor?: TypedPropertyDescriptor<() => any>): any;
        addProperty: (target: Class<Stage>, propertyName: string) => void;
    };
    var State: StateType;

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

    function setupForAva(test: any): void;

    function parametrized(parameters: Array<Array<any>>, func: () => void): ParametrizedScenarioFuncWithParameters;
    function parametrized1<T>(parameters: T[], func: (a: T) => void): ParametrizedScenarioFuncWithParameters;
    function parametrized2<A, B>(parameters: Array<[A, B]>, func: (a: A, b: B) => void): ParametrizedScenarioFuncWithParameters;
    function parametrized3<A, B, C>(parameters: Array<[A, B, C]>, func: (a: A, b: B, c: C) => void): ParametrizedScenarioFuncWithParameters;
    function parametrized4<A, B, C, D>(parameters: Array<[A, B, C, D]>, func: (a: A, b: B, c: C, d: D) => void): ParametrizedScenarioFuncWithParameters;
    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;
    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;
    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;

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