io.cucumber.java8.Fr Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cucumber-java8 Show documentation
There is a newer version: 7.18.1
package io.cucumber.java8;

import io.cucumber.java8.StepDefinitionBody.A0;
import io.cucumber.java8.StepDefinitionBody.A1;
import io.cucumber.java8.StepDefinitionBody.A2;
import io.cucumber.java8.StepDefinitionBody.A3;
import io.cucumber.java8.StepDefinitionBody.A4;
import io.cucumber.java8.StepDefinitionBody.A5;
import io.cucumber.java8.StepDefinitionBody.A6;
import io.cucumber.java8.StepDefinitionBody.A7;
import io.cucumber.java8.StepDefinitionBody.A8;
import io.cucumber.java8.StepDefinitionBody.A9;

import io.cucumber.java8.LambdaGlueRegistry;
import io.cucumber.java8.Java8StepDefinition;
import io.cucumber.java8.LambdaGlue;

import org.apiguardian.api.API;

/**
 * French - français
 * 
 * To execute steps in a feature file the steps must be
 * connected to executable code. This can be done by
 * implementing this interface.
 * 

 * The parameters extracted from the step by the expression
 * along with the data table or doc string argument are provided as
 * arguments to the lambda expression.
 * 

 * The types of the parameters are determined by the cucumber or
 * regular expression.
 * 
 * The type of the data table or doc string argument is determined
 * by the argument name value. When none is provided cucumber will
 * attempt to transform the data table or doc string to the the
 * type of last argument.
 */
@API(status = API.Status.STABLE)
public interface Fr extends LambdaGlue {

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Alors(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Alors(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Alors(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Alors(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Alors(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Alors(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Alors(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Alors(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Alors(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Alors(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Donc(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Donc(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Donc(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Donc(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Donc(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Donc(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Donc(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Donc(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Donc(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Donc(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Et(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Et(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Et(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Et(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Et(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Et(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Et(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Et(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Et(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Et(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etqu(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etqu(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etqu(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etqu(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etqu(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etqu(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etqu(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etqu(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etqu(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etqu(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etque(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etque(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etque(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etque(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etque(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etque(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etque(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etque(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etque(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etque(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etantdonné(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etantdonné(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etantdonné(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etantdonné(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etantdonné(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etantdonné(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etantdonné(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etantdonné(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etantdonné(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etantdonné(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etantdonnéqu(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etantdonnéqu(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etantdonnéqu(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etantdonnéqu(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etantdonnéqu(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etantdonnéqu(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etantdonnéqu(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etantdonnéqu(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etantdonnéqu(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etantdonnéqu(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etantdonnéque(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etantdonnéque(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etantdonnéque(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etantdonnéque(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etantdonnéque(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etantdonnéque(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etantdonnéque(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etantdonnéque(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etantdonnéque(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etantdonnéque(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etantdonnée(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etantdonnée(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etantdonnée(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etantdonnée(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etantdonnée(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etantdonnée(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etantdonnée(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etantdonnée(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etantdonnée(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etantdonnée(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etantdonnées(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etantdonnées(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etantdonnées(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etantdonnées(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etantdonnées(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etantdonnées(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etantdonnées(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etantdonnées(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etantdonnées(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etantdonnées(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Etantdonnés(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Etantdonnés(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Etantdonnés(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Etantdonnés(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Etantdonnés(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Etantdonnés(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Etantdonnés(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Etantdonnés(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Etantdonnés(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Etantdonnés(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Lorsqu(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Lorsqu(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Lorsqu(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Lorsqu(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Lorsqu(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Lorsqu(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Lorsqu(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Lorsqu(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Lorsqu(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Lorsqu(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Lorsque(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Lorsque(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Lorsque(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Lorsque(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Lorsque(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Lorsque(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Lorsque(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Lorsque(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Lorsque(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Lorsque(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Mais(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Mais(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Mais(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Mais(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Mais(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Mais(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Mais(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Mais(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Mais(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Mais(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Maisqu(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Maisqu(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Maisqu(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Maisqu(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Maisqu(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Maisqu(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Maisqu(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Maisqu(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Maisqu(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Maisqu(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Maisque(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Maisque(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Maisque(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Maisque(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Maisque(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Maisque(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Maisque(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Maisque(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Maisque(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Maisque(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Quand(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Quand(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Quand(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Quand(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Quand(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Quand(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Quand(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Quand(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Quand(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Quand(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Sachant(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Sachant(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Sachant(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Sachant(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Sachant(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Sachant(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Sachant(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Sachant(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Sachant(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Sachant(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Sachantqu(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Sachantqu(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Sachantqu(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Sachantqu(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Sachantqu(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Sachantqu(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Sachantqu(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Sachantqu(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Sachantqu(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Sachantqu(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Sachantque(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Sachantque(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Sachantque(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Sachantque(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Sachantque(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Sachantque(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Sachantque(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Sachantque(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Sachantque(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Sachantque(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Soit(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Soit(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Soit(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Soit(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Soit(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Soit(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Soit(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Soit(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Soit(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Soit(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Étantdonné(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Étantdonné(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Étantdonné(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Étantdonné(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Étantdonné(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Étantdonné(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Étantdonné(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Étantdonné(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Étantdonné(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Étantdonné(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Étantdonnéqu(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Étantdonnéqu(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Étantdonnéqu(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Étantdonnéqu(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Étantdonnéqu(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Étantdonnéqu(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Étantdonnéqu(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Étantdonnéqu(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Étantdonnéqu(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Étantdonnéqu(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Étantdonnéque(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Étantdonnéque(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Étantdonnéque(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Étantdonnéque(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Étantdonnéque(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Étantdonnéque(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Étantdonnéque(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Étantdonnéque(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Étantdonnéque(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Étantdonnéque(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Étantdonnée(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Étantdonnée(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Étantdonnée(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Étantdonnée(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Étantdonnée(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Étantdonnée(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Étantdonnée(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Étantdonnée(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Étantdonnée(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Étantdonnée(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Étantdonnées(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Étantdonnées(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Étantdonnées(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Étantdonnées(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Étantdonnées(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Étantdonnées(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Étantdonnées(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Étantdonnées(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Étantdonnées(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Étantdonnées(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with no parameters
     */
    default void Étantdonnés(String expression, A0 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A0.class, body));
    }

    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 1 parameters
     * 
     * @param  type of argument 1 
     */
    default  void Étantdonnés(String expression, A1 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A1.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 2 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     */
    default  void Étantdonnés(String expression, A2 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A2.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 3 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     */
    default  void Étantdonnés(String expression, A3 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A3.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 4 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     */
    default  void Étantdonnés(String expression, A4 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A4.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 5 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     */
    default  void Étantdonnés(String expression, A5 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A5.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 6 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     */
    default  void Étantdonnés(String expression, A6 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A6.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 7 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     */
    default  void Étantdonnés(String expression, A7 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A7.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 8 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     */
    default  void Étantdonnés(String expression, A8 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A8.class, body));
    }
    
    /**
     * Creates a new step definition.
     *
     * @param expression the cucumber expression
     * @param body       a lambda expression with 9 parameters
     * 
     * @param  type of argument 1 
     * @param  type of argument 2 
     * @param  type of argument 3 
     * @param  type of argument 4 
     * @param  type of argument 5 
     * @param  type of argument 6 
     * @param  type of argument 7 
     * @param  type of argument 8 
     * @param  type of argument 9 
     */
    default  void Étantdonnés(String expression, A9 body) {
        LambdaGlueRegistry.INSTANCE.get().addStepDefinition(Java8StepDefinition.create(expression, A9.class, body));
    }
    

}