diff --git a/build.sbt b/build.sbt
index 2fa91f12..7f16aad4 100644
--- a/build.sbt
+++ b/build.sbt
@@ -99,10 +99,10 @@ def paradiseFlag(scalaVersion: String): Seq[String] =
 
 val scalaTest       = Def.setting("org.scalatest" %%% "scalatest" % "3.2.17")
 val scalaCheck      = Def.setting("org.scalacheck" %%% "scalacheck" % "1.17.0")
-val slick           = "com.typesafe.slick" %% "slick" % "3.4.1"
+val slick           = "com.typesafe.slick" %% "slick" % "3.5.0"
 val optionalSlick   = optional(slick)
 val playJson        = "com.typesafe.play" %% "play-json" % "2.10.1"
-val slickPg         = "com.github.tminglei" %% "slick-pg" % "0.21.1"
+val slickPg         = "com.github.tminglei" %% "slick-pg" % "0.22.0"
 val doobie          = "org.tpolecat" %% "doobie-core" % "1.0.0-RC4"
 val doobiePg        = "org.tpolecat" %% "doobie-postgres" % "1.0.0-RC4"
 val sprayJson       = "io.spray" %% "spray-json" % "1.3.6"
@@ -176,7 +176,7 @@ lazy val commonSettings = baseSettings ++ Seq(
 
 lazy val slickSettings = commonSettings ++ Seq(
   libraryDependencies += slick.cross(CrossVersion.for3Use2_13),
-  libraryDependencies += (slickPg % "test").cross(CrossVersion.for3Use2_13),
+  libraryDependencies += (slickPg).cross(CrossVersion.for3Use2_13),
   libraryDependencies += optionalEnumeratum
 )
 
@@ -329,7 +329,7 @@ lazy val macroUtils = crossProject(JSPlatform, JVMPlatform)
 
 lazy val slickSupport = project
   .in(file("slick"))
-  .dependsOn(core.jvm, enumeratumSupport, instances % "test -> test")
+  .dependsOn(core.jvm, enumeratumSupport, instances)
   .settings(slickSettings: _*)
   .settings(publishSettings: _*)
   .settings(disableScala(List("3")))
diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala b/slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala
index a5b8dcb0..aee18737 100644
--- a/slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala
+++ b/slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala
@@ -1,174 +1,283 @@
 package pl.iterators.kebs.slick
 
-import pl.iterators.kebs.core.instances.InstanceConverter
-import pl.iterators.kebs.core.macros.{CaseClass1ToValueClass, ValueClassLike}
 import pl.iterators.kebs.slick.hstore.KebsHStoreColumnExtensionMethods
+import pl.iterators.kebs.core.instances.InstanceConverter
+import pl.iterators.kebs.core.macros.ValueClassLike
+import pl.iterators.kebs.instances.KebsInstances
+import pl.iterators.kebs.instances.util.UUIDString
+import pl.iterators.kebs.slick.types.GenericJdbcType
 import slick.ast.{BaseTypedType, NumericTypedType}
-import slick.jdbc.JdbcType
+import slick.jdbc.{JdbcProfile, JdbcType}
 import slick.lifted._
 
-import scala.language.implicitConversions
+import java.util.UUID
+import scala.language.{implicitConversions, reflectiveCalls}
+import scala.reflect.ClassTag
 
-trait KebsColumnExtensionMethods extends CaseClass1ToValueClass {
+trait KebsColumnExtensionMethods {
   implicit def stringValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[CC] =
     new StringColumnExtensionMethods[CC](rep)
+
   implicit def stringValueOptionColumnExt[CC](rep: Rep[Option[CC]])(
-      implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[Option[CC]] = new StringColumnExtensionMethods[Option[CC]](rep)
+    implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[Option[CC]] = new StringColumnExtensionMethods[Option[CC]](rep)
+
   implicit def numericValueColumnExt[CC, B](rep: Rep[CC])(
     implicit ev1: ValueClassLike[CC, B],
     ev2: BaseTypedType[B] with NumericTypedType): BaseNumericColumnExtensionMethods[CC] = new BaseNumericColumnExtensionMethods[CC](rep)
+
   implicit def numericValueOptionColumnExt[CC, B](rep: Rep[Option[CC]])(
     implicit ev1: ValueClassLike[CC, B],
     ev2: BaseTypedType[B] with NumericTypedType): OptionNumericColumnExtensionMethods[CC] =
     new OptionNumericColumnExtensionMethods[CC](rep)
+
   implicit def booleanValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[CC] =
     new BooleanColumnExtensionMethods[CC](rep)
+
   implicit def booleanValueOptionColumnExt[CC](rep: Rep[Option[CC]])(
-      implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[Option[CC]] =
+    implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[Option[CC]] =
     new BooleanColumnExtensionMethods[Option[CC]](rep)
 
   implicit def hstoreColumnExt[KEY, VALUE](c: Rep[Map[KEY, VALUE]])(
-      implicit tm0: JdbcType[KEY],
-      tm1: JdbcType[VALUE],
-      tm2: JdbcType[List[KEY]],
-      tm3: JdbcType[List[VALUE]],
-      tm4: JdbcType[Map[KEY, VALUE]]
+    implicit tm0: JdbcType[KEY],
+    tm1: JdbcType[VALUE],
+    tm2: JdbcType[List[KEY]],
+    tm3: JdbcType[List[VALUE]],
+    tm4: JdbcType[Map[KEY, VALUE]]
   ): KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]] =
     new KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]](c)
 
   @inline implicit def getCCOptionMapper2TT_1[B1, B2: BaseTypedType, BR, CC](
-      implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, B2, BR] =
+                                                                              implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, B2, BR] =
     OptionMapper2.plain.asInstanceOf[OptionMapper2[B1, B2, BR, CC, B2, BR]]
+
   @inline implicit def getCCOptionMapper2TT_2[B1, B2, BR, CC](implicit ev: ValueClassLike[CC, B2]): OptionMapper2[CC, CC, BR, CC, B2, BR] =
     OptionMapper2.plain.asInstanceOf[OptionMapper2[CC, CC, BR, CC, B2, BR]]
+
   @inline implicit def getCCOptionMapper2TO[B1, B2: BaseTypedType, BR, CC](
-      implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]] =
+                                                                            implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]] =
     OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]]]
+
   @inline implicit def getCCOptionMapper2OT[B1, B2: BaseTypedType, BR, CC](
-      implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]] =
+                                                                            implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]] =
     OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]]]
+
   @inline implicit def getCCOptionMapper2OO[B1, B2: BaseTypedType, BR, CC](
-      implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]] =
+                                                                            implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]] =
     OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]]]
 }
 
 trait Kebs extends KebsColumnExtensionMethods {
-  implicit def valueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B]): Isomorphism[CC, B] =
-    new Isomorphism[CC, B](rep1.unapply, rep1.apply)
-  implicit def valueTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B]): Isomorphism[CC, B] =
-    new Isomorphism[CC, B](ico.encode, ico.decode)
-  implicit def listValueColumnType[CC, B](implicit iso: Isomorphism[CC, B]): Isomorphism[List[CC], List[B]] =
-    new Isomorphism[List[CC], List[B]](_.map(iso.map), _.map(iso.comap))
-  implicit def seqValueColumnType[CC, B](implicit iso: Isomorphism[CC, B]): Isomorphism[Seq[CC], List[B]] = {
-    new Isomorphism[Seq[CC], List[B]](_.map(iso.map).toList, _.map(iso.comap))
+
+  import scala.reflect.ClassTag
+  import scala.annotation.implicitNotFound
+
+  @implicitNotFound("No InstanceConverter found")
+  trait InstanceConverterNotFound
+  implicit object DefaultInstanceConverterNotFound extends InstanceConverterNotFound
+
+  implicit def stringInstanceConverterToEither[T](implicit ico: InstanceConverter[T, String]): Option[InstanceConverter[T, String]] = Some(ico)
+
+  implicit def notFoundToEither[T](implicit notFound: InstanceConverterNotFound): Either[InstanceConverterNotFound, InstanceConverter[T, String]] = Left(notFound)
+
+  protected implicit def genericJdbcType[T](implicit ct: ClassTag[T], icoOrNot: Either[InstanceConverterNotFound, InstanceConverter[T, String]]): GenericJdbcType[T] = {
+    icoOrNot match {
+      case Right(ico) =>
+        println("InstanceConverter found!!")
+        new GenericJdbcType[T]("text", ico.decode, ico.encode, java.sql.Types.OTHER)
+      case Left(_) =>
+        println("No nstanceConverter found")
+        new GenericJdbcType[T]("text", _.asInstanceOf[T], _.toString, java.sql.Types.OTHER)
+    }
+  }
+
+//  protected implicit def genericJdbcType[T](implicit ct: ClassTag[T]): GenericJdbcType[T] = new GenericJdbcType[T]("text", _.asInstanceOf[T], _.toString, java.sql.Types.OTHER)
+
+  private type MyMappedJdbcType[CC, B] = slick.jdbc.JdbcTypesComponent#MappedJdbcType[CC, B]
+
+  implicit def valueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B], ct: ClassTag[CC], ct2: ClassTag[B], jp: JdbcProfile): MyMappedJdbcType[CC, B] = {
+    jp.MappedJdbcType.base[CC, B](rep1.unapply, rep1.apply).asInstanceOf[MyMappedJdbcType[CC, B]]
+  }
+
+  implicit def valueTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: JdbcProfile#BaseColumnType[B], ct: ClassTag[CC], jp: JdbcProfile): MyMappedJdbcType[CC, B] =
+    jp.MappedJdbcType.base[CC, B](ico.encode, ico.decode).asInstanceOf[MyMappedJdbcType[CC, B]]
+
+  implicit def listValueColumnType[CC, B](implicit iso: MyMappedJdbcType[CC, B], ct: ClassTag[CC], jp: JdbcProfile): MyMappedJdbcType[List[CC], List[B]] = {
+    jp.MappedJdbcType.base[List[CC], List[B]](_.map(iso.map), _.map(iso.comap)).asInstanceOf[MyMappedJdbcType[List[CC], List[B]]]
+  }
+
+  implicit def seqValueColumnType[CC, B](implicit iso: MyMappedJdbcType[CC, B], ct: ClassTag[CC], jp: JdbcProfile): MyMappedJdbcType[Seq[CC], List[B]] = {
+    jp.MappedJdbcType.base[Seq[CC], List[B]](_.map(iso.map).toList, _.map(iso.comap)).asInstanceOf[MyMappedJdbcType[Seq[CC], List[B]]]
   }
+
   implicit def mapValueColumnType[CC1, CC2, A, B](
-      implicit iso1: Isomorphism[CC1, A],
-      iso2: Isomorphism[CC2, B]
-  ): Isomorphism[Map[CC1, CC2], Map[A, B]] =
-    new Isomorphism[Map[CC1, CC2], Map[A, B]](
+                                                   implicit iso1: MyMappedJdbcType[CC1, A],
+                                                   iso2: MyMappedJdbcType[CC2, B],
+                                                   jp: JdbcProfile): MyMappedJdbcType[Map[CC1, CC2], Map[A, B]] = {
+    jp.MappedJdbcType.base[Map[CC1, CC2], Map[A, B]](
       _.map { case (cc1, cc2) => (iso1.map(cc1), iso2.map(cc2)) },
-      _.map { case (a, b)     => (iso1.comap(a), iso2.comap(b)) }
-    )
-
-  private class StringMapIsomorphism[A](comap: String => A)
-      extends Isomorphism[Map[String, A], Map[String, String]](
-        _.map { case (str, a)     => (str, a.toString) },
-        _.map { case (str1, str2) => (str1, comap(str2)) }
-      )
-  implicit final val intMapValueColumnType: Isomorphism[Map[String, Int], Map[String, String]] =
-    new StringMapIsomorphism[Int](_.toInt)
-  implicit final val longMapValueColumnType: Isomorphism[Map[String, Long], Map[String, String]] =
-    new StringMapIsomorphism[Long](_.toLong)
-  implicit final val boolMapValueColumnType: Isomorphism[Map[String, Boolean], Map[String, String]] =
-    new StringMapIsomorphism[Boolean](_.toBoolean)
-
-  private class StringValueMapIsomorphism[A](comap: String => A)
-      extends Isomorphism[Map[A, String], Map[String, String]](
-        _.map { case (a, str)     => (a.toString, str) },
-        _.map { case (str1, str2) => (comap(str1), str2) }
-      )
-  implicit final val intMapValueColumnType1: Isomorphism[Map[Int, String], Map[String, String]] =
-    new StringValueMapIsomorphism[Int](_.toInt)
-  implicit final val longMapValueColumnType1: Isomorphism[Map[Long, String], Map[String, String]] =
-    new StringValueMapIsomorphism[Long](_.toLong)
-  implicit final val boolMapValueColumnType1: Isomorphism[Map[Boolean, String], Map[String, String]] =
-    new StringValueMapIsomorphism[Boolean](_.toBoolean)
+      _.map { case (a, b) => (iso1.comap(a), iso2.comap(b)) }
+    ).asInstanceOf[MyMappedJdbcType[Map[CC1, CC2], Map[A, B]]]
+  }
+
+  private class StringMapIsomorphism[A](fromStringMap: String => A, jp: JdbcProfile) {
+    def map(t: Map[String, A]): Map[String, String] =   t.map { case (str, a)     => (str, a.toString) }
+    def comap(u: Map[String, String]): Map[String, A] = u.map { case (str1, str2) => (str1, fromStringMap(str2)) }
+    val mjt: MyMappedJdbcType[Map[String, A], Map[String, String]] = jp.MappedJdbcType.base[Map[String, A], Map[String, String]](
+      map,
+      comap
+    ).asInstanceOf[MyMappedJdbcType[Map[String, A], Map[String, String]]]
+  }
+  private object StringMapIsomorphism {
+    def apply[A](fromStringMap: String => A, jp: JdbcProfile): StringMapIsomorphism[A] = new StringMapIsomorphism(fromStringMap, jp)
+  }
+
+  implicit final def intMapValueColumnType(implicit jp: JdbcProfile): MyMappedJdbcType[Map[String, Int], Map[String, String]] =
+    StringMapIsomorphism[Int](_.toInt, implicitly[JdbcProfile]).mjt
+  implicit final def longMapValueColumnType(implicit jp: JdbcProfile): MyMappedJdbcType[Map[String, Long], Map[String, String]] =
+    StringMapIsomorphism[Long](_.toLong, implicitly[JdbcProfile]).mjt
+  implicit final def boolMapValueColumnType(implicit jp: JdbcProfile): MyMappedJdbcType[Map[String, Boolean], Map[String, String]] =
+    StringMapIsomorphism[Boolean](_.toBoolean, implicitly[JdbcProfile]).mjt
+
+  private class StringValueMapIsomorphism[A](fromStringMap: String => A, jp: JdbcProfile) {
+    def map(t: Map[A, String]): Map[String, String] =   t.map { case (a, str)     => (a.toString, str) }
+    def comap(u: Map[String, String]): Map[A, String] = u.map { case (str1, str2) => (fromStringMap(str1), str2) }
+    val mjt = jp.MappedJdbcType.base[Map[A, String], Map[String, String]](
+      map,
+      comap
+    ).asInstanceOf[MyMappedJdbcType[Map[A, String], Map[String, String]]]
+  }
+  private object StringValueMapIsomorphism {
+    def apply[A](fromStringMap: String => A, jp: JdbcProfile): StringValueMapIsomorphism[A] = new StringValueMapIsomorphism(fromStringMap, jp)
+  }
+
+  implicit final def intMapValueColumnType1(implicit jp: JdbcProfile): MyMappedJdbcType[Map[Int, String], Map[String, String]] =
+    StringValueMapIsomorphism[Int](_.toInt, jp).mjt
+  implicit final def longMapValueColumnType1(implicit jp: JdbcProfile): MyMappedJdbcType[Map[Long, String], Map[String, String]] =
+    StringValueMapIsomorphism[Long](_.toLong, jp).mjt
+  implicit final def boolMapValueColumnType1(implicit jp: JdbcProfile): MyMappedJdbcType[Map[Boolean, String], Map[String, String]] =
+    StringValueMapIsomorphism[Boolean](_.toBoolean, jp).mjt
 
   implicit def hstoreColumnType[CC1, CC2, A, B](
-      implicit iso1: Isomorphism[Map[CC1, CC2], Map[A, B]],
-      iso2: Isomorphism[Map[A, B], Map[String, String]]): Isomorphism[Map[CC1, CC2], Map[String, String]] =
-    new Isomorphism[Map[CC1, CC2], Map[String, String]](
-      iso1.map andThen iso2.map,
-      iso2.comap andThen iso1.comap
-    )
+                                                 implicit iso1: MyMappedJdbcType[Map[CC1, CC2], Map[A, B]],
+                                                 iso2: MyMappedJdbcType[Map[A, B], Map[String, String]],
+                                                 jp: JdbcProfile): MyMappedJdbcType[Map[CC1, CC2], Map[String, String]] = {
+    jp.MappedJdbcType.base[Map[CC1, CC2], Map[String, String]](
+      iso1.map _ andThen iso2.map,
+      iso2.comap _ andThen iso1.comap).asInstanceOf[MyMappedJdbcType[Map[CC1, CC2], Map[String, String]]]
+  }
 
   def instancesIsoMapVal[Obj, Value, MapVal](comap1: String => Value, comap2: String => MapVal)(
-      implicit ico: InstanceConverter[Obj, Value]) =
-    new Isomorphism[Map[Obj, MapVal], Map[String, String]](
+    implicit ico: InstanceConverter[Obj, Value],
+    jp: JdbcProfile,
+    ct: ClassTag[Obj]) = {
+    jp.MappedJdbcType.base[Map[Obj, MapVal], Map[String, String]](
       _.map { case (obj, mapval) => (ico.encode(obj).toString, mapval.toString) },
-      _.map { case (value, str)  => (ico.decode(comap1(value)), comap2(str)) }
-    )
+      _.map { case (value, str) => (ico.decode(comap1(value)), comap2(str)) }
+    ).asInstanceOf[MyMappedJdbcType[Map[Obj, MapVal], Map[String, String]]]
+  }
+
   def instancesIsoMapKey[Obj, Value, MapKey](comap1: String => Value, comap2: String => MapKey)(
-      implicit ico: InstanceConverter[Obj, Value]) =
-    new Isomorphism[Map[MapKey, Obj], Map[String, String]](
+    implicit ico: InstanceConverter[Obj, Value],
+    jp: JdbcProfile) = {
+    jp.MappedJdbcType.base[Map[MapKey, Obj], Map[String, String]](
       _.map { case (mapkey, obj) => (mapkey.toString, ico.encode(obj).toString) },
-      _.map { case (str1, str2)  => (comap2(str1), ico.decode(comap1(str2))) }
-    )
+      _.map { case (str1, str2) => (comap2(str1), ico.decode(comap1(str2))) }
+    ).asInstanceOf[MyMappedJdbcType[Map[MapKey, Obj], Map[String, String]]]
+  }
 
-  implicit def instancesIsoObj2Str[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, String], Map[String, String]] =
+  implicit def instancesIsoObj2Str[Obj](implicit ico: InstanceConverter[Obj, String], ct: ClassTag[Obj], jp: JdbcProfile): MyMappedJdbcType[Map[Obj, String], Map[String, String]] = {
     instancesIsoMapVal[Obj, String, String](identity[String], identity[String])
-  implicit def instancesIsoObj2Str1[Obj](
-      implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[String, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Str1[Obj](implicit ico: InstanceConverter[Obj, String], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[String, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, String, String](identity[String], identity[String])
-  implicit def instancesIsoObj2Str2[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, Int], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Str2[Obj](implicit ico: InstanceConverter[Obj, String], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Int], Map[String, String]] = {
     instancesIsoMapVal[Obj, String, Int](identity[String], _.toInt)
-  implicit def instancesIsoObj2Str3[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Int, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Str3[Obj](implicit ico: InstanceConverter[Obj, String], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Int, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, String, Int](identity[String], _.toInt)
-  implicit def instancesIsoObj2Str4[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, Long], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Str4[Obj](implicit ico: InstanceConverter[Obj, String], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Long], Map[String, String]] = {
     instancesIsoMapVal[Obj, String, Long](identity[String], _.toLong)
-  implicit def instancesIsoObj2Str5[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Long, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Str5[Obj](implicit ico: InstanceConverter[Obj, String], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Long, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, String, Long](identity[String], _.toLong)
-  implicit def instancesIsoObj2Str6[Obj](
-      implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, Boolean], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Str6[Obj](implicit ico: InstanceConverter[Obj, String], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Boolean], Map[String, String]] = {
     instancesIsoMapVal[Obj, String, Boolean](identity[String], _.toBoolean)
-  implicit def instancesIsoObj2Str7[Obj](
-      implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Boolean, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Str7[Obj](implicit ico: InstanceConverter[Obj, String], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Boolean, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, String, Boolean](identity[String], _.toBoolean)
+  }
 
-  implicit def instancesIsoObj2Int[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, String], Map[String, String]] =
+  implicit def instancesIsoObj2Int[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, String], Map[String, String]] = {
     instancesIsoMapVal[Obj, Int, String](_.toInt, identity[String])
-  implicit def instancesIsoObj2Int1[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[String, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Int1[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[String, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Int, String](_.toInt, identity[String])
-  implicit def instancesIsoObj2Int2[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, Int], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Int2[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Int], Map[String, String]] = {
     instancesIsoMapVal[Obj, Int, Int](_.toInt, _.toInt)
-  implicit def instancesIsoObj2Int3[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Int, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Int3[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Int, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Int, Int](_.toInt, _.toInt)
-  implicit def instancesIsoObj2Int4[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, Long], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Int4[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Long], Map[String, String]] = {
     instancesIsoMapVal[Obj, Int, Long](_.toInt, _.toLong)
-  implicit def instancesIsoObj2Int5[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Long, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Int5[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Long, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Int, Long](_.toInt, _.toLong)
-  implicit def instancesIsoObj2Int6[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, Boolean], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Int6[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Boolean], Map[String, String]] = {
     instancesIsoMapVal[Obj, Int, Boolean](_.toInt, _.toBoolean)
-  implicit def instancesIsoObj2Int7[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Boolean, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Int7[Obj](implicit ico: InstanceConverter[Obj, Int], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Boolean, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Int, Boolean](_.toInt, _.toBoolean)
+  }
 
-  implicit def instancesIsoObj2Long[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, String], Map[String, String]] =
+  implicit def instancesIsoObj2Long[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, String], Map[String, String]] = {
     instancesIsoMapVal[Obj, Long, String](_.toLong, identity[String])
-  implicit def instancesIsoObj2Long1[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[String, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Long1[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[String, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Long, String](_.toLong, identity[String])
-  implicit def instancesIsoObj2Long2[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, Int], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Long2[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Int], Map[String, String]] = {
     instancesIsoMapVal[Obj, Long, Int](_.toLong, _.toInt)
-  implicit def instancesIsoObj2Long3[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Int, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Long3[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Int, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Long, Int](_.toLong, _.toInt)
-  implicit def instancesIsoObj2Long4[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, Long], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Long4[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Long], Map[String, String]] = {
     instancesIsoMapVal[Obj, Long, Long](_.toLong, _.toLong)
-  implicit def instancesIsoObj2Long5[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Long, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Long5[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Long, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Long, Long](_.toLong, _.toLong)
-  implicit def instancesIsoObj2Long6[Obj](
-      implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, Boolean], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Long6[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Obj, Boolean], Map[String, String]] = {
     instancesIsoMapVal[Obj, Long, Boolean](_.toLong, _.toBoolean)
-  implicit def instancesIsoObj2Long7[Obj](
-      implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Boolean, Obj], Map[String, String]] =
+  }
+
+  implicit def instancesIsoObj2Long7[Obj](implicit ico: InstanceConverter[Obj, Long], jp: JdbcProfile, ct: ClassTag[Obj]): MyMappedJdbcType[Map[Boolean, Obj], Map[String, String]] = {
     instancesIsoMapKey[Obj, Long, Boolean](_.toLong, _.toBoolean)
+  }
 }
diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala b/slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala
index d9e16975..5c9bf7b4 100644
--- a/slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala
+++ b/slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala
@@ -1,42 +1,57 @@
 package pl.iterators.kebs.slick.enums
 
+import pl.iterators.kebs.slick.Kebs
 import pl.iterators.kebs.core.enums.{EnumLike, ValueEnumLike, ValueEnumLikeEntry}
-import slick.lifted.Isomorphism
+import slick.jdbc.{JdbcProfile, JdbcType}
 
-trait SlickEnum {
-  def enumIsomorphism[E](`enum`: EnumLike[E]): Isomorphism[E, String] = new Isomorphism[E, String](_.toString, `enum`.withName)
+import scala.reflect.ClassTag
 
-  def uppercaseEnumIsomorphism[E](`enum`: EnumLike[E]): Isomorphism[E, String] =
-    new Isomorphism[E, String](_.toString.toUpperCase, `enum`.withNameUppercaseOnly)
+trait SlickEnum extends Kebs {
 
-  def lowercaseEnumIsomorphism[E](`enum`: EnumLike[E]): Isomorphism[E, String] =
-    new Isomorphism[E, String](_.toString.toLowerCase, `enum`.withNameLowercaseOnly)
+  def enumIsomorphism[E](
+                                       `enum`: EnumLike[E])(
+                                       implicit ct: ClassTag[E],
+                                       jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String] = {
+    jp.MappedColumnType.base[E, String](_.toString, `enum`.withName).asInstanceOf[slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String]]
+  }
+
+  def uppercaseEnumIsomorphism[E](
+                                                `enum`: EnumLike[E])(
+                                                implicit ct: ClassTag[E],
+                                                jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String] = jp.MappedColumnType.base[E, String](_.toString.toUpperCase, `enum`.withNameUppercaseOnly).asInstanceOf[slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String]]
 
-  implicit def enumListColumnType[E](implicit iso: Isomorphism[E, String]): Isomorphism[List[E], List[String]] =
-    new Isomorphism[List[E], List[String]](_.map(iso.map), _.map(iso.comap))
+  def lowercaseEnumIsomorphism[E](
+                                                `enum`: EnumLike[E])(
+                                                implicit ct: ClassTag[E],
+                                                jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String] = jp.MappedColumnType.base[E, String](_.toString.toLowerCase, `enum`.withNameLowercaseOnly).asInstanceOf[slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String]]
 
-  implicit def enumSeqColumnType[E](implicit iso: Isomorphism[E, String]): Isomorphism[Seq[E], List[String]] =
-    new Isomorphism[Seq[E], List[String]](_.map(iso.map).toList, _.map(iso.comap))
+  implicit def enumListColumnType[E](implicit iso: slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String], jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[List[E], List[String]] = {
+    jp.MappedColumnType.base[List[E], List[String]](_.map(iso.map), _.map(iso.comap)).asInstanceOf[slick.jdbc.JdbcTypesComponent#MappedJdbcType[List[E], List[String]]]
+  }
+
+  implicit def enumSeqColumnType[E](implicit iso: slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String], jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[Seq[E], List[String]] = {
+    jp.MappedColumnType.base[Seq[E], List[String]](_.map(iso.map).toList, _.map(iso.comap)).asInstanceOf[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Seq[E], List[String]]]
+  }
 }
 
 trait SlickValueEnum {
-  def valueEnumIsomorphism[V, E <: ValueEnumLikeEntry[V]](`enum`: ValueEnumLike[V, E]): Isomorphism[E, V] =
-    new Isomorphism[E, V](_.value, `enum`.withValue)
+  def valueEnumIsomorphism[V, E <: ValueEnumLikeEntry[V]](`enum`: ValueEnumLike[V, E])(implicit bct: JdbcType[V], ct: ClassTag[E], jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, V] =
+    jp.MappedColumnType.base[E, V](_.value, `enum`.withValue).asInstanceOf[slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, V]]
 }
 
 trait KebsEnums extends SlickEnum with SlickValueEnum {
-  implicit def enumValueColumn[E](implicit ev: EnumLike[E]): Isomorphism[E, String] = enumIsomorphism(ev)
+  implicit def enumValueColumn[E](implicit ev: EnumLike[E], ct: ClassTag[E], jt: slick.jdbc.JdbcType[String], jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String] = enumIsomorphism(ev)
 
-  implicit def valueEnumColumn[V, E <: ValueEnumLikeEntry[V]](implicit ev: ValueEnumLike[V, E]): Isomorphism[E, V] =
+  implicit def valueEnumColumn[V, E <: ValueEnumLikeEntry[V]](implicit ev: ValueEnumLike[V, E], bct: JdbcProfile#BaseColumnType[V], ct: ClassTag[E], jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, V] =
     valueEnumIsomorphism(ev)
 
   trait Uppercase extends SlickEnum {
-    implicit def enumValueColumn[E](implicit ev: EnumLike[E]): Isomorphism[E, String] = uppercaseEnumIsomorphism(ev)
+    implicit def enumValueColumn[E](implicit ev: EnumLike[E], jt: slick.jdbc.JdbcType[String], ct: ClassTag[E], jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String] = uppercaseEnumIsomorphism(ev)
   }
 
   trait Lowercase extends SlickEnum {
-    implicit def enumValueColumn[E](implicit ev: EnumLike[E]): Isomorphism[E, String] = lowercaseEnumIsomorphism(ev)
+    implicit def enumValueColumn[E](implicit ev: EnumLike[E], jt: slick.jdbc.JdbcType[String], ct: ClassTag[E], jp: JdbcProfile): slick.jdbc.JdbcTypesComponent#MappedJdbcType[E, String] = lowercaseEnumIsomorphism(ev)
   }
 }
 
-object KebsEnums extends KebsEnums
\ No newline at end of file
+object KebsEnums extends KebsEnums
diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/hstore/KebsHStoreColumnExtensionMethods.scala b/slick/src/main/scala/pl/iterators/kebs/slick/hstore/KebsHStoreColumnExtensionMethods.scala
index 5cdf80c7..ef6a3111 100644
--- a/slick/src/main/scala/pl/iterators/kebs/slick/hstore/KebsHStoreColumnExtensionMethods.scala
+++ b/slick/src/main/scala/pl/iterators/kebs/slick/hstore/KebsHStoreColumnExtensionMethods.scala
@@ -7,11 +7,11 @@ import slick.jdbc.JdbcType
 import slick.lifted.{ExtensionMethods, FunctionSymbolExtensionMethods, Rep}
 
 class KebsHStoreColumnExtensionMethods[KEY, VALUE, P1](val c: Rep[P1])(
-    implicit tm0: JdbcType[KEY],
-    tm1: JdbcType[VALUE],
-    tm2: JdbcType[List[KEY]],
-    tm3: JdbcType[List[VALUE]],
-    tm4: JdbcType[Map[KEY, VALUE]]
+  implicit tm0: JdbcType[KEY],
+  tm1: JdbcType[VALUE],
+  tm2: JdbcType[List[KEY]],
+  tm3: JdbcType[List[VALUE]],
+  tm4: JdbcType[Map[KEY, VALUE]]
 ) extends ExtensionMethods[Map[KEY, VALUE], P1] {
   import FunctionSymbolExtensionMethods._
 
diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/types/GenericJdbcType.scala b/slick/src/main/scala/pl/iterators/kebs/slick/types/GenericJdbcType.scala
new file mode 100644
index 00000000..668fe470
--- /dev/null
+++ b/slick/src/main/scala/pl/iterators/kebs/slick/types/GenericJdbcType.scala
@@ -0,0 +1,36 @@
+package pl.iterators.kebs.slick.types
+
+import slick.ast.{FieldSymbol, ScalaType}
+
+import java.sql.{PreparedStatement, ResultSet}
+import scala.reflect.ClassTag
+
+class GenericJdbcType[T](val sqlTypeName: String,
+                         fnFromString: (String => T),
+                         fnToString: (T => String) = ((r: T) => r.toString),
+                         val sqlType: Int = java.sql.Types.OTHER,
+                         override val hasLiteralForm: Boolean = false)(
+                          implicit override val classTag: ClassTag[T]) extends slick.jdbc.JdbcType[T] {
+
+  override def sqlTypeName(sym: Option[FieldSymbol]): String = sqlTypeName
+
+  override def getValue(r: ResultSet, idx: Int): T = {
+    val value = r.getString(idx)
+    if (r.wasNull) null.asInstanceOf[T] else fnFromString(value)
+  }
+
+  override def setValue(v: T, p: PreparedStatement, idx: Int): Unit = p.setObject(idx, toStr(v), java.sql.Types.OTHER)
+
+  override def updateValue(v: T, r: ResultSet, idx: Int): Unit = r.updateObject(idx, toStr(v), java.sql.Types.OTHER)
+
+  override def valueToSQLLiteral(v: T) = if(v == null) "NULL" else s"'${fnToString(v)}'"
+
+  private def toStr(v: T) = if(v == null) null else fnToString(v)
+
+  override def setNull(p: PreparedStatement, idx: Int): Unit = p.setNull(idx, sqlType)
+
+  override def wasNull(r: ResultSet, idx: Int): Boolean = r.wasNull()
+
+  override def scalaType: ScalaType[T] = null
+}
+
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala
index c71cf665..70c6e7a8 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala
@@ -3,28 +3,28 @@ package pl.iterators.kebs.slick.arrays
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 import pl.iterators.kebs.instances.time.YearMonthString
-import slick.lifted.Isomorphism
 
 class ListIsomorphismTest extends AnyFunSuite with Matchers with YearMonthString {
   import pl.iterators.kebs.slick._
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
+  import slick.jdbc.PostgresProfile.api._
 
   case class C(a: String)
 
-  test("No ValueClassLike implicits derived") {
-    import pl.iterators.kebs.core.macros.ValueClassLike
+  test("No CaseClass1Rep implicits derived") {
 
-    "implicitly[ValueClassLike[YearMonth, String]]" shouldNot typeCheck
-    "implicitly[ValueClassLike[String, YearMonth]]" shouldNot typeCheck
+    "implicitly[CaseClass1Rep[YearMonth, String]]" shouldNot typeCheck
+    "implicitly[CaseClass1Rep[String, YearMonth]]" shouldNot typeCheck
   }
 
   test("Case class isomorphism implies list isomorphism") {
-    val iso = implicitly[Isomorphism[List[C], List[String]]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[List[C], List[String]]]
     iso.map(List(C("a"), C("b"))) shouldBe List("a", "b")
     iso.comap(List("a", "b")) shouldBe List(C("a"), C("b"))
   }
 
   test("Case class isomorphism implies seq to list isomorphism") {
-    val iso = implicitly[Isomorphism[Seq[C], List[String]]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Seq[C], List[String]]]
     iso.map(Seq(C("a"), C("b"))) shouldBe List("a", "b")
     iso.comap(List("a", "b")) shouldBe Seq(C("a"), C("b"))
   }
@@ -32,10 +32,10 @@ class ListIsomorphismTest extends AnyFunSuite with Matchers with YearMonthString
   import java.time.YearMonth
 
   test("List[Obj[String]] <-> List[String]") {
-    "val iso = implicitly[Isomorphism[List[YearMonth], List[String]]]" should compile
+    "val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[List[YearMonth], List[String]]]" should compile
   }
 
   test("Seq[Obj[String]] <-> List[String]") {
-    "val iso = implicitly[Isomorphism[Seq[YearMonth], List[String]]]" should compile
+    "val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Seq[YearMonth], List[String]]]" should compile
   }
 }
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala
index 64cf1cd4..f72d4ba6 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala
@@ -4,18 +4,19 @@ import com.github.tminglei.slickpg._
 import enumeratum.{Enum, EnumEntry}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
-import pl.iterators.kebs.enumeratum.KebsEnumeratum
-import pl.iterators.kebs.slick.enums.KebsEnums
 
-class SlickPgArrayColumnTypeTests extends AnyFunSuite with Matchers with KebsEnumeratum {
+class SlickPgArrayColumnTypeTests extends AnyFunSuite with Matchers {
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
+
   case class Institution(value: Long)
   case class MarketFinancialProduct(value: String)
 
   import pl.iterators.kebs.slick.Kebs
+  import pl.iterators.kebs.slick.enums.KebsEnums
 
   object MyPostgresProfile extends ExPostgresProfile with PgArraySupport {
-    override val api: APIWithArrays = new APIWithArrays {}
-    trait APIWithArrays extends super.API with ArrayImplicits with Kebs with KebsEnums
+    override val api: ExtPostgresAPI = new ExtPostgresAPI {}
+    trait APIWithArrays extends ExPostgresProfile with ArrayImplicits with Kebs with KebsEnums
   }
 
   import MyPostgresProfile.api._
@@ -50,7 +51,8 @@ class SlickPgArrayColumnTypeTests extends AnyFunSuite with Matchers with KebsEnu
 
     override val values = findValues
   }
-  import enums._
+  import pl.iterators.kebs.slick.enums._
+  import pl.iterators.kebs.enumeratum._
 
   test("Seq column type with enums") {
     """
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala
index cb884501..1f4d2dae 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala
@@ -9,12 +9,13 @@ import java.time.YearMonth
 import java.util.UUID
 
 class SlickPgArrayTests extends AnyFunSuite with Matchers {
-  import pl.iterators.kebs.instances.time.YearMonthString
   import pl.iterators.kebs.slick.Kebs
+  import pl.iterators.kebs.instances.time.YearMonthString
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
 
   trait PostgresDriver extends ExPostgresProfile with PgArraySupport {
     override val api: ArrayAPI = new ArrayAPI {}
-    trait ArrayAPI extends super.API with ArrayImplicits with Kebs with YearMonthString
+    trait ArrayAPI extends ExtPostgresAPI with ArrayImplicits with Kebs with YearMonthString
   }
   object PostgresDriver extends PostgresDriver
 
@@ -40,7 +41,7 @@ class SlickPgArrayTests extends AnyFunSuite with Matchers {
     override def * : ProvenShape[Test] = (id, ccList) <> ((Test.apply _).tupled, Test.unapply)
   }
 
-  test("No ValueClassLike implicits derived") {
+  test("No CaseClass1Rep implicits derived") {
     import pl.iterators.kebs.core.macros.ValueClassLike
 
     "implicitly[ValueClassLike[YearMonth, String]]" shouldNot typeCheck
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala
index 29a24d98..6a7b97e4 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala
@@ -2,54 +2,57 @@ package pl.iterators.kebs.slick.caseclasses
 
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
+import pl.iterators.kebs.slick.Kebs
+import slick.jdbc.PostgresProfile.api._
 
-class CaseClassIsomorphismTests extends AnyFunSuite with Matchers {
-  import slick.lifted.Isomorphism
-  import pl.iterators.kebs._
+import scala.reflect.ClassTag
+
+class CaseClassIsomorphismTests extends AnyFunSuite with Matchers with Kebs {
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
 
   case class Simple1(a: Int)
   case class Simple2(a: Option[Int])
 
   test("Implicit isomorphism for case class of arity 1") {
-    val iso = implicitly[Isomorphism[Simple1, Int]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Simple1, Int]]
     iso.map(Simple1(10)) shouldBe 10
     iso.comap(10) shouldBe Simple1(10)
   }
 
-  test("Implicit isomorphism for case class of arity 1 - parametrized return type") {
-    val iso = implicitly[Isomorphism[Simple2, Option[Int]]]
-    iso.map(Simple2(Some(10))) shouldBe Some(10)
-    iso.comap(Some(10)) shouldBe Simple2(Some(10))
-  }
+    test("Implicit isomorphism for case class of arity 1 - parametrized return type") {
+      val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Simple2, Option[Int]]]
+      iso.map(Simple2(Some(10))) shouldBe Some(10)
+      iso.comap(Some(10)) shouldBe Simple2(Some(10))
+    }
 
   case class TooBig(a: Int, b: Int)
 
   test("No isomorphism for case classes of arity > 1") {
-    "implicitly[Isomorphism[TooBig, _]]" shouldNot typeCheck
+    "implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[TooBig, _]]" shouldNot typeCheck
   }
 
   case object NoIsoForYou
 
   test("No isomorphism for case classes of arity == 0") {
-    "implicitly[Isomorphism[NoIsoForYou.type, _]]" shouldNot typeCheck
+    "implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[NoIsoForYou.type, _]]" shouldNot typeCheck
   }
 
   class JustAClass(val a: Int)
 
   test("No isomorphism for ordinary classes") {
-    "implicitly[Isomorphism[JustAClass, Int]]" shouldNot typeCheck
+    "implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[JustAClass, Int]]" shouldNot typeCheck
   }
 
   case class Parametrized[P](a: P)
 
   test("Implicit isomorphism for parametrized case class of arity 1") {
-    val iso = implicitly[Isomorphism[Parametrized[Int], Int]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Parametrized[Int], Int]]
     iso.map(Parametrized(10)) shouldBe 10
     iso.comap(10) shouldBe Parametrized(10)
   }
 
   test("Implicit isomorphism for parametrized case class of arity 1 - unrefined type parameter") {
-    def iso[P]: Isomorphism[Parametrized[P], P] = implicitly[Isomorphism[Parametrized[P], P]]
+    def iso[P](implicit cls: ClassTag[P]): slick.jdbc.JdbcTypesComponent#MappedJdbcType[Parametrized[P], P] = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Parametrized[P], P]]
     iso[Int].map(Parametrized(10)) shouldBe 10
     iso[Option[Int]].comap(Some(10)) shouldBe Parametrized(Some(10))
   }
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala
index cbdaab8f..90ac46c5 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala
@@ -6,7 +6,7 @@ import org.scalatest.matchers.should.Matchers
 class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers {
   import slick.lifted.ProvenShape
   import slick.jdbc.PostgresProfile.api._
-  import pl.iterators.kebs._
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
 
   case class Id(id: Long)
   case class Row(id: Id, name: String, num: Long)
@@ -46,7 +46,7 @@ class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers {
     """
       |class OneElement(tag: Tag) extends Table[Name](tag, "ONE_ELEMENT_TABLE") {
       |      def name                           = column[String]("name")
-      |      
+      |
       |      override def * : ProvenShape[Name] = name <> (Name.apply, Name.unapply)
       |    }
     """.stripMargin should compile
@@ -56,7 +56,7 @@ class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers {
     """
       |class Matryoshka(tag: Tag) extends Table[WrappedName](tag, "MATRYOSHKA") {
       |      def name                                  = column[Name]("name")
-      |      
+      |
       |      override def * : ProvenShape[WrappedName] = name <> (WrappedName.apply, WrappedName.unapply)
       |}
     """.stripMargin should compile
@@ -67,7 +67,7 @@ class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers {
       |class Matryoshka(tag: Tag) extends Table[WrappedName](tag, "MATRYOSHKA") {
       |      def name                                  = column[Name]("name")
       |      private def mappedProjection              = name <> (WrappedName.apply, WrappedName.unapply)
-      |      
+      |
       |      override def * : ProvenShape[WrappedName] = mappedProjection
       |    }
     """.stripMargin should compile
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala
index 8b91fcbb..caa08cf4 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala
@@ -7,8 +7,8 @@ import org.scalatest.matchers.should.Matchers
 import java.util.UUID
 
 class SlickPgTests extends AnyFunSuite with Matchers {
-
   import pl.iterators.kebs.slick.Kebs
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
   import slick.lifted.ProvenShape
 
   case class ServiceLineName(name: String)
@@ -17,7 +17,7 @@ class SlickPgTests extends AnyFunSuite with Matchers {
 
   trait PostgresDriver extends ExPostgresProfile {
     override val api = PostgresApi
-    object PostgresApi extends API with Kebs
+    object PostgresApi extends ExtPostgresAPI with Kebs
   }
   object PostgresDriver extends PostgresDriver
 
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala
index cdd5fb47..52ae9a94 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala
@@ -1,13 +1,9 @@
-package enums
-
 import enumeratum.{Enum, EnumEntry}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
-import pl.iterators.kebs.core.enums.EnumLike
-import slick.lifted.Isomorphism
-import pl.iterators.kebs.enumeratum.KebsEnumeratum
 
-class EnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnumeratum {
+class EnumIsomorphismTests extends AnyFunSuite with Matchers {
+  import slick.jdbc.PostgresProfile.api._
 
   sealed trait Greeting extends EnumEntry
 
@@ -21,11 +17,11 @@ class EnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnumeratum
   }
 
   import Greeting._
+  import pl.iterators.kebs.enumeratum._
 
   test("Implicit isomorphism for EnumEntry") {
     import pl.iterators.kebs.slick.enums._
-
-    val iso = implicitly[Isomorphism[Greeting, String]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Greeting, String]]
     iso.map(Hello) shouldBe "Hello"
     iso.comap("Hello") shouldBe Hello
   }
@@ -33,11 +29,7 @@ class EnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnumeratum
   test("Implicit isomorphism for EnumEntry - lowercase") {
     import pl.iterators.kebs.slick.enums.lowercase._
 
-    val enumm = new EnumLike[Greeting] {
-      override def values: Seq[Greeting] = Greeting.values}
-
-    val iso = implicitly[Isomorphism[Greeting, String]]
-
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Greeting, String]]
     iso.map(GoodBye) shouldBe "goodbye"
     iso.comap("goodbye") shouldBe GoodBye
   }
@@ -45,7 +37,7 @@ class EnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnumeratum
   test("Implicit isomorphism for EnumEntry - uppercase") {
     import pl.iterators.kebs.slick.enums.uppercase._
 
-    val iso = implicitly[Isomorphism[Greeting, String]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Greeting, String]]
     iso.map(GoodBye) shouldBe "GOODBYE"
     iso.comap("GOODBYE") shouldBe GoodBye
   }
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala
index 0e6bed9d..1b275ff8 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala
@@ -3,11 +3,10 @@ package pl.iterators.kebs.slick.enums
 import enumeratum.{Enum, EnumEntry}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
-import pl.iterators.kebs.enumeratum.KebsEnumeratum
 
-class SlickMappedEnumColumnTypeTests extends AnyFunSuite with Matchers with KebsEnumeratum {
+class SlickMappedEnumColumnTypeTests extends AnyFunSuite with Matchers {
   import slick.jdbc.PostgresProfile.api._
-  import pl.iterators.kebs.slick.enums._
+  import pl.iterators.kebs.enumeratum._
 
   sealed trait WorkerAccountStatus extends EnumEntry
   object WorkerAccountStatus extends Enum[WorkerAccountStatus] {
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala
index 6b1c6f6b..cfbe3b30 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala
@@ -4,11 +4,10 @@ import enumeratum.values.{IntEnum, IntEnumEntry}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 import pl.iterators.kebs.core.enums.ValueEnumLikeEntry
-import pl.iterators.kebs.enumeratum.KebsValueEnumeratum
 
-class SlickMappedValueEnumColumnTypeTests extends AnyFunSuite with Matchers with KebsValueEnumeratum {
+class SlickMappedValueEnumColumnTypeTests extends AnyFunSuite with Matchers {
   import slick.jdbc.PostgresProfile.api._
-  import pl.iterators.kebs.slick.enums._
+  import pl.iterators.kebs.enumeratum._
 
   sealed abstract class WorkerAccountStatusInt(val value: Int) extends IntEnumEntry with ValueEnumLikeEntry[Int]
   object WorkerAccountStatusInt extends IntEnum[WorkerAccountStatusInt] {
@@ -18,7 +17,7 @@ class SlickMappedValueEnumColumnTypeTests extends AnyFunSuite with Matchers with
 
     override val values = findValues
   }
-  
+
   test("MappedColumnType for value enum entries") {
     "implicitly[BaseColumnType[WorkerAccountStatusInt]]" should compile
   }
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala
index ff6622cc..3bb2fd15 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala
@@ -4,10 +4,10 @@ import enumeratum.values.{IntEnum, IntEnumEntry}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 import pl.iterators.kebs.core.enums.ValueEnumLikeEntry
-import slick.lifted.Isomorphism
-import pl.iterators.kebs.enumeratum.KebsEnumeratum
+import pl.iterators.kebs.enumeratum._
 
-class ValueEnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnumeratum {
+class ValueEnumIsomorphismTests extends AnyFunSuite with Matchers {
+  import slick.jdbc.PostgresProfile.api._
 
   sealed abstract class IntGreeting(val value: Int) extends IntEnumEntry with ValueEnumLikeEntry[Int]
 
@@ -23,9 +23,8 @@ class ValueEnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnume
   import IntGreeting._
 
   test("Implicit isomorphism from ValueEnumEntry") {
-  import pl.iterators.kebs.slick.enums._
 
-    val iso = implicitly[Isomorphism[IntGreeting, Int]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[IntGreeting, Int]]
     iso.map(Bye) shouldBe 3
     iso.comap(3) shouldBe Bye
   }
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala
index 657d8af2..976740ca 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala
@@ -2,19 +2,18 @@ package pl.iterators.kebs.slick.hstore
 
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
-import pl.iterators.kebs.instances.time.{DayOfWeekInt, YearMonthString}
 import pl.iterators.kebs.instances.time.mixins.InstantEpochMilliLong
-import slick.lifted.Isomorphism
+import pl.iterators.kebs.instances.time.{DayOfWeekInt, YearMonthString}
+import pl.iterators.kebs.slick.Kebs
 
-class MapIsomorphismTest extends AnyFunSuite with Matchers with YearMonthString with DayOfWeekInt with InstantEpochMilliLong {
-  import pl.iterators.kebs.slick._
+class MapIsomorphismTest extends AnyFunSuite with Matchers with YearMonthString with DayOfWeekInt with InstantEpochMilliLong with Kebs {
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
+  import slick.jdbc.PostgresProfile.api._
 
   case class StringValue(value: String)
   case class IntValue(value: Int)
 
   test("No ValueClassLike implicits derived") {
-    import pl.iterators.kebs.core.macros.ValueClassLike
-
     "implicitly[ValueClassLike[YearMonth, String]]" shouldNot typeCheck
     "implicitly[ValueClassLike[String, YearMonth]]" shouldNot typeCheck
     "implicitly[ValueClassLike[DayOfWeek, Int]]" shouldNot typeCheck
@@ -24,127 +23,127 @@ class MapIsomorphismTest extends AnyFunSuite with Matchers with YearMonthString
   }
 
   test("Case classes isomorphisms implies string to int map isomorphism") {
-    val iso = implicitly[Isomorphism[Map[StringValue, IntValue], Map[String, Int]]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[StringValue, IntValue], Map[String, Int]]]
     iso.map(Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))) shouldBe Map("a"    -> 0, "b"                        -> 1)
     iso.comap(Map("a"            -> 0, "b"                        -> 1)) shouldBe Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))
   }
 
-  test("Case classes isomorphisms implies string to string map isomorphism") {
-    val iso = implicitly[Isomorphism[Map[StringValue, IntValue], Map[String, String]]]
-    iso.map(Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))) shouldBe Map("a"      -> "0", "b"                      -> "1")
-    iso.comap(Map("a"            -> "0", "b"                      -> "1")) shouldBe Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))
-  }
+    test("Case classes isomorphisms implies string to string map isomorphism") {
+      val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[StringValue, IntValue], Map[String, String]]]
+      iso.map(Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))) shouldBe Map("a"      -> "0", "b"                      -> "1")
+      iso.comap(Map("a"            -> "0", "b"                      -> "1")) shouldBe Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))
+    }
 
   test("Case classes isomorphisms implies int to string map isomorphism") {
-    val iso = implicitly[Isomorphism[Map[IntValue, StringValue], Map[Int, String]]]
+    val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[IntValue, StringValue], Map[Int, String]]]
     iso.map(Map(IntValue(0) -> StringValue("a"), IntValue(1) -> StringValue("b"))) shouldBe Map(0 -> "a", 1                        -> "b")
     iso.comap(Map(0         -> "a", 1                        -> "b")) shouldBe Map(IntValue(0)    -> StringValue("a"), IntValue(1) -> StringValue("b"))
   }
 
-  test("Case classes isomorphisms implies string to string map isomorphism 2") {
-    val iso = implicitly[Isomorphism[Map[IntValue, StringValue], Map[String, String]]]
-    iso.map(Map(IntValue(0) -> StringValue("a"), IntValue(1) -> StringValue("b"))) shouldBe Map("0" -> "a", "1"                      -> "b")
-    iso.comap(Map("0"       -> "a", "1"                      -> "b")) shouldBe Map(IntValue(0)      -> StringValue("a"), IntValue(1) -> StringValue("b"))
-  }
+    test("Case classes isomorphisms implies string to string map isomorphism 2") {
+      val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[IntValue, StringValue], Map[String, String]]]
+      iso.map(Map(IntValue(0) -> StringValue("a"), IntValue(1) -> StringValue("b"))) shouldBe Map("0" -> "a", "1"                      -> "b")
+      iso.comap(Map("0"       -> "a", "1"                      -> "b")) shouldBe Map(IntValue(0)      -> StringValue("a"), IntValue(1) -> StringValue("b"))
+    }
 
   import java.time.{DayOfWeek, YearMonth, Instant}
 
   /* InstanceConverter[Obj, String] */
   test("Map[Obj[String], String] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[YearMonth, String], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[YearMonth, String], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[String, Obj[String]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[String, YearMonth], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[String, YearMonth], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[String], Int] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[YearMonth, Int], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[YearMonth, Int], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Int, Obj[String]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Int, YearMonth], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Int, YearMonth], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[String], Long] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[YearMonth, Long], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[YearMonth, Long], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Long, Obj[String]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Long, YearMonth], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Long, YearMonth], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[String], Boolean] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[YearMonth, Boolean], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[YearMonth, Boolean], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Boolean, Obj[String]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Boolean, YearMonth], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Boolean, YearMonth], Map[String, String]]]""".stripMargin should compile
   }
 
   /* implicit InstanceConverter[Obj, Int] */
   test("Map[Obj[Int], String] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[DayOfWeek, String], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[DayOfWeek, String], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[String, Obj[Int]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[String, DayOfWeek], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[String, DayOfWeek], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[Int], Int] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[DayOfWeek, Int], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[DayOfWeek, Int], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Int, Obj[Int]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Int, DayOfWeek], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Int, DayOfWeek], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[Int], Long] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[DayOfWeek, Long], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[DayOfWeek, Long], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Long, Obj[Int]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Long, DayOfWeek], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Long, DayOfWeek], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[Int], Boolean] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[DayOfWeek, Boolean], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[DayOfWeek, Boolean], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Boolean, Obj[Int]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Boolean, DayOfWeek], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Boolean, DayOfWeek], Map[String, String]]]""".stripMargin should compile
   }
 
   /* implicit InstanceConverter[Obj, Long] */
   test("Map[Obj[Long], String] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Instant, String], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Instant, String], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[String, Obj[Long]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[String, Instant], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[String, Instant], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[Long], Int] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Instant, Int], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Instant, Int], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Int, Obj[Long]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Int, Instant], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Int, Instant], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[Long], Long] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Instant, Long], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Instant, Long], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Long, Obj[Long]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Long, Instant], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Long, Instant], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Obj[Long], Boolean] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Instant, Boolean], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Instant, Boolean], Map[String, String]]]""".stripMargin should compile
   }
 
   test("Map[Boolean, Obj[Long]] <-> Map[String, String]") {
-    """val iso = implicitly[Isomorphism[Map[Boolean, Instant], Map[String, String]]]""".stripMargin should compile
+    """val iso = implicitly[slick.jdbc.JdbcTypesComponent#MappedJdbcType[Map[Boolean, Instant], Map[String, String]]]""".stripMargin should compile
   }
 }
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala
index fe8ccaa2..424a9296 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala
@@ -5,14 +5,15 @@ import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
 class SlickPgHstoreColumnTypeTests extends AnyFunSuite with Matchers {
+  import pl.iterators.kebs.slick.Kebs
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
   import pl.iterators.kebs.instances.time.{DayOfWeekInt, YearMonthString}
   import pl.iterators.kebs.instances.time.mixins.InstantEpochMilliLong
-  import pl.iterators.kebs.slick.Kebs
   import java.time.{DayOfWeek, YearMonth, Instant}
 
   object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport {
     override val api: APIWithHStore = new APIWithHStore {}
-    trait APIWithHStore extends super.API with HStoreImplicits with Kebs with YearMonthString with DayOfWeekInt with InstantEpochMilliLong
+    trait APIWithHStore extends super.ExtPostgresAPI with HStoreImplicits with Kebs with YearMonthString with DayOfWeekInt with InstantEpochMilliLong
   }
 
   case class CategoryName(name: String)
@@ -21,7 +22,6 @@ class SlickPgHstoreColumnTypeTests extends AnyFunSuite with Matchers {
   import MyPostgresProfile.api._
 
   test("No ValueClassLike implicits derived") {
-    import pl.iterators.kebs.core.macros.ValueClassLike
 
     "implicitly[ValueClassLike[YearMonth, String]]" shouldNot typeCheck
     "implicitly[ValueClassLike[String, YearMonth]]" shouldNot typeCheck
@@ -42,7 +42,7 @@ class SlickPgHstoreColumnTypeTests extends AnyFunSuite with Matchers {
       |""".stripMargin should compile
   }
 
-  /* ValueClassLike[Obj, String] */
+  /* CaseClass1Rep[Obj, String] */
   test("Map[Obj[String], String] column type") {
     """
       |class HStoreTestTable(tag: Tag) extends Table[(Long, Map[YearMonth, String])](tag, "HStoreTestTable") {
@@ -131,7 +131,7 @@ class SlickPgHstoreColumnTypeTests extends AnyFunSuite with Matchers {
       |""".stripMargin should compile
   }
 
-  /* ValueClassLike[Obj, Int] */
+  /* CaseClass1Rep[Obj, Int] */
   test("Map[Obj[Int], String] column type") {
     """
       |class HStoreTestTable(tag: Tag) extends Table[(Long, Map[DayOfWeek, String])](tag, "HStoreTestTable") {
@@ -220,7 +220,7 @@ class SlickPgHstoreColumnTypeTests extends AnyFunSuite with Matchers {
       |""".stripMargin should compile
   }
 
-  /* ValueClassLike[Obj, Long] */
+  /* CaseClass1Rep[Obj, Long] */
   test("Map[Obj[Long], String] column type") {
     """
       |class HStoreTestTable(tag: Tag) extends Table[(Long, Map[Instant, String])](tag, "HStoreTestTable") {
diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala
index da17c270..50b4aa33 100644
--- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala
+++ b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala
@@ -9,12 +9,13 @@ import java.time.YearMonth
 import java.util.UUID
 
 class SlickPgHstoreTests extends AnyFunSuite with Matchers {
-  import pl.iterators.kebs.instances.time.YearMonthString
   import pl.iterators.kebs.slick.Kebs
+  import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._
+  import pl.iterators.kebs.instances.time.YearMonthString
 
   trait PostgresDriver extends ExPostgresProfile with PgArraySupport with PgHStoreSupport {
     override val api: HstoreAPI = new HstoreAPI {}
-    trait HstoreAPI extends super.API with ArrayImplicits with HStoreImplicits with Kebs with YearMonthString
+    trait HstoreAPI extends super.ExtPostgresAPI with ArrayImplicits with HStoreImplicits with Kebs with YearMonthString
   }
   object PostgresDriver extends PostgresDriver
 
@@ -42,7 +43,6 @@ class SlickPgHstoreTests extends AnyFunSuite with Matchers {
   }
 
   test("No ValueClassLike implicits derived") {
-    import pl.iterators.kebs.core.macros.ValueClassLike
 
     "implicitly[ValueClassLike[YearMonth, String]]" shouldNot typeCheck
     "implicitly[ValueClassLike[String, YearMonth]]" shouldNot typeCheck
diff --git a/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala b/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala
index 79d18d1d..a7afb5ba 100644
--- a/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala
+++ b/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala
@@ -1,8 +1,8 @@
 package pl.iterators.kebs.tagged.slick
 
-import slick.lifted.Isomorphism
 import pl.iterators.kebs.tagged._
+import _root_.slick.jdbc.JdbcProfile
 
 trait SlickSupport {
-  implicit def taggedColumnType[T, U]: Isomorphism[T @@ U, T] = new Isomorphism[T @@ U, T](identity, _.@@[U])
+  implicit def taggedColumnType[T, U](implicit bct: JdbcProfile#BaseColumnType[T], jp: JdbcProfile): _root_.slick.jdbc.JdbcTypesComponent#MappedJdbcType[T @@ U, T] = jp.MappedColumnType.base[T @@ U, T](identity, _.@@[U]).asInstanceOf[_root_.slick.jdbc.JdbcTypesComponent#MappedJdbcType[T @@ U, T]]
 }
diff --git a/tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala b/tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala
index 0bf1ce38..17c71d5c 100644
--- a/tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala
+++ b/tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala
@@ -1,10 +1,10 @@
 import pl.iterators.kebs.tagged.slick.SlickSupport
-import slick.lifted.Isomorphism
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
 class TaggedTypeIsomorphismTests extends AnyFunSuite with Matchers with SlickSupport {
   import pl.iterators.kebs.tagged._
+  import _root_.slick.jdbc.PostgresProfile.api._
 
   trait Tag1
 
@@ -14,13 +14,13 @@ class TaggedTypeIsomorphismTests extends AnyFunSuite with Matchers with SlickSup
   }
 
   test("implicit isomorphism between bare type and type with tag") {
-    val iso = implicitly[Isomorphism[Int @@ Tag1, Int]]
+    val iso = implicitly[_root_.slick.jdbc.JdbcTypesComponent#MappedJdbcType[Int @@ Tag1, Int]]
     iso.map(Simple(10)) shouldBe 10
     iso.comap(10) shouldBe Simple(10)
   }
 
   test("implicit isomorphism between bare type and type with tag (alias)") {
-    val iso = implicitly[Isomorphism[Simple, Int]]
+    val iso = implicitly[_root_.slick.jdbc.JdbcTypesComponent#MappedJdbcType[Simple, Int]]
     iso.map(Simple(10)) shouldBe 10
     iso.comap(10) shouldBe Simple(10)
   }