diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1c3fd659..5776ecfe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,8 @@ See also the [CHANGELOG](https://github.com/cucumber/cucumber-jvm/blob/master/CH
 
 ### Changed
 
+- [Internal] Rewrite the way types of step arguments are inferred 
+
 ### Deprecated
 
 ### Removed
diff --git a/build.sbt b/build.sbt
index 660bd8a8..a693f993 100644
--- a/build.sbt
+++ b/build.sbt
@@ -88,8 +88,6 @@ lazy val cucumberScala = (projectMatrix in file("cucumber-scala"))
       CrossVersion.partialVersion(scalaVersion.value) match {
         case Some((2, n)) if n <= 12 =>
           List("org.scala-lang.modules" %% "scala-collection-compat" % "2.4.4")
-        case Some((3, 0)) =>
-          List("io.github.gaeljw" %% "typetrees" % "0.4.0")
         case _ => Nil
       }
     },
diff --git a/cucumber-scala/src/main/codegen/gen.scala b/cucumber-scala/src/main/codegen/gen.scala
index d67d9e3e..dca8b35c 100644
--- a/cucumber-scala/src/main/codegen/gen.scala
+++ b/cucumber-scala/src/main/codegen/gen.scala
@@ -1,35 +1,18 @@
 
-/*
- * Generates the evil looking apply methods in StepDsl#StepBody for Function1 to Function22
- */
-for (i <- 1 to 22) {
-  val ts = (1 to i).map("T".+).mkString(", ")
-  val f = "(" + ts + ") => Any"
-  val p1 = "def apply[" + ts + "](f: " + f + ")"
-  val p2 = "(implicit " + (1 to i).map(n => "m" + n + ":Manifest[T" + n + "]").mkString(", ") + ")"
-  val register = "\n  register(" +(1 to i).map(n => "m" + n).mkString(", ")  + ") {\n"
-  val pf = "    case List(" + (1 to i).map("a" + _ + ":AnyRef").mkString(", ") + ") => \n      f(" + (1 to i).map(n => "a" + n + ".asInstanceOf[T" + n + "]").mkString(",\n        ") + ")\n"
-  val otherwise = "    case _ =>\n          throw new IncorrectStepDefinitionException()\n"
-  val closeRegister = "  }\n}"
-
-  println(p1 + p2 + ": Unit = { " + register + pf + otherwise + closeRegister + "\n")
-}
-
 /*
  * Generates the evil looking apply methods in StepDsl#StepBody for Function1 to Function22
  * Scala 3
  */
 for (i <- 1 to 22) {
   val ts = (1 to i).map("T".+).mkString(", ")
-  val tagsDef = (1 to i).map(n => s"val t$n: TypeTreeTag = typeTreeTag[T$n]").mkString("\n")
-  val tagsParam = (1 to i).map(n => s"t$n").mkString(", ")
+  val implicits = (1 to i).map(n => s"t$n: Stepable[T$n]").mkString(", ")
+  val implicitsParams = (1 to i).map(n => s"t$n").mkString(", ")
   val listParams = (1 to i).map("a" + _ + ":AnyRef").mkString(", ")
   val pf =  (1 to i).map(n => "a" + n + ".asInstanceOf[T" + n + "]").mkString(",\n        ")
 
   println(s"""
-    |inline def apply[$ts](f: ($ts) => Any): Unit = {
-    |  $tagsDef
-    |  register($tagsParam) {
+    |def apply[$ts](f: ($ts) => Any)(using $implicits): Unit = {
+    |  register($implicitsParams) {
     |    case List($listParams) =>
     |      f($pf)
     |    case _ =>
@@ -58,4 +41,30 @@ for (i <- 1 to 22) {
       |""".stripMargin
 
   println(template)
-}
\ No newline at end of file
+}
+
+/*
+ * Generates the Stepable implicit methods
+ */
+for (i <- (1 to 9).reverse) {
+
+  val underscores = (1 to i).map(_ => "_").mkString(", ")
+  val types = (1 to i).map(j => s"X$j").mkString(", ")
+  val typesStepable = (1 to i).map(j => s"X$j: Stepable").mkString(", ")
+  val typeArgs = (1 to i).map(j => s"implicitly[Stepable[X$j]].asJavaType").mkString(", ")
+
+  val template =
+    s"""
+       |implicit def stepable$i[T[$underscores], $typesStepable](implicit ct: ClassTag[T[$types]]): Stepable[T[$types]] =
+       |    new Stepable[T[$types]] {
+       |      def asJavaType: JavaType =
+       |        new ScalaParameterizedType(
+       |          ct.runtimeClass,
+       |          Array(
+       |            $typeArgs
+       |          )
+       |        )
+       |    }""".stripMargin
+
+  println(template)
+}
diff --git a/cucumber-scala/src/main/scala-2/io/cucumber/scala/ScalaTypeHelper.scala b/cucumber-scala/src/main/scala-2/io/cucumber/scala/ScalaTypeHelper.scala
deleted file mode 100644
index a5d7fdfc..00000000
--- a/cucumber-scala/src/main/scala-2/io/cucumber/scala/ScalaTypeHelper.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-package io.cucumber.scala
-
-import java.lang.reflect.{ParameterizedType, Type}
-
-object ScalaTypeHelper {
-
-  def asJavaType(m: Manifest[_]): Type = {
-    if (m.typeArguments.isEmpty) {
-      m.runtimeClass
-    } else {
-      new ScalaParameterizedType(m)
-    }
-  }
-
-}
-
-class ScalaParameterizedType(manifest: Manifest[_]) extends ParameterizedType {
-
-  override def getActualTypeArguments: Array[Type] =
-    manifest.typeArguments.map(ScalaTypeHelper.asJavaType).toArray
-
-  override def getRawType: Type = manifest.runtimeClass
-
-  override def getOwnerType: Type = null
-
-}
diff --git a/cucumber-scala/src/main/scala-2/io/cucumber/scala/StepDsl.scala b/cucumber-scala/src/main/scala-2/io/cucumber/scala/StepDsl.scala
index 6f8510d5..b447dcfa 100644
--- a/cucumber-scala/src/main/scala-2/io/cucumber/scala/StepDsl.scala
+++ b/cucumber-scala/src/main/scala-2/io/cucumber/scala/StepDsl.scala
@@ -54,8 +54,8 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     /*
      * Generated apply1 to apply22 below
      */
-    def apply[T1](f: (T1) => Any)(implicit m1: Manifest[T1]): Unit = {
-      register(m1) {
+    def apply[T1](f: (T1) => Any)(implicit t1: Stepable[T1]): Unit = {
+      register(t1) {
         case List(a1: AnyRef) =>
           f(a1.asInstanceOf[T1])
         case _ =>
@@ -65,8 +65,8 @@ private[scala] trait StepDsl extends BaseScalaDsl {
 
     def apply[T1, T2](
         f: (T1, T2) => Any
-    )(implicit m1: Manifest[T1], m2: Manifest[T2]): Unit = {
-      register(m1, m2) {
+    )(implicit t1: Stepable[T1], t2: Stepable[T2]): Unit = {
+      register(t1, t2) {
         case List(a1: AnyRef, a2: AnyRef) =>
           f(a1.asInstanceOf[T1], a2.asInstanceOf[T2])
         case _ =>
@@ -76,8 +76,8 @@ private[scala] trait StepDsl extends BaseScalaDsl {
 
     def apply[T1, T2, T3](
         f: (T1, T2, T3) => Any
-    )(implicit m1: Manifest[T1], m2: Manifest[T2], m3: Manifest[T3]): Unit = {
-      register(m1, m2, m3) {
+    )(implicit t1: Stepable[T1], t2: Stepable[T2], t3: Stepable[T3]): Unit = {
+      register(t1, t2, t3) {
         case List(a1: AnyRef, a2: AnyRef, a3: AnyRef) =>
           f(a1.asInstanceOf[T1], a2.asInstanceOf[T2], a3.asInstanceOf[T3])
         case _ =>
@@ -86,12 +86,12 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     }
 
     def apply[T1, T2, T3, T4](f: (T1, T2, T3, T4) => Any)(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4]
     ): Unit = {
-      register(m1, m2, m3, m4) {
+      register(t1, t2, t3, t4) {
         case List(a1: AnyRef, a2: AnyRef, a3: AnyRef, a4: AnyRef) =>
           f(
             a1.asInstanceOf[T1],
@@ -105,13 +105,13 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     }
 
     def apply[T1, T2, T3, T4, T5](f: (T1, T2, T3, T4, T5) => Any)(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5]
     ): Unit = {
-      register(m1, m2, m3, m4, m5) {
+      register(t1, t2, t3, t4, t5) {
         case List(a1: AnyRef, a2: AnyRef, a3: AnyRef, a4: AnyRef, a5: AnyRef) =>
           f(
             a1.asInstanceOf[T1],
@@ -128,14 +128,14 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6](
         f: (T1, T2, T3, T4, T5, T6) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6) {
+      register(t1, t2, t3, t4, t5, t6) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -160,15 +160,15 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7](
         f: (T1, T2, T3, T4, T5, T6, T7) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7) {
+      register(t1, t2, t3, t4, t5, t6, t7) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -195,16 +195,16 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7, T8](
         f: (T1, T2, T3, T4, T5, T6, T7, T8) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7, m8) {
+      register(t1, t2, t3, t4, t5, t6, t7, t8) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -233,17 +233,17 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7, m8, m9) {
+      register(t1, t2, t3, t4, t5, t6, t7, t8, t9) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -274,18 +274,18 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) {
+      register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -318,19 +318,19 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) {
+      register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -365,20 +365,20 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) {
+      register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -415,21 +415,21 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) {
+      register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -468,22 +468,22 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14]
     ): Unit = {
-      register(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) {
+      register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) {
         case List(
               a1: AnyRef,
               a2: AnyRef,
@@ -540,38 +540,38 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T15
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15
       ) {
         case List(
               a1: AnyRef,
@@ -649,40 +649,40 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T16
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15],
-        m16: Manifest[T16]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15,
-        m16
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15,
+        t16
       ) {
         case List(
               a1: AnyRef,
@@ -764,42 +764,42 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T17
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15],
-        m16: Manifest[T16],
-        m17: Manifest[T17]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15,
-        m16,
-        m17
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15,
+        t16,
+        t17
       ) {
         case List(
               a1: AnyRef,
@@ -885,44 +885,44 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T18
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15],
-        m16: Manifest[T16],
-        m17: Manifest[T17],
-        m18: Manifest[T18]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15,
-        m16,
-        m17,
-        m18
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15,
+        t16,
+        t17,
+        t18
       ) {
         case List(
               a1: AnyRef,
@@ -1012,46 +1012,46 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T19
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15],
-        m16: Manifest[T16],
-        m17: Manifest[T17],
-        m18: Manifest[T18],
-        m19: Manifest[T19]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15,
-        m16,
-        m17,
-        m18,
-        m19
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15,
+        t16,
+        t17,
+        t18,
+        t19
       ) {
         case List(
               a1: AnyRef,
@@ -1145,48 +1145,48 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T20
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15],
-        m16: Manifest[T16],
-        m17: Manifest[T17],
-        m18: Manifest[T18],
-        m19: Manifest[T19],
-        m20: Manifest[T20]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19],
+        t20: Stepable[T20]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15,
-        m16,
-        m17,
-        m18,
-        m19,
-        m20
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15,
+        t16,
+        t17,
+        t18,
+        t19,
+        t20
       ) {
         case List(
               a1: AnyRef,
@@ -1284,50 +1284,50 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T21
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15],
-        m16: Manifest[T16],
-        m17: Manifest[T17],
-        m18: Manifest[T18],
-        m19: Manifest[T19],
-        m20: Manifest[T20],
-        m21: Manifest[T21]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19],
+        t20: Stepable[T20],
+        t21: Stepable[T21]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15,
-        m16,
-        m17,
-        m18,
-        m19,
-        m20,
-        m21
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15,
+        t16,
+        t17,
+        t18,
+        t19,
+        t20,
+        t21
       ) {
         case List(
               a1: AnyRef,
@@ -1429,52 +1429,52 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T22
         ) => Any
     )(implicit
-        m1: Manifest[T1],
-        m2: Manifest[T2],
-        m3: Manifest[T3],
-        m4: Manifest[T4],
-        m5: Manifest[T5],
-        m6: Manifest[T6],
-        m7: Manifest[T7],
-        m8: Manifest[T8],
-        m9: Manifest[T9],
-        m10: Manifest[T10],
-        m11: Manifest[T11],
-        m12: Manifest[T12],
-        m13: Manifest[T13],
-        m14: Manifest[T14],
-        m15: Manifest[T15],
-        m16: Manifest[T16],
-        m17: Manifest[T17],
-        m18: Manifest[T18],
-        m19: Manifest[T19],
-        m20: Manifest[T20],
-        m21: Manifest[T21],
-        m22: Manifest[T22]
+        t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19],
+        t20: Stepable[T20],
+        t21: Stepable[T21],
+        t22: Stepable[T22]
     ): Unit = {
       register(
-        m1,
-        m2,
-        m3,
-        m4,
-        m5,
-        m6,
-        m7,
-        m8,
-        m9,
-        m10,
-        m11,
-        m12,
-        m13,
-        m14,
-        m15,
-        m16,
-        m17,
-        m18,
-        m19,
-        m20,
-        m21,
-        m22
+        t1,
+        t2,
+        t3,
+        t4,
+        t5,
+        t6,
+        t7,
+        t8,
+        t9,
+        t10,
+        t11,
+        t12,
+        t13,
+        t14,
+        t15,
+        t16,
+        t17,
+        t18,
+        t19,
+        t20,
+        t21,
+        t22
       ) {
         case List(
               a1: AnyRef,
@@ -1530,9 +1530,9 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     }
 
     private def register(
-        manifests: Manifest[_ <: Any]*
+        tags: Stepable[_]*
     )(pf: PartialFunction[List[Any], Any]): Unit = {
-      val types = manifests.map(ScalaTypeHelper.asJavaType)
+      val types = tags.map(_.asJavaType)
       registry.registerStep(
         ScalaStepDetails(Utils.frame(self), name, regex, types, pf)
       )
diff --git a/cucumber-scala/src/main/scala-3/io/cucumber/scala/ScalaTypeHelper.scala b/cucumber-scala/src/main/scala-3/io/cucumber/scala/ScalaTypeHelper.scala
deleted file mode 100644
index 71daf762..00000000
--- a/cucumber-scala/src/main/scala-3/io/cucumber/scala/ScalaTypeHelper.scala
+++ /dev/null
@@ -1,27 +0,0 @@
-package io.cucumber.scala
-
-import io.github.gaeljw.typetrees.TypeTreeTag
-import java.lang.reflect.{ParameterizedType, Type}
-
-object ScalaTypeHelper {
-
-  def asJavaType(tag: TypeTreeTag): Type = {
-    if (tag.args.isEmpty) {
-      tag.self.runtimeClass
-    } else {
-      new ScalaParameterizedType(tag)
-    }
-  }
-
-}
-
-class ScalaParameterizedType(tag: TypeTreeTag) extends ParameterizedType {
-
-  override def getActualTypeArguments: Array[Type] =
-    tag.args.map(ScalaTypeHelper.asJavaType).toArray
-
-  override def getRawType: Type = tag.self.runtimeClass
-
-  override def getOwnerType: Type = null
-
-}
diff --git a/cucumber-scala/src/main/scala-3/io/cucumber/scala/StepDsl.scala b/cucumber-scala/src/main/scala-3/io/cucumber/scala/StepDsl.scala
index 3a94189e..89f5ff36 100644
--- a/cucumber-scala/src/main/scala-3/io/cucumber/scala/StepDsl.scala
+++ b/cucumber-scala/src/main/scala-3/io/cucumber/scala/StepDsl.scala
@@ -1,8 +1,5 @@
 package io.cucumber.scala
 
-import io.github.gaeljw.typetrees.TypeTreeTag
-import io.github.gaeljw.typetrees.TypeTreeTagMacros.typeTreeTag
-
 import scala.annotation.targetName
 
 private[scala] trait StepDsl extends BaseScalaDsl {
@@ -14,7 +11,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
 
   final class StepBody(name: String, regex: String) {
 
-    inline def apply(f: => Any): Unit = {
+    def apply(f: => Any): Unit = {
       register() {
         case Nil => f
         case _ =>
@@ -23,7 +20,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     }
 
     @targetName("apply_function0")
-    inline def apply(fun: () => Any): Unit = {
+    def apply(fun: () => Any): Unit = {
       register() {
         case Nil => fun.apply()
         case _ =>
@@ -34,8 +31,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     /*
      * Generated apply1 to apply22 below
      */
-    inline def apply[T1](f: (T1) => Any): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
+    def apply[T1](f: (T1) => Any)(using t1: Stepable[T1]): Unit = {
       register(t1) {
         case List(a1: AnyRef) =>
           f(a1.asInstanceOf[T1])
@@ -44,9 +40,9 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2](f: (T1, T2) => Any): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
+    def apply[T1, T2](
+        f: (T1, T2) => Any
+    )(using t1: Stepable[T1], t2: Stepable[T2]): Unit = {
       register(t1, t2) {
         case List(a1: AnyRef, a2: AnyRef) =>
           f(a1.asInstanceOf[T1], a2.asInstanceOf[T2])
@@ -55,10 +51,9 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3](f: (T1, T2, T3) => Any): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
+    def apply[T1, T2, T3](
+        f: (T1, T2, T3) => Any
+    )(using t1: Stepable[T1], t2: Stepable[T2], t3: Stepable[T3]): Unit = {
       register(t1, t2, t3) {
         case List(a1: AnyRef, a2: AnyRef, a3: AnyRef) =>
           f(a1.asInstanceOf[T1], a2.asInstanceOf[T2], a3.asInstanceOf[T3])
@@ -67,11 +62,12 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4](f: (T1, T2, T3, T4) => Any): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
+    def apply[T1, T2, T3, T4](f: (T1, T2, T3, T4) => Any)(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4]
+    ): Unit = {
       register(t1, t2, t3, t4) {
         case List(a1: AnyRef, a2: AnyRef, a3: AnyRef, a4: AnyRef) =>
           f(
@@ -85,14 +81,13 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5](
-        f: (T1, T2, T3, T4, T5) => Any
+    def apply[T1, T2, T3, T4, T5](f: (T1, T2, T3, T4, T5) => Any)(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
       register(t1, t2, t3, t4, t5) {
         case List(a1: AnyRef, a2: AnyRef, a3: AnyRef, a4: AnyRef, a5: AnyRef) =>
           f(
@@ -107,15 +102,14 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6](
-        f: (T1, T2, T3, T4, T5, T6) => Any
+    def apply[T1, T2, T3, T4, T5, T6](f: (T1, T2, T3, T4, T5, T6) => Any)(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
       register(t1, t2, t3, t4, t5, t6) {
         case List(
               a1: AnyRef,
@@ -138,16 +132,17 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6, T7](
+    def apply[T1, T2, T3, T4, T5, T6, T7](
         f: (T1, T2, T3, T4, T5, T6, T7) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
       register(t1, t2, t3, t4, t5, t6, t7) {
         case List(
               a1: AnyRef,
@@ -172,17 +167,18 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6, T7, T8](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8](
         f: (T1, T2, T3, T4, T5, T6, T7, T8) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
       register(t1, t2, t3, t4, t5, t6, t7, t8) {
         case List(
               a1: AnyRef,
@@ -209,18 +205,19 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
       register(t1, t2, t3, t4, t5, t6, t7, t8, t9) {
         case List(
               a1: AnyRef,
@@ -249,19 +246,20 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
       register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) {
         case List(
               a1: AnyRef,
@@ -292,20 +290,21 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
       register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) {
         case List(
               a1: AnyRef,
@@ -338,21 +337,22 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
       register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) {
         case List(
               a1: AnyRef,
@@ -387,22 +387,23 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
       register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) {
         case List(
               a1: AnyRef,
@@ -439,38 +440,24 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
-        T1,
-        T2,
-        T3,
-        T4,
-        T5,
-        T6,
-        T7,
-        T8,
-        T9,
-        T10,
-        T11,
-        T12,
-        T13,
-        T14
-    ](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](
         f: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
       register(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) {
         case List(
               a1: AnyRef,
@@ -509,23 +496,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
-        T1,
-        T2,
-        T3,
-        T4,
-        T5,
-        T6,
-        T7,
-        T8,
-        T9,
-        T10,
-        T11,
-        T12,
-        T13,
-        T14,
-        T15
-    ](
+    def apply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](
         f: (
             T1,
             T2,
@@ -543,22 +514,23 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T14,
             T15
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
       register(
         t1,
         t2,
@@ -615,7 +587,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
+    def apply[
         T1,
         T2,
         T3,
@@ -651,23 +623,24 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T15,
             T16
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
-      val t16: TypeTreeTag = typeTreeTag[T16]
       register(
         t1,
         t2,
@@ -727,7 +700,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
+    def apply[
         T1,
         T2,
         T3,
@@ -765,24 +738,25 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T16,
             T17
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
-      val t16: TypeTreeTag = typeTreeTag[T16]
-      val t17: TypeTreeTag = typeTreeTag[T17]
       register(
         t1,
         t2,
@@ -845,7 +819,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
+    def apply[
         T1,
         T2,
         T3,
@@ -885,25 +859,26 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T17,
             T18
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
-      val t16: TypeTreeTag = typeTreeTag[T16]
-      val t17: TypeTreeTag = typeTreeTag[T17]
-      val t18: TypeTreeTag = typeTreeTag[T18]
       register(
         t1,
         t2,
@@ -969,7 +944,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
+    def apply[
         T1,
         T2,
         T3,
@@ -1011,26 +986,27 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T18,
             T19
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
-      val t16: TypeTreeTag = typeTreeTag[T16]
-      val t17: TypeTreeTag = typeTreeTag[T17]
-      val t18: TypeTreeTag = typeTreeTag[T18]
-      val t19: TypeTreeTag = typeTreeTag[T19]
       register(
         t1,
         t2,
@@ -1099,7 +1075,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
+    def apply[
         T1,
         T2,
         T3,
@@ -1143,27 +1119,28 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T19,
             T20
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19],
+        t20: Stepable[T20]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
-      val t16: TypeTreeTag = typeTreeTag[T16]
-      val t17: TypeTreeTag = typeTreeTag[T17]
-      val t18: TypeTreeTag = typeTreeTag[T18]
-      val t19: TypeTreeTag = typeTreeTag[T19]
-      val t20: TypeTreeTag = typeTreeTag[T20]
       register(
         t1,
         t2,
@@ -1235,7 +1212,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
+    def apply[
         T1,
         T2,
         T3,
@@ -1281,28 +1258,29 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T20,
             T21
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19],
+        t20: Stepable[T20],
+        t21: Stepable[T21]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
-      val t16: TypeTreeTag = typeTreeTag[T16]
-      val t17: TypeTreeTag = typeTreeTag[T17]
-      val t18: TypeTreeTag = typeTreeTag[T18]
-      val t19: TypeTreeTag = typeTreeTag[T19]
-      val t20: TypeTreeTag = typeTreeTag[T20]
-      val t21: TypeTreeTag = typeTreeTag[T21]
       register(
         t1,
         t2,
@@ -1377,7 +1355,7 @@ private[scala] trait StepDsl extends BaseScalaDsl {
       }
     }
 
-    inline def apply[
+    def apply[
         T1,
         T2,
         T3,
@@ -1425,29 +1403,30 @@ private[scala] trait StepDsl extends BaseScalaDsl {
             T21,
             T22
         ) => Any
+    )(
+        using t1: Stepable[T1],
+        t2: Stepable[T2],
+        t3: Stepable[T3],
+        t4: Stepable[T4],
+        t5: Stepable[T5],
+        t6: Stepable[T6],
+        t7: Stepable[T7],
+        t8: Stepable[T8],
+        t9: Stepable[T9],
+        t10: Stepable[T10],
+        t11: Stepable[T11],
+        t12: Stepable[T12],
+        t13: Stepable[T13],
+        t14: Stepable[T14],
+        t15: Stepable[T15],
+        t16: Stepable[T16],
+        t17: Stepable[T17],
+        t18: Stepable[T18],
+        t19: Stepable[T19],
+        t20: Stepable[T20],
+        t21: Stepable[T21],
+        t22: Stepable[T22]
     ): Unit = {
-      val t1: TypeTreeTag = typeTreeTag[T1]
-      val t2: TypeTreeTag = typeTreeTag[T2]
-      val t3: TypeTreeTag = typeTreeTag[T3]
-      val t4: TypeTreeTag = typeTreeTag[T4]
-      val t5: TypeTreeTag = typeTreeTag[T5]
-      val t6: TypeTreeTag = typeTreeTag[T6]
-      val t7: TypeTreeTag = typeTreeTag[T7]
-      val t8: TypeTreeTag = typeTreeTag[T8]
-      val t9: TypeTreeTag = typeTreeTag[T9]
-      val t10: TypeTreeTag = typeTreeTag[T10]
-      val t11: TypeTreeTag = typeTreeTag[T11]
-      val t12: TypeTreeTag = typeTreeTag[T12]
-      val t13: TypeTreeTag = typeTreeTag[T13]
-      val t14: TypeTreeTag = typeTreeTag[T14]
-      val t15: TypeTreeTag = typeTreeTag[T15]
-      val t16: TypeTreeTag = typeTreeTag[T16]
-      val t17: TypeTreeTag = typeTreeTag[T17]
-      val t18: TypeTreeTag = typeTreeTag[T18]
-      val t19: TypeTreeTag = typeTreeTag[T19]
-      val t20: TypeTreeTag = typeTreeTag[T20]
-      val t21: TypeTreeTag = typeTreeTag[T21]
-      val t22: TypeTreeTag = typeTreeTag[T22]
       register(
         t1,
         t2,
@@ -1526,9 +1505,9 @@ private[scala] trait StepDsl extends BaseScalaDsl {
     }
 
     private def register(
-        tags: TypeTreeTag*
+        tags: Stepable[_]*
     )(pf: PartialFunction[List[Any], Any]): Unit = {
-      val types = tags.map(ScalaTypeHelper.asJavaType)
+      val types = tags.map(_.asJavaType)
       registry.registerStep(
         ScalaStepDetails(Utils.frame(self), name, regex, types, pf)
       )
diff --git a/cucumber-scala/src/main/scala/io/cucumber/scala/Stepable.scala b/cucumber-scala/src/main/scala/io/cucumber/scala/Stepable.scala
new file mode 100644
index 00000000..ca6219e5
--- /dev/null
+++ b/cucumber-scala/src/main/scala/io/cucumber/scala/Stepable.scala
@@ -0,0 +1,231 @@
+package io.cucumber.scala
+
+import java.lang.reflect.{
+  ParameterizedType => JavaParameterizedType,
+  Type => JavaType
+}
+import scala.reflect.ClassTag
+
+/** Indicates that a type `T` can be used in step definitions
+  */
+trait Stepable[T] {
+  def asJavaType: JavaType
+}
+
+object Stepable {
+
+  implicit def stepable9[T[
+      _,
+      _,
+      _,
+      _,
+      _,
+      _,
+      _,
+      _,
+      _
+  ], X1: Stepable, X2: Stepable, X3: Stepable, X4: Stepable, X5: Stepable, X6: Stepable, X7: Stepable, X8: Stepable, X9: Stepable](
+      implicit ct: ClassTag[T[X1, X2, X3, X4, X5, X6, X7, X8, X9]]
+  ): Stepable[T[X1, X2, X3, X4, X5, X6, X7, X8, X9]] =
+    new Stepable[T[X1, X2, X3, X4, X5, X6, X7, X8, X9]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType,
+            implicitly[Stepable[X3]].asJavaType,
+            implicitly[Stepable[X4]].asJavaType,
+            implicitly[Stepable[X5]].asJavaType,
+            implicitly[Stepable[X6]].asJavaType,
+            implicitly[Stepable[X7]].asJavaType,
+            implicitly[Stepable[X8]].asJavaType,
+            implicitly[Stepable[X9]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable8[T[
+      _,
+      _,
+      _,
+      _,
+      _,
+      _,
+      _,
+      _
+  ], X1: Stepable, X2: Stepable, X3: Stepable, X4: Stepable, X5: Stepable, X6: Stepable, X7: Stepable, X8: Stepable](
+      implicit ct: ClassTag[T[X1, X2, X3, X4, X5, X6, X7, X8]]
+  ): Stepable[T[X1, X2, X3, X4, X5, X6, X7, X8]] =
+    new Stepable[T[X1, X2, X3, X4, X5, X6, X7, X8]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType,
+            implicitly[Stepable[X3]].asJavaType,
+            implicitly[Stepable[X4]].asJavaType,
+            implicitly[Stepable[X5]].asJavaType,
+            implicitly[Stepable[X6]].asJavaType,
+            implicitly[Stepable[X7]].asJavaType,
+            implicitly[Stepable[X8]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable7[T[
+      _,
+      _,
+      _,
+      _,
+      _,
+      _,
+      _
+  ], X1: Stepable, X2: Stepable, X3: Stepable, X4: Stepable, X5: Stepable, X6: Stepable, X7: Stepable](
+      implicit ct: ClassTag[T[X1, X2, X3, X4, X5, X6, X7]]
+  ): Stepable[T[X1, X2, X3, X4, X5, X6, X7]] =
+    new Stepable[T[X1, X2, X3, X4, X5, X6, X7]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType,
+            implicitly[Stepable[X3]].asJavaType,
+            implicitly[Stepable[X4]].asJavaType,
+            implicitly[Stepable[X5]].asJavaType,
+            implicitly[Stepable[X6]].asJavaType,
+            implicitly[Stepable[X7]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable6[T[
+      _,
+      _,
+      _,
+      _,
+      _,
+      _
+  ], X1: Stepable, X2: Stepable, X3: Stepable, X4: Stepable, X5: Stepable, X6: Stepable](
+      implicit ct: ClassTag[T[X1, X2, X3, X4, X5, X6]]
+  ): Stepable[T[X1, X2, X3, X4, X5, X6]] =
+    new Stepable[T[X1, X2, X3, X4, X5, X6]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType,
+            implicitly[Stepable[X3]].asJavaType,
+            implicitly[Stepable[X4]].asJavaType,
+            implicitly[Stepable[X5]].asJavaType,
+            implicitly[Stepable[X6]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable5[T[
+      _,
+      _,
+      _,
+      _,
+      _
+  ], X1: Stepable, X2: Stepable, X3: Stepable, X4: Stepable, X5: Stepable](
+      implicit ct: ClassTag[T[X1, X2, X3, X4, X5]]
+  ): Stepable[T[X1, X2, X3, X4, X5]] =
+    new Stepable[T[X1, X2, X3, X4, X5]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType,
+            implicitly[Stepable[X3]].asJavaType,
+            implicitly[Stepable[X4]].asJavaType,
+            implicitly[Stepable[X5]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable4[T[
+      _,
+      _,
+      _,
+      _
+  ], X1: Stepable, X2: Stepable, X3: Stepable, X4: Stepable](implicit
+      ct: ClassTag[T[X1, X2, X3, X4]]
+  ): Stepable[T[X1, X2, X3, X4]] =
+    new Stepable[T[X1, X2, X3, X4]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType,
+            implicitly[Stepable[X3]].asJavaType,
+            implicitly[Stepable[X4]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable3[T[_, _, _], X1: Stepable, X2: Stepable, X3: Stepable](
+      implicit ct: ClassTag[T[X1, X2, X3]]
+  ): Stepable[T[X1, X2, X3]] =
+    new Stepable[T[X1, X2, X3]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType,
+            implicitly[Stepable[X3]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable2[T[_, _], X1: Stepable, X2: Stepable](implicit
+      ct: ClassTag[T[X1, X2]]
+  ): Stepable[T[X1, X2]] =
+    new Stepable[T[X1, X2]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType,
+            implicitly[Stepable[X2]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable1[T[_], X1: Stepable](implicit
+      ct: ClassTag[T[X1]]
+  ): Stepable[T[X1]] =
+    new Stepable[T[X1]] {
+      def asJavaType: JavaType =
+        new ScalaParameterizedType(
+          ct.runtimeClass,
+          Array(
+            implicitly[Stepable[X1]].asJavaType
+          )
+        )
+    }
+
+  implicit def stepable0[T: ClassTag]: Stepable[T] =
+    new Stepable[T] {
+      def asJavaType: JavaType = implicitly[ClassTag[T]].runtimeClass
+    }
+
+}
+
+class ScalaParameterizedType(self: JavaType, args: Array[JavaType])
+    extends JavaParameterizedType {
+
+  override def getActualTypeArguments: Array[JavaType] = args
+
+  override def getRawType: JavaType = self
+
+  override def getOwnerType: JavaType = null
+
+}
diff --git a/cucumber-scala/src/test/scala-3/io/cucumber/scala/ScalaDslStepsTest.scala b/cucumber-scala/src/test/scala-3/io/cucumber/scala/ScalaDslStepsTest.scala
index 854b6b56..6d02b688 100644
--- a/cucumber-scala/src/test/scala-3/io/cucumber/scala/ScalaDslStepsTest.scala
+++ b/cucumber-scala/src/test/scala-3/io/cucumber/scala/ScalaDslStepsTest.scala
@@ -49,7 +49,7 @@ class ScalaDslStepsTest {
     assertClassStepDefinition(
       glue.registry.stepDefinitions.head,
       "Something",
-      "ScalaDslStepsTest.scala:44",
+      "ScalaDslStepsTest.scala:43",
       Array(),
       invoked
     )
@@ -119,7 +119,7 @@ class ScalaDslStepsTest {
       classOf[IncorrectStepDefinitionException],
       "io.cucumber.scala.ScalaDslStepsTest",
       "ScalaDslStepsTest.scala",
-      109,
+      323,
       Array(null)
     )
   }
@@ -162,7 +162,7 @@ class ScalaDslStepsTest {
     assertObjectStepDefinition(
       Glue.registry.stepDefinitions.head,
       "Something",
-      "ScalaDslStepsTest.scala:159",
+      "ScalaDslStepsTest.scala:158",
       Array(),
       invoked
     )
@@ -226,7 +226,7 @@ class ScalaDslStepsTest {
       classOf[IncorrectStepDefinitionException],
       "io.cucumber.scala.ScalaDslStepsTest",
       "ScalaDslStepsTest.scala",
-      218,
+      323,
       Array(null)
     )
   }
diff --git a/cucumber-scala/src/test/scala/io/cucumber/scala/StepableTest.scala b/cucumber-scala/src/test/scala/io/cucumber/scala/StepableTest.scala
new file mode 100644
index 00000000..73473b6a
--- /dev/null
+++ b/cucumber-scala/src/test/scala/io/cucumber/scala/StepableTest.scala
@@ -0,0 +1,219 @@
+package io.cucumber.scala
+
+import io.cucumber.datatable.DataTable
+import org.junit.Assert.{assertEquals, assertTrue}
+import org.junit.Test
+
+import java.lang.reflect.{ParameterizedType => JavaParameterizedType}
+import java.util.{List => JavaList, Map => JavaMap}
+
+class StepableTest {
+
+  case class SomeCaseClass(a: String, b: Int)
+
+  class RegularClass {}
+
+  class GenericClass[T] {}
+
+  @Test
+  def availableImplicitForSimpleTypes(): Unit = {
+    assertEquals(classOf[String], implicitly[Stepable[String]].asJavaType)
+    assertEquals(classOf[Int], implicitly[Stepable[Int]].asJavaType)
+    assertEquals(classOf[Long], implicitly[Stepable[Long]].asJavaType)
+  }
+
+  @Test
+  def availableImplicitForSimpleTypeDatatable(): Unit = {
+    assertEquals(classOf[DataTable], implicitly[Stepable[DataTable]].asJavaType)
+  }
+
+  @Test
+  def availableImplicitForCaseClass(): Unit = {
+    assertEquals(
+      classOf[SomeCaseClass],
+      implicitly[Stepable[SomeCaseClass]].asJavaType
+    )
+  }
+
+  @Test
+  def availableImplicitForRegularClass(): Unit = {
+    assertEquals(
+      classOf[RegularClass],
+      implicitly[Stepable[RegularClass]].asJavaType
+    )
+  }
+
+  @Test
+  def availableImplicitForSimpleJavaList(): Unit = {
+    val javaType = implicitly[Stepable[JavaList[String]]].asJavaType
+    assertTrue(javaType.isInstanceOf[JavaParameterizedType])
+    assertEquals(
+      classOf[JavaList[_]],
+      javaType.asInstanceOf[JavaParameterizedType].getRawType
+    )
+    assertEquals(
+      1L,
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments
+        .length
+        .toLong
+    )
+    assertEquals(
+      classOf[String],
+      javaType.asInstanceOf[JavaParameterizedType].getActualTypeArguments()(0)
+    )
+  }
+
+  @Test
+  def availableImplicitForCaseClassJavaList(): Unit = {
+    val javaType = implicitly[Stepable[JavaList[SomeCaseClass]]].asJavaType
+    assertTrue(javaType.isInstanceOf[JavaParameterizedType])
+    assertEquals(
+      classOf[JavaList[_]],
+      javaType.asInstanceOf[JavaParameterizedType].getRawType
+    )
+    assertEquals(
+      1L,
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments
+        .length
+        .toLong
+    )
+    assertEquals(
+      classOf[SomeCaseClass],
+      javaType.asInstanceOf[JavaParameterizedType].getActualTypeArguments()(0)
+    )
+  }
+
+  @Test
+  def availableImplicitForJavaListOfMaps(): Unit = {
+    val javaType =
+      implicitly[Stepable[JavaList[JavaMap[String, Int]]]].asJavaType
+    assertTrue(javaType.isInstanceOf[JavaParameterizedType])
+    assertEquals(
+      classOf[JavaList[_]],
+      javaType.asInstanceOf[JavaParameterizedType].getRawType
+    )
+    assertEquals(
+      1L,
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments
+        .length
+        .toLong
+    )
+    assertTrue(
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments()(0)
+        .isInstanceOf[JavaParameterizedType]
+    )
+    assertEquals(
+      classOf[JavaMap[_, _]],
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments()(0)
+        .asInstanceOf[JavaParameterizedType]
+        .getRawType
+    )
+    assertEquals(
+      2L,
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments()(0)
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments
+        .length
+        .toLong
+    )
+    assertEquals(
+      classOf[String],
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments()(0)
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments()(0)
+    )
+    assertEquals(
+      classOf[Int],
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments()(0)
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments()(1)
+    )
+  }
+
+  @Test
+  def availableImplicitForRegularClassJavaList(): Unit = {
+    val javaType = implicitly[Stepable[JavaList[RegularClass]]].asJavaType
+    assertTrue(javaType.isInstanceOf[JavaParameterizedType])
+    assertEquals(
+      classOf[JavaList[_]],
+      javaType.asInstanceOf[JavaParameterizedType].getRawType
+    )
+    assertEquals(
+      1L,
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments
+        .length
+        .toLong
+    )
+    assertEquals(
+      classOf[RegularClass],
+      javaType.asInstanceOf[JavaParameterizedType].getActualTypeArguments()(0)
+    )
+  }
+
+  @Test
+  def availableImplicitForSimpleJavaMap(): Unit = {
+    val javaType = implicitly[Stepable[JavaMap[String, Int]]].asJavaType
+    assertTrue(javaType.isInstanceOf[JavaParameterizedType])
+    assertEquals(
+      classOf[JavaMap[_, _]],
+      javaType.asInstanceOf[JavaParameterizedType].getRawType
+    )
+    assertEquals(
+      2L,
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments
+        .length
+        .toLong
+    )
+    assertEquals(
+      classOf[String],
+      javaType.asInstanceOf[JavaParameterizedType].getActualTypeArguments()(0)
+    )
+    assertEquals(
+      classOf[Int],
+      javaType.asInstanceOf[JavaParameterizedType].getActualTypeArguments()(1)
+    )
+  }
+
+  @Test
+  def availableImplicitForGenericClass(): Unit = {
+    val javaType = implicitly[Stepable[GenericClass[Int]]].asJavaType
+    assertTrue(javaType.isInstanceOf[JavaParameterizedType])
+    assertEquals(
+      classOf[GenericClass[_]],
+      javaType.asInstanceOf[JavaParameterizedType].getRawType
+    )
+    assertEquals(
+      1L,
+      javaType
+        .asInstanceOf[JavaParameterizedType]
+        .getActualTypeArguments
+        .length
+        .toLong
+    )
+    assertEquals(
+      classOf[Int],
+      javaType.asInstanceOf[JavaParameterizedType].getActualTypeArguments()(0)
+    )
+  }
+
+}
diff --git a/project/ScalacOptions.scala b/project/ScalacOptions.scala
index 872830da..3c822f0a 100644
--- a/project/ScalacOptions.scala
+++ b/project/ScalacOptions.scala
@@ -62,7 +62,8 @@ object ScalacOptions {
     "-encoding",
     "utf-8", // Specify character encoding used by source files.
     "-feature", // Emit warning and location for usages of features that should be imported explicitly.
-    "-language:implicitConversions" // Allow definition of implicit functions called views
+    "-language:implicitConversions", // Allow definition of implicit functions called views
+    "-language:higherKinds" // Allow higher-kinded types
   )
 
   val scalacOptions211 = Seq(
@@ -71,6 +72,7 @@ object ScalacOptions {
     "UTF-8", // yes, this is 2 args
     "-feature",
     "-language:implicitConversions",
+    "-language:higherKinds", // Allow higher-kinded types
     "-target:jvm-1.8"
   )