diff --git a/build.sbt b/build.sbt
index 52a77bf..cab7a60 100644
--- a/build.sbt
+++ b/build.sbt
@@ -17,8 +17,8 @@ inThisBuild(List(
   )
 ))
 
-val scala_2_12 = "2.12.7"
-val scala_2_13 = "2.13.6"
+val scala_2_12 = "2.12.20"
+val scala_2_13 = "2.13.16"
 
 scalaVersion := scala_2_13
 
@@ -41,7 +41,11 @@ libraryDependencies ++= Seq(
   "com.softwaremill.sttp.tapir" %% "tapir-core" % "1.2.7"
 )
 
-testOptions in Test ++= Seq(Tests.Argument("-oF"))
+Test / testOptions ++= Seq(Tests.Argument("-oF"))
+Test / fork := true
+Test / javaOptions ++= Seq(
+  "--add-opens=java.base/java.lang=ALL-UNNAMED"
+)
 
 scalacOptions ++= Seq(
   "-deprecation",
diff --git a/project/build.properties b/project/build.properties
index 46e43a9..bbb0b60 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=1.8.2
+sbt.version=1.11.2
diff --git a/src/main/scala/org/virtuslab/beholder/filters/BaseFilterComponent.scala b/src/main/scala/org/virtuslab/beholder/filters/BaseFilterComponent.scala
index 5752b36..90f30c2 100644
--- a/src/main/scala/org/virtuslab/beholder/filters/BaseFilterComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/filters/BaseFilterComponent.scala
@@ -2,21 +2,18 @@ package org.virtuslab.beholder.filters
 
 import org.virtuslab.beholder.views.BaseViewComponent
 import org.virtuslab.unicorn.UnicornWrapper
-import play.api.libs.json.Json
+import play.api.libs.json.{ Json, OFormat, Reads, Writes }
 import slick.ast.Ordering
 import slick.lifted.{ ColumnOrdered, Ordered }
 
 import scala.concurrent.ExecutionContext
 import sttp.tapir._
-import play.api.libs.json.Format
-import play.api.libs.json.Reads
-import play.api.libs.json.Writes
 
 case class Order(column: String, asc: Boolean)
 
 object Order {
-  implicit val format = Json.format[Order]
-  implicit val schema = Schema.derived[Order]
+  implicit val format: OFormat[Order] = Json.format[Order]
+  implicit val schema: Schema[Order] = Schema.derived[Order]
 }
 
 /**
@@ -39,7 +36,7 @@ object FilterRange {
   import sttp.tapir.Schema
   import play.api.libs.functional.syntax._
   import play.api.libs.json._
-  def schema[T: Schema](tname: String) = Schema.derived[FilterRange[T]].name(Schema.SName(s"FilterRange_$tname"))
+  def schema[T: Schema](tname: String): Schema[FilterRange[T]] = Schema.derived[FilterRange[T]].name(Schema.SName(s"FilterRange_$tname"))
   implicit def rangeFormat[T: Format]: Format[FilterRange[T]] =
     ((__ \ "from").formatNullable[T] and
       (__ \ "to").formatNullable[T])(FilterRange.apply, unlift(FilterRange.unapply))
@@ -139,7 +136,7 @@ trait BaseFilterComponent extends BaseViewComponent with FilterFieldComponent {
 
     //ordering
     private def order(data: FilterDefinition)(table: FilterTable): Option[(Rep[_], Boolean)] =
-      data.orderBy.map { case order => (table.columnByName(order.column), order.asc) }
+      data.orderBy.map(order => (table.columnByName(order.column), order.asc))
   }
 
   trait TableFilterAPI[Entity, Formatter, QueryBase] extends FilterAPI[Entity, Formatter] {
@@ -220,10 +217,7 @@ trait BaseFilterComponent extends BaseViewComponent with FilterFieldComponent {
   }
 
   case class FilterResult[T](data: Seq[T], total: Int) {
-
-    def this(data: Seq[T]) {
-      this(data, data.size)
-    }
+    def this(data: Seq[T]) = this(data, data.size)
   }
 
   object FilterResult {
diff --git a/src/main/scala/org/virtuslab/beholder/filters/FilterFactoryMethodsComponent.scala b/src/main/scala/org/virtuslab/beholder/filters/FilterFactoryMethodsComponent.scala
index 48cae29..6385606 100644
--- a/src/main/scala/org/virtuslab/beholder/filters/FilterFactoryMethodsComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/filters/FilterFactoryMethodsComponent.scala
@@ -3,7 +3,6 @@ package org.virtuslab.beholder.filters
 import org.virtuslab.beholder.views.FilterableViewsGenerateCodeComponent
 import org.virtuslab.unicorn.UnicornWrapper
 
-import scala.language.higherKinds
 import slick.ast.TypedType
 /**
  * Generated code
diff --git a/src/main/scala/org/virtuslab/beholder/filters/forms/FromFilterFieldsComponent.scala b/src/main/scala/org/virtuslab/beholder/filters/forms/FromFilterFieldsComponent.scala
index fa5d142..6e1dc1a 100644
--- a/src/main/scala/org/virtuslab/beholder/filters/forms/FromFilterFieldsComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/filters/forms/FromFilterFieldsComponent.scala
@@ -13,7 +13,6 @@ import slick.ast.{ BaseTypedType, TypedType }
 trait FromFilterFieldsComponent extends FilterFieldComponent with SeqParametersHelperComponent {
   self: UnicornWrapper[Long] =>
 
-  import unicorn._
   import unicorn.profile.api._
 
   abstract class FormFilterField[A: TypedType, B](mapping: Mapping[B]) extends MappedFilterField[A, B] {
diff --git a/src/main/scala/org/virtuslab/beholder/filters/json/JsonFilterFieldsComponent.scala b/src/main/scala/org/virtuslab/beholder/filters/json/JsonFilterFieldsComponent.scala
index 30191b1..70a3271 100644
--- a/src/main/scala/org/virtuslab/beholder/filters/json/JsonFilterFieldsComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/filters/json/JsonFilterFieldsComponent.scala
@@ -5,7 +5,6 @@ import org.virtuslab.beholder.filters._
 import org.virtuslab.beholder.utils.ILikeExtension._
 import org.virtuslab.beholder.utils.SeqParametersHelperComponent
 import org.virtuslab.unicorn.UnicornWrapper
-import play.api.libs.functional.syntax._
 import play.api.libs.json._
 import slick.ast.{ BaseTypedType, TypedType }
 import sttp.tapir._
diff --git a/src/main/scala/org/virtuslab/beholder/filters/json/JsonFormatterComponent.scala b/src/main/scala/org/virtuslab/beholder/filters/json/JsonFormatterComponent.scala
index b6960da..7ad8b02 100644
--- a/src/main/scala/org/virtuslab/beholder/filters/json/JsonFormatterComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/filters/json/JsonFormatterComponent.scala
@@ -49,7 +49,7 @@ trait JsonFormatterComponent extends JsonFilterFieldsComponent with BaseFilterCo
 
       override def reads(json: JsValue): JsResult[Seq[Option[Any]]] = json match {
         case jsObject: JsObject =>
-          jsObject.keys -- fieldFormatters.flatMap(_.filterColumnNames) match {
+          jsObject.keys.toSet -- fieldFormatters.flatMap(_.filterColumnNames) match {
             case badFields if badFields.nonEmpty =>
               JsError((JsPath(Nil), JsonValidationError("No such fields in filter: " + badFields)))
             case _ =>
diff --git a/src/main/scala/org/virtuslab/beholder/utils/ILikeExtension.scala b/src/main/scala/org/virtuslab/beholder/utils/ILikeExtension.scala
index ec1cd09..84c0f6c 100644
--- a/src/main/scala/org/virtuslab/beholder/utils/ILikeExtension.scala
+++ b/src/main/scala/org/virtuslab/beholder/utils/ILikeExtension.scala
@@ -18,18 +18,18 @@ object ILikeExtension {
    * escape underscores, percent signs and backslashes as they have special meaning in PostgreSQL's LIKE function
    * @see https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
    */
-  def escape(text: String) = text
+  def escape(text: String): String = text
     .replace(raw"""\""", raw"\\")
     .replace("%", raw"\%")
     .replace("_", raw"\_")
 
-  implicit def iLikeExtension(c: Rep[String]) = new ILikeExtension(c)
+  implicit def iLikeExtension(c: Rep[String]): ILikeExtension[String] = new ILikeExtension(c)
 
-  implicit def iLikeMappedExtension(c: Rep[MappedTo[String]]) = new ILikeExtension(c)
+  implicit def iLikeMappedExtension(c: Rep[MappedTo[String]]): ILikeExtension[MappedTo[String]] = new ILikeExtension(c)
 
-  implicit def iLikeOptionExtension(c: Rep[Option[String]]) = new ILikeExtension(c)
+  implicit def iLikeOptionExtension(c: Rep[Option[String]]): ILikeExtension[Option[String]] = new ILikeExtension(c)
 
-  implicit def seq2Ordered[T <% Ordered](t: IndexedSeq[T]) = new Ordered(t.flatMap(_.columns))
+  implicit def seq2Ordered[T](t: IndexedSeq[T])(implicit ev: T => Ordered): Ordered = new Ordered(t.flatMap(_.columns))
 }
 
 /**
@@ -37,7 +37,7 @@ object ILikeExtension {
  */
 class ILikeExtension[B](val c: Rep[B]) extends AnyVal with ExtensionMethods[String, B] {
 
-  def ilike[R](e: String)(implicit om: o#arg[String, B]#to[Boolean, R]) =
+  def ilike[R](e: String)(implicit om: o#arg[String, B]#to[Boolean, R]): Rep[R] =
     om.column(ILikeExtension.ILIKE, n, LiteralNode(e))
 
   override protected[this] implicit def b1Type: TypedType[String] = ???
diff --git a/src/main/scala/org/virtuslab/beholder/views/BaseViewComponent.scala b/src/main/scala/org/virtuslab/beholder/views/BaseViewComponent.scala
index f1539ce..3642803 100644
--- a/src/main/scala/org/virtuslab/beholder/views/BaseViewComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/views/BaseViewComponent.scala
@@ -3,8 +3,6 @@ package org.virtuslab.beholder.views
 import org.virtuslab.unicorn.UnicornWrapper
 import slick.ast.TypedType
 
-import scala.language.existentials
-
 trait BaseViewComponent {
   self: UnicornWrapper[Long] =>
 
@@ -25,7 +23,7 @@ trait BaseViewComponent {
     protected val columns: Seq[(String, this.type => Rep[_])]
     private lazy val columnsMap: Map[String, this.type => Rep[_]] = columns.toMap
 
-    final def columnsNames = columns.map(_._1)
+    final def columnsNames: Seq[String] = columns.map(_._1)
 
     /**
      * find column by name
@@ -48,7 +46,7 @@ trait BaseViewComponent {
   object BaseView {
 
     implicit class WithViewDDL(val query: TableQuery[_ <: BaseView[_, _]]) {
-      def viewDDL = ViewDDL(query.shaped.value)
+      def viewDDL: ViewDDL = ViewDDL(query.shaped.value)
     }
 
     case class ViewDDL(table: BaseView[_, _]) extends DDL {
diff --git a/src/main/scala/org/virtuslab/beholder/views/FilterableViewsComponent.scala b/src/main/scala/org/virtuslab/beholder/views/FilterableViewsComponent.scala
index b9ea9b9..bec5135 100644
--- a/src/main/scala/org/virtuslab/beholder/views/FilterableViewsComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/views/FilterableViewsComponent.scala
@@ -41,7 +41,7 @@ trait FilterableViewsComponent extends FilterableViewsGenerateCodeComponent {
 
     implicit val tupleShape = new TupleShape(s1, s2).asInstanceOf[Shape[_ <: slick.lifted.FlatShapeLevel, (slick.lifted.Rep[A], slick.lifted.Rep[B]), (A, B), _]]
 
-    def * = (c1, c2) <> (apply.tupled, unapply)
+    def * = (c1, c2).<>(apply.tupled, unapply)
   }
   // }
 
diff --git a/src/main/scala/org/virtuslab/beholder/views/FilterableViewsGenerateCodeComponent.scala b/src/main/scala/org/virtuslab/beholder/views/FilterableViewsGenerateCodeComponent.scala
index 83ccaf6..81f372a 100644
--- a/src/main/scala/org/virtuslab/beholder/views/FilterableViewsGenerateCodeComponent.scala
+++ b/src/main/scala/org/virtuslab/beholder/views/FilterableViewsGenerateCodeComponent.scala
@@ -2,7 +2,7 @@ package org.virtuslab.beholder.views
 
 import org.virtuslab.unicorn.UnicornWrapper
 import shapeless.Generic.Aux
-import shapeless.{ ::, Generic, HNil }
+import shapeless.{ ::, HNil }
 import slick.ast.TypedType
 import slick.lifted._
 import slickless._
@@ -36,7 +36,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2]), (A1, A2), _]]
 
-              (c1, c2) <> (apply.tupled, unapply)
+              (c1, c2).<>(apply.tupled, unapply)
           }
       }
     }
@@ -63,7 +63,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2]), (A1, A2), _]]
 
-    def * = (c1, c2) <> (apply.tupled, unapply)
+    def * = (c1, c2).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType](
@@ -85,7 +85,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3]), (A1, A2, A3), _]]
 
-              (c1, c2, c3) <> (apply.tupled, unapply)
+              (c1, c2, c3).<>(apply.tupled, unapply)
           }
       }
     }
@@ -114,7 +114,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3]), (A1, A2, A3), _]]
 
-    def * = (c1, c2, c3) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType](
@@ -136,7 +136,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4]), (A1, A2, A3, A4), _]]
 
-              (c1, c2, c3, c4) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4).<>(apply.tupled, unapply)
           }
       }
     }
@@ -167,7 +167,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4]), (A1, A2, A3, A4), _]]
 
-    def * = (c1, c2, c3, c4) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType](
@@ -189,7 +189,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5]), (A1, A2, A3, A4, A5), _]]
 
-              (c1, c2, c3, c4, c5) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5).<>(apply.tupled, unapply)
           }
       }
     }
@@ -222,7 +222,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5]), (A1, A2, A3, A4, A5), _]]
 
-    def * = (c1, c2, c3, c4, c5) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType](
@@ -244,7 +244,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6]), (A1, A2, A3, A4, A5, A6), _]]
 
-              (c1, c2, c3, c4, c5, c6) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6).<>(apply.tupled, unapply)
           }
       }
     }
@@ -279,7 +279,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6]), (A1, A2, A3, A4, A5, A6), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType](
@@ -301,7 +301,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7]), (A1, A2, A3, A4, A5, A6, A7), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7).<>(apply.tupled, unapply)
           }
       }
     }
@@ -338,7 +338,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7]), (A1, A2, A3, A4, A5, A6, A7), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType](
@@ -360,7 +360,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8]), (A1, A2, A3, A4, A5, A6, A7, A8), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8).<>(apply.tupled, unapply)
           }
       }
     }
@@ -399,7 +399,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8]), (A1, A2, A3, A4, A5, A6, A7, A8), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType](
@@ -421,7 +421,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9]), (A1, A2, A3, A4, A5, A6, A7, A8, A9), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9).<>(apply.tupled, unapply)
           }
       }
     }
@@ -462,7 +462,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9]), (A1, A2, A3, A4, A5, A6, A7, A8, A9), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType](
@@ -484,7 +484,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10).<>(apply.tupled, unapply)
           }
       }
     }
@@ -527,7 +527,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType](
@@ -549,7 +549,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11).<>(apply.tupled, unapply)
           }
       }
     }
@@ -594,7 +594,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType](
@@ -616,7 +616,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12).<>(apply.tupled, unapply)
           }
       }
     }
@@ -663,7 +663,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType](
@@ -685,7 +685,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13).<>(apply.tupled, unapply)
           }
       }
     }
@@ -734,7 +734,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType](
@@ -756,7 +756,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14).<>(apply.tupled, unapply)
           }
       }
     }
@@ -807,7 +807,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType](
@@ -829,7 +829,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15).<>(apply.tupled, unapply)
           }
       }
     }
@@ -882,7 +882,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType](
@@ -904,7 +904,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16).<>(apply.tupled, unapply)
           }
       }
     }
@@ -959,7 +959,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType](
@@ -981,7 +981,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17).<>(apply.tupled, unapply)
           }
       }
     }
@@ -1038,7 +1038,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType](
@@ -1060,7 +1060,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18).<>(apply.tupled, unapply)
           }
       }
     }
@@ -1119,7 +1119,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType](
@@ -1141,7 +1141,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19).<>(apply.tupled, unapply)
           }
       }
     }
@@ -1202,7 +1202,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType](
@@ -1224,7 +1224,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19], Rep[A20]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20).<>(apply.tupled, unapply)
           }
       }
     }
@@ -1287,7 +1287,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19], Rep[A20]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType](
@@ -1309,7 +1309,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19], Rep[A20], Rep[A21]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21).<>(apply.tupled, unapply)
           }
       }
     }
@@ -1374,7 +1374,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19], Rep[A20], Rep[A21]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType](
@@ -1396,7 +1396,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
               implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22)
                 .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19], Rep[A20], Rep[A21], Rep[A22]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22), _]]
 
-              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22) <> (apply.tupled, unapply)
+              (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22).<>(apply.tupled, unapply)
           }
       }
     }
@@ -1463,7 +1463,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
     implicit val tupleShape = new TupleShape(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22)
       .asInstanceOf[Shape[_ <: FlatShapeLevel, (Rep[A1], Rep[A2], Rep[A3], Rep[A4], Rep[A5], Rep[A6], Rep[A7], Rep[A8], Rep[A9], Rep[A10], Rep[A11], Rep[A12], Rep[A13], Rep[A14], Rep[A15], Rep[A16], Rep[A17], Rep[A18], Rep[A19], Rep[A20], Rep[A21], Rep[A22]), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22), _]]
 
-    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22) <> (apply.tupled, unapply)
+    def * = (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22).<>(apply.tupled, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType](
@@ -1483,7 +1483,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -1549,7 +1549,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(21) -> (_.c22),
       columnNames(22) -> (_.c23))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType](
@@ -1569,7 +1569,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -1637,7 +1637,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(22) -> (_.c23),
       columnNames(23) -> (_.c24))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType](
@@ -1657,7 +1657,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -1727,7 +1727,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(23) -> (_.c24),
       columnNames(24) -> (_.c25))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType](
@@ -1747,7 +1747,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -1819,7 +1819,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(24) -> (_.c25),
       columnNames(25) -> (_.c26))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType](
@@ -1839,7 +1839,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -1913,7 +1913,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(25) -> (_.c26),
       columnNames(26) -> (_.c27))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType](
@@ -1933,7 +1933,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2009,7 +2009,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(26) -> (_.c27),
       columnNames(27) -> (_.c28))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType](
@@ -2029,7 +2029,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2107,7 +2107,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(27) -> (_.c28),
       columnNames(28) -> (_.c29))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType](
@@ -2127,7 +2127,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2207,7 +2207,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(28) -> (_.c29),
       columnNames(29) -> (_.c30))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType](
@@ -2227,7 +2227,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2309,7 +2309,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(29) -> (_.c30),
       columnNames(30) -> (_.c31))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType](
@@ -2329,7 +2329,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2413,7 +2413,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(30) -> (_.c31),
       columnNames(31) -> (_.c32))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType](
@@ -2433,7 +2433,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2519,7 +2519,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(31) -> (_.c32),
       columnNames(32) -> (_.c33))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType](
@@ -2539,7 +2539,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2627,7 +2627,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(32) -> (_.c33),
       columnNames(33) -> (_.c34))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType](
@@ -2647,7 +2647,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2737,7 +2737,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(33) -> (_.c34),
       columnNames(34) -> (_.c35))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType](
@@ -2757,7 +2757,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2849,7 +2849,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(34) -> (_.c35),
       columnNames(35) -> (_.c36))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType](
@@ -2869,7 +2869,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -2963,7 +2963,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(35) -> (_.c36),
       columnNames(36) -> (_.c37))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType](
@@ -2983,7 +2983,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3079,7 +3079,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(36) -> (_.c37),
       columnNames(37) -> (_.c38))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType](
@@ -3099,7 +3099,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3197,7 +3197,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(37) -> (_.c38),
       columnNames(38) -> (_.c39))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType](
@@ -3217,7 +3217,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3317,7 +3317,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(38) -> (_.c39),
       columnNames(39) -> (_.c40))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType](
@@ -3337,7 +3337,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3439,7 +3439,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(39) -> (_.c40),
       columnNames(40) -> (_.c41))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType](
@@ -3459,7 +3459,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3563,7 +3563,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(40) -> (_.c41),
       columnNames(41) -> (_.c42))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType](
@@ -3583,7 +3583,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3689,7 +3689,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(41) -> (_.c42),
       columnNames(42) -> (_.c43))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType, A44: TypedType](
@@ -3709,7 +3709,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: (name44, c44) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43, name44)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3817,7 +3817,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(42) -> (_.c43),
       columnNames(43) -> (_.c44))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType, A44: TypedType, A45: TypedType](
@@ -3837,7 +3837,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: (name44, c44) :: (name45, c45) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43, name44, name45)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -3947,7 +3947,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(43) -> (_.c44),
       columnNames(44) -> (_.c45))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType, A44: TypedType, A45: TypedType, A46: TypedType](
@@ -3967,7 +3967,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: (name44, c44) :: (name45, c45) :: (name46, c46) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43, name44, name45, name46)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -4079,7 +4079,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(44) -> (_.c45),
       columnNames(45) -> (_.c46))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType, A44: TypedType, A45: TypedType, A46: TypedType, A47: TypedType](
@@ -4099,7 +4099,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: (name44, c44) :: (name45, c45) :: (name46, c46) :: (name47, c47) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43, name44, name45, name46, name47)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -4213,7 +4213,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(45) -> (_.c46),
       columnNames(46) -> (_.c47))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType, A44: TypedType, A45: TypedType, A46: TypedType, A47: TypedType, A48: TypedType](
@@ -4233,7 +4233,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: (name44, c44) :: (name45, c45) :: (name46, c46) :: (name47, c47) :: (name48, c48) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43, name44, name45, name46, name47, name48)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -4349,7 +4349,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(46) -> (_.c47),
       columnNames(47) -> (_.c48))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType, A44: TypedType, A45: TypedType, A46: TypedType, A47: TypedType, A48: TypedType, A49: TypedType](
@@ -4369,7 +4369,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: (name44, c44) :: (name45, c45) :: (name46, c46) :: (name47, c47) :: (name48, c48) :: (name49, c49) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43, name44, name45, name46, name47, name48, name49)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -4487,7 +4487,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(47) -> (_.c48),
       columnNames(48) -> (_.c49))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: HNil).<>(apply, unapply)
   }
 
   def createView[T: ClassTag, E, A1: TypedType, A2: TypedType, A3: TypedType, A4: TypedType, A5: TypedType, A6: TypedType, A7: TypedType, A8: TypedType, A9: TypedType, A10: TypedType, A11: TypedType, A12: TypedType, A13: TypedType, A14: TypedType, A15: TypedType, A16: TypedType, A17: TypedType, A18: TypedType, A19: TypedType, A20: TypedType, A21: TypedType, A22: TypedType, A23: TypedType, A24: TypedType, A25: TypedType, A26: TypedType, A27: TypedType, A28: TypedType, A29: TypedType, A30: TypedType, A31: TypedType, A32: TypedType, A33: TypedType, A34: TypedType, A35: TypedType, A36: TypedType, A37: TypedType, A38: TypedType, A39: TypedType, A40: TypedType, A41: TypedType, A42: TypedType, A43: TypedType, A44: TypedType, A45: TypedType, A46: TypedType, A47: TypedType, A48: TypedType, A49: TypedType, A50: TypedType](
@@ -4507,7 +4507,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
             case ((name1, c1) :: (name2, c2) :: (name3, c3) :: (name4, c4) :: (name5, c5) :: (name6, c6) :: (name7, c7) :: (name8, c8) :: (name9, c9) :: (name10, c10) :: (name11, c11) :: (name12, c12) :: (name13, c13) :: (name14, c14) :: (name15, c15) :: (name16, c16) :: (name17, c17) :: (name18, c18) :: (name19, c19) :: (name20, c20) :: (name21, c21) :: (name22, c22) :: (name23, c23) :: (name24, c24) :: (name25, c25) :: (name26, c26) :: (name27, c27) :: (name28, c28) :: (name29, c29) :: (name30, c30) :: (name31, c31) :: (name32, c32) :: (name33, c33) :: (name34, c34) :: (name35, c35) :: (name36, c36) :: (name37, c37) :: (name38, c38) :: (name39, c39) :: (name40, c40) :: (name41, c41) :: (name42, c42) :: (name43, c43) :: (name44, c44) :: (name45, c45) :: (name46, c46) :: (name47, c47) :: (name48, c48) :: (name49, c49) :: (name50, c50) :: HNil) =>
               columnsNames = Seq(name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15, name16, name17, name18, name19, name20, name21, name22, name23, name24, name25, name26, name27, name28, name29, name30, name31, name32, name33, name34, name35, name36, name37, name38, name39, name40, name41, name42, name43, name44, name45, name46, name47, name48, name49, name50)
 
-              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: c50 :: HNil) <> (apply, unapply)
+              (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: c50 :: HNil).<>(apply, unapply)
           }
       }
     }
@@ -4627,7 +4627,7 @@ trait FilterableViewsGenerateCodeComponent extends BaseViewComponent {
       columnNames(48) -> (_.c49),
       columnNames(49) -> (_.c50))
 
-    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: c50 :: HNil) <> (apply, unapply)
+    def * = (c1 :: c2 :: c3 :: c4 :: c5 :: c6 :: c7 :: c8 :: c9 :: c10 :: c11 :: c12 :: c13 :: c14 :: c15 :: c16 :: c17 :: c18 :: c19 :: c20 :: c21 :: c22 :: c23 :: c24 :: c25 :: c26 :: c27 :: c28 :: c29 :: c30 :: c31 :: c32 :: c33 :: c34 :: c35 :: c36 :: c37 :: c38 :: c39 :: c40 :: c41 :: c42 :: c43 :: c44 :: c45 :: c46 :: c47 :: c48 :: c49 :: c50 :: HNil).<>(apply, unapply)
   }
 
 }
\ No newline at end of file
diff --git a/src/test/scala/org/virtuslab/beholder/BaseTest.scala b/src/test/scala/org/virtuslab/beholder/BaseTest.scala
index 6c0793c..aa5dd8c 100644
--- a/src/test/scala/org/virtuslab/beholder/BaseTest.scala
+++ b/src/test/scala/org/virtuslab/beholder/BaseTest.scala
@@ -1,7 +1,8 @@
 package org.virtuslab.beholder
 
 import org.joda.time.DateTime
-import org.scalatest._
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.{Matchers => _, _}
 import org.scalatestplus.play.guice.GuiceFakeApplicationFactory
 import org.virtuslab.beholder.model.{LargeElement, Machine, MachineStatus, User}
 import org.virtuslab.beholder.repositories._
@@ -18,7 +19,7 @@ import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 import scala.util.{Failure, Try}
 
-trait BaseTest extends fixture.FlatSpecLike with Matchers with GuiceFakeApplicationFactory {
+trait BaseTest extends flatspec.FixtureAnyFlatSpecLike with Matchers with GuiceFakeApplicationFactory {
   import BaseTest.Fixture
 
   override type FixtureParam = Fixture
@@ -63,7 +64,7 @@ trait BaseTest extends fixture.FlatSpecLike with Matchers with GuiceFakeApplicat
       Await.result(DB.run(sqlu"""DROP ALL OBJECTS"""), Duration.Inf)
       withFixture(test.toNoArgTest(theFixture))
     } finally {
-      fakeApp.foreach(Play.stop(_))
+      fakeApp.foreach(Play.stop)
     }
   }
 
diff --git a/src/test/scala/org/virtuslab/beholder/UserMachinesView.scala b/src/test/scala/org/virtuslab/beholder/UserMachinesView.scala
index 8a7bb95..4ce1252 100644
--- a/src/test/scala/org/virtuslab/beholder/UserMachinesView.scala
+++ b/src/test/scala/org/virtuslab/beholder/UserMachinesView.scala
@@ -3,7 +3,7 @@ package org.virtuslab.beholder
 import java.sql.Date
 import org.virtuslab.beholder.model.{ MachineStatus, UserMachinesComponent }
 import org.virtuslab.beholder.views.FilterableViewsComponent
-import org.virtuslab.unicorn.{ UnicornPlay, UnicornWrapper }
+import org.virtuslab.unicorn.UnicornWrapper
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import sttp.tapir.Schema
diff --git a/src/test/scala/org/virtuslab/beholder/json/JsonFiltersSeqTest.scala b/src/test/scala/org/virtuslab/beholder/json/JsonFiltersSeqTest.scala
index 66741c2..ef53af1 100644
--- a/src/test/scala/org/virtuslab/beholder/json/JsonFiltersSeqTest.scala
+++ b/src/test/scala/org/virtuslab/beholder/json/JsonFiltersSeqTest.scala
@@ -4,7 +4,6 @@ import java.sql.Date
 
 import org.virtuslab.beholder.filters.FilterDefinition
 import org.virtuslab.beholder.{ BaseTest, UserMachineViewRow, UserMachinesViewComponent }
-import org.virtuslab.beholder.filters.forms.FromFilterFieldsComponent
 import org.virtuslab.beholder.filters.json.{ JsonFilterFieldsComponent, JsonFiltersComponent, JsonFormatterComponent }
 import org.virtuslab.beholder.model.MachineStatus
 import org.virtuslab.unicorn.{ UnicornPlay, UnicornWrapper }
diff --git a/src/test/scala/org/virtuslab/beholder/json/JsonFiltersTestForLargeElements.scala b/src/test/scala/org/virtuslab/beholder/json/JsonFiltersTestForLargeElements.scala
index d6bf4af..92bef0a 100644
--- a/src/test/scala/org/virtuslab/beholder/json/JsonFiltersTestForLargeElements.scala
+++ b/src/test/scala/org/virtuslab/beholder/json/JsonFiltersTestForLargeElements.scala
@@ -1,6 +1,5 @@
 package org.virtuslab.beholder.json
 
-import org.joda.time.DateTime
 import org.virtuslab.beholder.filters.json.{ JsonFilterFieldsComponent, JsonFiltersComponent, JsonFormatterComponent }
 import org.virtuslab.beholder.filters.{ FilterDefinition, FilterRange, Order }
 import org.virtuslab.beholder.model.{ LargeElement, LargeElementId }
diff --git a/src/test/scala/org/virtuslab/beholder/json/JsonFiltersVarLengthTest.scala b/src/test/scala/org/virtuslab/beholder/json/JsonFiltersVarLengthTest.scala
index ff65402..843cc11 100644
--- a/src/test/scala/org/virtuslab/beholder/json/JsonFiltersVarLengthTest.scala
+++ b/src/test/scala/org/virtuslab/beholder/json/JsonFiltersVarLengthTest.scala
@@ -42,8 +42,8 @@ class JsonFiltersVarLengthRepository(override val unicorn: UnicornPlay[Long])
       import play.api.libs.functional.syntax._
       import play.api.libs.json._
       (
-        (__ \ 'firstPart).formatWithDefault("") and
-        (__ \ 'secondPart).formatWithDefault("")).tupled
+        (__ \ "firstPart").formatWithDefault("") and
+        (__ \ "secondPart").formatWithDefault("")).tupled
     }
 
     override protected def filterOnColumn(column: Rep[String])(value: (String, String)): Rep[Option[Boolean]] = {
diff --git a/src/test/scala/org/virtuslab/beholder/model/MachineComponent.scala b/src/test/scala/org/virtuslab/beholder/model/MachineComponent.scala
index e899bd4..bdd80bd 100644
--- a/src/test/scala/org/virtuslab/beholder/model/MachineComponent.scala
+++ b/src/test/scala/org/virtuslab/beholder/model/MachineComponent.scala
@@ -1,7 +1,6 @@
 package org.virtuslab.beholder.model
 
 import java.sql.Date
-import java.util
 
 import org.virtuslab.unicorn.LongUnicornPlayIdentifiers.IdCompanion
 import org.virtuslab.unicorn.{ BaseId, UnicornWrapper, WithId }
@@ -9,18 +8,16 @@ import play.api.data.FormError
 import play.api.libs.json._
 import play.api.data.format.{ Formats, Formatter }
 
-import scala.language.implicitConversions
-
 trait BaseEnum {
   self: Enumeration =>
 
   //for play forms
   implicit lazy val mappingFormatter: Formatter[Value] = new Formatter[Value] {
 
-    override val format = Some(("format.numeric", Nil))
+    override val format: Option[(String, Seq[Any])] = Some(("format.numeric", Nil))
 
     override def bind(key: String, data: Map[String, String]): Either[Seq[FormError], Value] =
-      Formats.intFormat.bind(key, data).right.map(apply)
+      Formats.intFormat.bind(key, data).map(apply)
 
     override def unbind(key: String, value: Value): Map[String, String] =
       Map(key -> value.id.toString)
@@ -28,7 +25,7 @@ trait BaseEnum {
   }
 
   //for json forms
-  implicit val format = new Format[Value] {
+  implicit val format: Format[Value] = new Format[Value] {
     override def writes(o: Value): JsValue = JsNumber(o.id)
     override def reads(json: JsValue): JsResult[Value] = json.asOpt[Int].map(apply).map(JsSuccess(_)).getOrElse(JsError("format invalid"))
   }
@@ -107,7 +104,7 @@ trait MachineComponent extends EnumColumnMapper {
 
     def status = column[MachineStatus.Value]("status")
 
-    override def * = (id.?, url, system, cores, created, capacity, status) <> (Machine.tupled, Machine.unapply)
+    override def * = (id.?, url, system, cores, created, capacity, status).<>(Machine.tupled, Machine.unapply)
 
   }
 
diff --git a/src/test/scala/org/virtuslab/beholder/model/UserComponent.scala b/src/test/scala/org/virtuslab/beholder/model/UserComponent.scala
index f79c79a..3e44431 100644
--- a/src/test/scala/org/virtuslab/beholder/model/UserComponent.scala
+++ b/src/test/scala/org/virtuslab/beholder/model/UserComponent.scala
@@ -41,7 +41,7 @@ trait UserComponent {
 
     def lastName = column[String]("last_name")
 
-    override def * = (id.?, email, firstName, lastName) <> (User.tupled, User.unapply)
+    override def * = (id.?, email, firstName, lastName).<>(User.tupled, User.unapply)
   }
 
   class BaseUsersRepository extends BaseIdRepository[UserId, User, Users](TableQuery[Users])
diff --git a/src/test/scala/org/virtuslab/beholder/model/UserMachinesComponent.scala b/src/test/scala/org/virtuslab/beholder/model/UserMachinesComponent.scala
index 9e24d84..d75242c 100644
--- a/src/test/scala/org/virtuslab/beholder/model/UserMachinesComponent.scala
+++ b/src/test/scala/org/virtuslab/beholder/model/UserMachinesComponent.scala
@@ -1,7 +1,6 @@
 package org.virtuslab.beholder.model
 
-import org.virtuslab.unicorn.{ LongUnicornPlayJDBC, UnicornPlay, UnicornWrapper }
-import slick.lifted.ProvenShape
+import org.virtuslab.unicorn.UnicornWrapper
 
 trait UserMachinesComponent extends UserComponent with MachineComponent {
   self: UnicornWrapper[Long] =>
diff --git a/src/test/scala/org/virtuslab/beholder/repositories/LargeElementsRepository.scala b/src/test/scala/org/virtuslab/beholder/repositories/LargeElementsRepository.scala
index c6964fa..47641a1 100644
--- a/src/test/scala/org/virtuslab/beholder/repositories/LargeElementsRepository.scala
+++ b/src/test/scala/org/virtuslab/beholder/repositories/LargeElementsRepository.scala
@@ -1,13 +1,16 @@
 package org.virtuslab.beholder.repositories
 
-import org.virtuslab.beholder.model.{ LargeComponent, LargeElement }
+import org.virtuslab.beholder.model.{ LargeComponent, LargeElement, LargeElementId }
 import org.virtuslab.unicorn.{ UnicornPlay, UnicornWrapper }
 
 import scala.concurrent.ExecutionContext.Implicits.global
 
 class LargeElementsRepository(val unicorn: UnicornPlay[Long]) extends LargeComponent with UnicornWrapper[Long] {
-  def save(elem: LargeElement) = baseLargeElementsRepository.save(elem)
 
-  def create() = baseLargeElementsRepository.create
+  import unicorn.profile.api.DBIO
+
+  def save(elem: LargeElement): DBIO[LargeElementId] = baseLargeElementsRepository.save(elem)
+
+  def create(): DBIO[Unit] = baseLargeElementsRepository.create()
 
 }
diff --git a/src/test/scala/org/virtuslab/beholder/repositories/UsersRepository.scala b/src/test/scala/org/virtuslab/beholder/repositories/UsersRepository.scala
index 29ce358..a7dfcdd 100644
--- a/src/test/scala/org/virtuslab/beholder/repositories/UsersRepository.scala
+++ b/src/test/scala/org/virtuslab/beholder/repositories/UsersRepository.scala
@@ -1,12 +1,16 @@
 package org.virtuslab.beholder.repositories
 
-import org.virtuslab.beholder.model.{ User, UserComponent }
+import org.virtuslab.beholder.model.{ User, UserComponent, UserId }
 import org.virtuslab.unicorn.{ UnicornPlay, UnicornWrapper }
+
 import scala.concurrent.ExecutionContext.Implicits.global
 
 class UsersRepository(val unicorn: UnicornPlay[Long]) extends UserComponent with UnicornWrapper[Long] {
-  def save(elem: User) = baseUserBaseRepository.save(elem)
 
-  def create() = baseUserBaseRepository.create
+  import unicorn.profile.api.DBIO
+
+  def save(elem: User): DBIO[UserId] = baseUserBaseRepository.save(elem)
+
+  def create(): DBIO[Unit] = baseUserBaseRepository.create()
 
 }