diff --git a/core/src/main/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpression.kt b/core/src/main/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpression.kt
index e03cc83c..c34519ee 100644
--- a/core/src/main/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpression.kt
+++ b/core/src/main/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpression.kt
@@ -10,7 +10,7 @@ import ch.ergon.dope.validtype.StringType
 class SubstringExpression(
     private val inStr: TypeExpression<StringType>,
     private val startPos: Int,
-    private val length: Int,
+    private val length: Int? = null,
 ) : TypeExpression<StringType>, FunctionOperator {
     override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
         val inStrDopeQuery = inStr.toDopeQuery(manager)
@@ -19,13 +19,13 @@ class SubstringExpression(
                 symbol = "SUBSTR",
                 inStrDopeQuery,
                 startPos.toDopeType().toDopeQuery(manager),
-                length.toDopeType().toDopeQuery(manager),
+                length?.toDopeType()?.toDopeQuery(manager),
             ),
             parameters = inStrDopeQuery.parameters,
         )
     }
 }
 
-fun substr(inStr: TypeExpression<StringType>, startPos: Int, length: Int) = SubstringExpression(inStr, startPos, length)
+fun substr(inStr: TypeExpression<StringType>, startPos: Int, length: Int? = null) = SubstringExpression(inStr, startPos, length)
 
-fun substr(inStr: String, startPos: Int, length: Int = inStr.length) = substr(inStr.toDopeType(), startPos, length)
+fun substr(inStr: String, startPos: Int, length: Int? = null) = substr(inStr.toDopeType(), startPos, length)
diff --git a/core/src/test/kotlin/ch/ergon/dope/buildTest/StringFunctionsTest.kt b/core/src/test/kotlin/ch/ergon/dope/buildTest/StringFunctionsTest.kt
index fbd5068c..be906123 100644
--- a/core/src/test/kotlin/ch/ergon/dope/buildTest/StringFunctionsTest.kt
+++ b/core/src/test/kotlin/ch/ergon/dope/buildTest/StringFunctionsTest.kt
@@ -599,7 +599,7 @@ class StringFunctionsTest : ManagerDependentTest {
     @Test
     fun `should Support Substring`() {
         val expected =
-            "SELECT SUBSTR(\"N1QL is awesome\", 3, 15) AS `end_of_string`, SUBSTR(\"N1QL is awesome\", 3, 1) AS" +
+            "SELECT SUBSTR(\"N1QL is awesome\", 3) AS `end_of_string`, SUBSTR(\"N1QL is awesome\", 3, 1) AS" +
                 " `single_letter`, SUBSTR(\"N1QL is awesome\", 3, 3) AS `three_letters`"
 
         val actual: String = create.select(
diff --git a/core/src/test/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpressionTest.kt b/core/src/test/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpressionTest.kt
index 93401489..66659012 100644
--- a/core/src/test/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpressionTest.kt
+++ b/core/src/test/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/function/stringfunction/SubstringExpressionTest.kt
@@ -52,6 +52,17 @@ class SubstringExpressionTest : ManagerDependentTest {
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
+    @Test
+    fun `should support substring function type int`() {
+        val inStr = someStringField("inStr")
+        val startPos = 1
+        val expected = SubstringExpression(inStr, startPos)
+
+        val actual = substr(inStr, startPos)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
     @Test
     fun `should support substring function string int int`() {
         val inStr = someString("inStr")
@@ -68,8 +79,7 @@ class SubstringExpressionTest : ManagerDependentTest {
     fun `should support substring function string int`() {
         val inStr = someString("inStr")
         val startPos = 1
-        val length = inStr.length
-        val expected = SubstringExpression(inStr.toDopeType(), startPos, length)
+        val expected = SubstringExpression(inStr.toDopeType(), startPos)
 
         val actual = substr(inStr, startPos)
 
diff --git a/crystal-map-connector/build.gradle.kts b/crystal-map-connector/build.gradle.kts
index 7cd3ae4d..ca8b5381 100644
--- a/crystal-map-connector/build.gradle.kts
+++ b/crystal-map-connector/build.gradle.kts
@@ -32,7 +32,7 @@ repositories {
 }
 
 dependencies {
-    implementation("com.github.SchwarzIT.crystal-map:crystal-map-api:3.18.0")
+    implementation("com.github.SchwarzIT.crystal-map:crystal-map-api:4.0.3")
     implementation(kotlin("reflect"))
     implementation(project(":core"))
 
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/CrystalMapAdapter.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/CrystalMapAdapter.kt
index 65f5cfc9..8df734fd 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/CrystalMapAdapter.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/CrystalMapAdapter.kt
@@ -1,6 +1,8 @@
 package ch.ergon.dope
 
+import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.Field
+import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.resolvable.formatPathToQueryString
 import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
@@ -8,41 +10,84 @@ import ch.ergon.dope.validtype.DopeSchemaArray
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMConverterList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMObject
 import com.schwarz.crystalapi.schema.CMObjectList
 import com.schwarz.crystalapi.schema.CMType
 import com.schwarz.crystalapi.schema.Schema
+import kotlin.reflect.KClass
 
 fun CMType.toDopeType(reference: String = path): Field<ValidType> = Field(
     when (this) {
-        is CMField<*> -> this.name
-        is CMList<*> -> this.name
+        is CMJsonField<*> -> this.name
+        is CMJsonList<*> -> this.name
         is CMObjectList<*> -> this.name
         is CMObject<*> -> TODO("DOPE-216")
-        else -> throw IllegalArgumentException("Unsupported type $this")
     },
     reference,
 )
 
+@JvmName("toDopeTypeNumber")
+fun <Convertable : Any, JsonType : Number> Convertable.toDopeType(other: CMConverterField<Convertable, JsonType>): TypeExpression<NumberType> =
+    requireValidConvertable(other.typeConverter.write(this), Number::class).toDopeType()
+
+@JvmName("toDopeTypeString")
+fun <Convertable : Any> Convertable.toDopeType(other: CMConverterField<Convertable, String>): TypeExpression<StringType> =
+    requireValidConvertable(other.typeConverter.write(this), String::class).toDopeType()
+
+@JvmName("toDopeTypeBoolean")
+fun <Convertable : Any> Convertable.toDopeType(other: CMConverterField<Convertable, Boolean>): TypeExpression<BooleanType> =
+    requireValidConvertable(other.typeConverter.write(this), Boolean::class).toDopeType()
+
+@JvmName("toDopeTypeListNumber")
+fun <Convertable : Any, JsonType : Number> Convertable.toDopeType(other: CMConverterList<Convertable, JsonType>): TypeExpression<NumberType> =
+    requireValidConvertable(other.typeConverter.write(this), Number::class).toDopeType()
+
+@JvmName("toDopeTypeListString")
+fun <Convertable : Any> Convertable.toDopeType(other: CMConverterList<Convertable, String>): TypeExpression<StringType> =
+    requireValidConvertable(other.typeConverter.write(this), String::class).toDopeType()
+
+@JvmName("toDopeTypeListBoolean")
+fun <Convertable : Any> Convertable.toDopeType(other: CMConverterList<Convertable, Boolean>): TypeExpression<BooleanType> =
+    requireValidConvertable(other.typeConverter.write(this), Boolean::class).toDopeType()
+
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.toDopeType(other: Convertable) =
+    requireValidConvertable(typeConverter.write(other), Number::class).toDopeType()
+
+fun <Convertable : Any> CMConverterField<Convertable, String>.toDopeType(other: Convertable) =
+    requireValidConvertable(typeConverter.write(other), String::class).toDopeType()
+
+fun <Convertable : Any> CMConverterField<Convertable, Boolean>.toDopeType(other: Convertable) =
+    requireValidConvertable(typeConverter.write(other), Boolean::class).toDopeType()
+
 @JvmName("toDopeNumberField")
-fun CMField<out Number>.toDopeType(reference: String = path): Field<NumberType> = Field(name, reference)
+fun CMJsonField<out Number>.toDopeType(reference: String = path): Field<NumberType> = Field(name, reference)
 
 @JvmName("toDopeStringField")
-fun CMField<String>.toDopeType(reference: String = path): Field<StringType> = Field(name, reference)
+fun CMJsonField<String>.toDopeType(reference: String = path): Field<StringType> = Field(name, reference)
 
 @JvmName("toDopeBooleanField")
-fun CMField<Boolean>.toDopeType(reference: String = path): Field<BooleanType> = Field(name, reference)
+fun CMJsonField<Boolean>.toDopeType(reference: String = path): Field<BooleanType> = Field(name, reference)
 
 @JvmName("toDopeNumberArrayField")
-fun CMList<out Number>.toDopeType(): Field<ArrayType<NumberType>> = Field(name, path)
+fun CMJsonList<out Number>.toDopeType(): Field<ArrayType<NumberType>> = Field(name, path)
 
 @JvmName("toDopeStringArrayField")
-fun CMList<String>.toDopeType(): Field<ArrayType<StringType>> = Field(name, path)
+fun CMJsonList<String>.toDopeType(): Field<ArrayType<StringType>> = Field(name, path)
 
 @JvmName("toDopeBooleanArrayField")
-fun CMList<Boolean>.toDopeType(): Field<ArrayType<BooleanType>> = Field(name, path)
+fun CMJsonList<Boolean>.toDopeType(): Field<ArrayType<BooleanType>> = Field(name, path)
+
+fun CMJsonList<out Any>.toDopeType(): Field<ArrayType<ValidType>> = Field(name, path)
 
 // TODO: DOPE-192
 fun <T : Schema> CMObjectList<T>.toDopeType() = DopeSchemaArray(element, formatPathToQueryString(name, path))
+
+private fun <Convertable : Any, JsonType : Any> Convertable.requireValidConvertable(jsonType: JsonType?, jsonTypeClass: KClass<JsonType>) =
+    requireNotNull(jsonType) {
+        "Conversion failed: " +
+            "The value of type '${this::class.simpleName}' couldn't be converted to the expected JSON type '${jsonTypeClass.simpleName}'. "
+    }
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/ArrayAggregate.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/ArrayAggregate.kt
index 4fe8ed3e..22dfaab2 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/ArrayAggregate.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/ArrayAggregate.kt
@@ -5,29 +5,29 @@ import ch.ergon.dope.resolvable.expression.unaliased.aggregator.ArrayAggregateEx
 import ch.ergon.dope.resolvable.expression.unaliased.aggregator.arrayAggregate
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.ValidType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("arrayAggNumber")
-fun arrayAggregate(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun arrayAggregate(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     ArrayAggregateExpression<out ValidType> = arrayAggregate(field.toDopeType(), quantifier)
 
 @JvmName("arrayAggString")
-fun arrayAggregate(field: CMField<String>, quantifier: AggregateQuantifier? = null):
+fun arrayAggregate(field: CMJsonField<String>, quantifier: AggregateQuantifier? = null):
     ArrayAggregateExpression<out ValidType> = arrayAggregate(field.toDopeType(), quantifier)
 
 @JvmName("arrayAggBoolean")
-fun arrayAggregate(field: CMField<Boolean>, quantifier: AggregateQuantifier? = null):
+fun arrayAggregate(field: CMJsonField<Boolean>, quantifier: AggregateQuantifier? = null):
     ArrayAggregateExpression<out ValidType> = arrayAggregate(field.toDopeType(), quantifier)
 
 @JvmName("arrayAggNumberArray")
-fun arrayAggregate(field: CMList<out Number>, quantifier: AggregateQuantifier? = null):
+fun arrayAggregate(field: CMJsonList<out Number>, quantifier: AggregateQuantifier? = null):
     ArrayAggregateExpression<out ValidType> = arrayAggregate(field.toDopeType(), quantifier)
 
 @JvmName("arrayAggStringArray")
-fun arrayAggregate(field: CMList<String>, quantifier: AggregateQuantifier? = null):
+fun arrayAggregate(field: CMJsonList<String>, quantifier: AggregateQuantifier? = null):
     ArrayAggregateExpression<out ValidType> = arrayAggregate(field.toDopeType(), quantifier)
 
 @JvmName("arrayAggBooleanArray")
-fun arrayAggregate(field: CMList<Boolean>, quantifier: AggregateQuantifier? = null):
+fun arrayAggregate(field: CMJsonList<Boolean>, quantifier: AggregateQuantifier? = null):
     ArrayAggregateExpression<out ValidType> = arrayAggregate(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Count.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Count.kt
index a85b2818..ce980c60 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Count.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Count.kt
@@ -4,29 +4,29 @@ import ch.ergon.dope.resolvable.expression.unaliased.aggregator.AggregateQuantif
 import ch.ergon.dope.resolvable.expression.unaliased.aggregator.CountExpression
 import ch.ergon.dope.resolvable.expression.unaliased.aggregator.count
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("countNumber")
-fun count(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun count(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     CountExpression = count(field.toDopeType(), quantifier)
 
 @JvmName("countString")
-fun count(field: CMField<String>, quantifier: AggregateQuantifier? = null):
+fun count(field: CMJsonField<String>, quantifier: AggregateQuantifier? = null):
     CountExpression = count(field.toDopeType(), quantifier)
 
 @JvmName("countBoolean")
-fun count(field: CMField<Boolean>, quantifier: AggregateQuantifier? = null):
+fun count(field: CMJsonField<Boolean>, quantifier: AggregateQuantifier? = null):
     CountExpression = count(field.toDopeType(), quantifier)
 
 @JvmName("countNumber")
-fun count(field: CMList<out Number>, quantifier: AggregateQuantifier? = null):
+fun count(field: CMJsonList<out Number>, quantifier: AggregateQuantifier? = null):
     CountExpression = count(field.toDopeType(), quantifier)
 
 @JvmName("countString")
-fun count(field: CMList<String>, quantifier: AggregateQuantifier? = null):
+fun count(field: CMJsonList<String>, quantifier: AggregateQuantifier? = null):
     CountExpression = count(field.toDopeType(), quantifier)
 
 @JvmName("countBoolean")
-fun count(field: CMList<Boolean>, quantifier: AggregateQuantifier? = null):
+fun count(field: CMJsonList<Boolean>, quantifier: AggregateQuantifier? = null):
     CountExpression = count(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Max.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Max.kt
index 2e66efe3..cbc93f97 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Max.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Max.kt
@@ -5,29 +5,29 @@ import ch.ergon.dope.resolvable.expression.unaliased.aggregator.MaxExpression
 import ch.ergon.dope.resolvable.expression.unaliased.aggregator.max
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.ValidType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("maxNumber")
-fun max(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun max(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     MaxExpression<out ValidType> = max(field.toDopeType(), quantifier)
 
 @JvmName("maxString")
-fun max(field: CMField<String>, quantifier: AggregateQuantifier? = null):
+fun max(field: CMJsonField<String>, quantifier: AggregateQuantifier? = null):
     MaxExpression<out ValidType> = max(field.toDopeType(), quantifier)
 
 @JvmName("maxBoolean")
-fun max(field: CMField<Boolean>, quantifier: AggregateQuantifier? = null):
+fun max(field: CMJsonField<Boolean>, quantifier: AggregateQuantifier? = null):
     MaxExpression<out ValidType> = max(field.toDopeType(), quantifier)
 
 @JvmName("maxNumber")
-fun max(field: CMList<out Number>, quantifier: AggregateQuantifier? = null):
+fun max(field: CMJsonList<out Number>, quantifier: AggregateQuantifier? = null):
     MaxExpression<out ValidType> = max(field.toDopeType(), quantifier)
 
 @JvmName("maxString")
-fun max(field: CMList<String>, quantifier: AggregateQuantifier? = null):
+fun max(field: CMJsonList<String>, quantifier: AggregateQuantifier? = null):
     MaxExpression<out ValidType> = max(field.toDopeType(), quantifier)
 
 @JvmName("maxBoolean")
-fun max(field: CMList<Boolean>, quantifier: AggregateQuantifier? = null):
+fun max(field: CMJsonList<Boolean>, quantifier: AggregateQuantifier? = null):
     MaxExpression<out ValidType> = max(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Min.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Min.kt
index 24122292..c1534d98 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Min.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/Min.kt
@@ -5,29 +5,29 @@ import ch.ergon.dope.resolvable.expression.unaliased.aggregator.MinExpression
 import ch.ergon.dope.resolvable.expression.unaliased.aggregator.min
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.ValidType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("minNumber")
-fun min(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun min(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     MinExpression<out ValidType> = min(field.toDopeType(), quantifier)
 
 @JvmName("minString")
-fun min(field: CMField<String>, quantifier: AggregateQuantifier? = null):
+fun min(field: CMJsonField<String>, quantifier: AggregateQuantifier? = null):
     MinExpression<out ValidType> = min(field.toDopeType(), quantifier)
 
 @JvmName("minBoolean")
-fun min(field: CMField<Boolean>, quantifier: AggregateQuantifier? = null):
+fun min(field: CMJsonField<Boolean>, quantifier: AggregateQuantifier? = null):
     MinExpression<out ValidType> = min(field.toDopeType(), quantifier)
 
 @JvmName("minNumber")
-fun min(field: CMList<out Number>, quantifier: AggregateQuantifier? = null):
+fun min(field: CMJsonList<out Number>, quantifier: AggregateQuantifier? = null):
     MinExpression<out ValidType> = min(field.toDopeType(), quantifier)
 
 @JvmName("minString")
-fun min(field: CMList<String>, quantifier: AggregateQuantifier? = null):
+fun min(field: CMJsonList<String>, quantifier: AggregateQuantifier? = null):
     MinExpression<out ValidType> = min(field.toDopeType(), quantifier)
 
 @JvmName("minBoolean")
-fun min(field: CMList<Boolean>, quantifier: AggregateQuantifier? = null):
+fun min(field: CMJsonList<Boolean>, quantifier: AggregateQuantifier? = null):
     MinExpression<out ValidType> = min(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/NumberAggregate.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/NumberAggregate.kt
index da57b697..5db3567e 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/NumberAggregate.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/aggregator/NumberAggregate.kt
@@ -15,28 +15,28 @@ import ch.ergon.dope.resolvable.expression.unaliased.aggregator.sum
 import ch.ergon.dope.resolvable.expression.unaliased.aggregator.variance
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("avgNumber")
-fun avg(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun avg(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     AverageExpression<out NumberType> = avg(field.toDopeType(), quantifier)
 
 @JvmName("meanNumber")
-fun mean(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun mean(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     MeanExpression<out NumberType> = mean(field.toDopeType(), quantifier)
 
 @JvmName("medianNumber")
-fun median(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun median(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     MedianExpression<out NumberType> = median(field.toDopeType(), quantifier)
 
 @JvmName("sumNumber")
-fun sum(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun sum(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     SumExpression<out NumberType> = sum(field.toDopeType(), quantifier)
 
 @JvmName("stdDevNumber")
-fun stdDev(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun stdDev(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     StandardDeviationExpression<out NumberType> = stdDev(field.toDopeType(), quantifier)
 
 @JvmName("varianceNumber")
-fun variance(field: CMField<out Number>, quantifier: AggregateQuantifier? = null):
+fun variance(field: CMJsonField<out Number>, quantifier: AggregateQuantifier? = null):
     VarianceExpression<out NumberType> = variance(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/DeleteClause.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/DeleteClause.kt
index 1907f55e..79d287f7 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/DeleteClause.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/DeleteClause.kt
@@ -6,18 +6,18 @@ import ch.ergon.dope.resolvable.clause.IDeleteOffsetClause
 import ch.ergon.dope.resolvable.clause.IDeleteUseKeysClause
 import ch.ergon.dope.resolvable.clause.IDeleteWhereClause
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMType
 
 fun IDeleteOffsetClause.returning(field: CMType, vararg fields: CMType) =
     returning(field.toDopeType(), *fields.map { it.toDopeType() }.toTypedArray())
 
-fun IDeleteLimitClause.offset(numberExpression: CMField<Number>) = offset(numberExpression.toDopeType())
+fun IDeleteLimitClause.offset(numberExpression: CMJsonField<Number>) = offset(numberExpression.toDopeType())
 
-fun IDeleteWhereClause.limit(numberExpression: CMField<Number>) = limit(numberExpression.toDopeType())
+fun IDeleteWhereClause.limit(numberExpression: CMJsonField<Number>) = limit(numberExpression.toDopeType())
 
-fun IDeleteUseKeysClause.where(booleanExpression: CMField<Boolean>) = where(booleanExpression.toDopeType())
+fun IDeleteUseKeysClause.where(booleanExpression: CMJsonField<Boolean>) = where(booleanExpression.toDopeType())
 
-fun IDeleteClause.useKeys(useKeys: CMField<String>) = useKeys(useKeys.toDopeType())
-fun IDeleteClause.useKeys(useKeys: CMList<String>) = useKeys(useKeys.toDopeType())
+fun IDeleteClause.useKeys(useKeys: CMJsonField<String>) = useKeys(useKeys.toDopeType())
+fun IDeleteClause.useKeys(useKeys: CMJsonList<String>) = useKeys(useKeys.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/SelectClause.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/SelectClause.kt
index cfc1c43e..d0f6d97b 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/SelectClause.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/SelectClause.kt
@@ -11,41 +11,43 @@ import ch.ergon.dope.resolvable.clause.ISelectWhereClause
 import ch.ergon.dope.resolvable.clause.model.OrderByType
 import ch.ergon.dope.resolvable.fromable.Bucket
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMType
 
-fun ISelectLimitClause.offset(numberField: CMField<Number>) = offset(numberField.toDopeType())
+fun ISelectLimitClause.offset(numberField: CMJsonField<Number>) = offset(numberField.toDopeType())
 
-fun ISelectOrderByClause.limit(numberField: CMField<Number>) = limit(numberField.toDopeType())
+fun ISelectOrderByClause.limit(numberField: CMJsonField<Number>) = limit(numberField.toDopeType())
 
-fun ISelectGroupByClause.orderBy(stringField: CMField<String>) = orderBy(stringField.toDopeType())
+fun ISelectGroupByClause.orderBy(stringField: CMJsonField<String>) = orderBy(stringField.toDopeType())
 
-fun ISelectGroupByClause.orderBy(stringField: CMField<String>, orderByType: OrderByType) =
+fun ISelectGroupByClause.orderBy(stringField: CMJsonField<String>, orderByType: OrderByType) =
     orderBy(stringField.toDopeType(), orderByType)
 
 fun ISelectWhereClause.groupBy(field: CMType, vararg fields: CMType) =
     groupBy(field.toDopeType(), *fields.map { it.toDopeType() }.toTypedArray())
 
-fun ISelectUseKeysClause.where(whereExpression: CMField<Boolean>) = where(whereExpression.toDopeType())
+fun ISelectUseKeysClause.where(whereExpression: CMJsonField<Boolean>) = where(whereExpression.toDopeType())
 
-fun ISelectFromClause.useKeys(useKeys: CMField<String>) = useKeys(useKeys.toDopeType())
-fun ISelectFromClause.useKeys(useKeys: CMList<String>) = useKeys(useKeys.toDopeType())
+fun ISelectFromClause.useKeys(useKeys: CMJsonField<String>) = useKeys(useKeys.toDopeType())
+fun ISelectFromClause.useKeys(useKeys: CMJsonList<String>) = useKeys(useKeys.toDopeType())
 
-fun ISelectJoinClause.join(bucket: Bucket, onKeys: CMField<out Any>) = join(bucket, onKeys.toDopeType())
-fun ISelectJoinClause.join(bucket: Bucket, onKey: CMField<out Any>, forBucket: Bucket) = join(bucket, onKey.toDopeType(), forBucket)
+fun ISelectJoinClause.join(bucket: Bucket, onKeys: CMJsonField<out Any>) = join(bucket, onKeys.toDopeType())
+fun ISelectJoinClause.join(bucket: Bucket, onKey: CMJsonField<out Any>, forBucket: Bucket) = join(bucket, onKey.toDopeType(), forBucket)
 
-fun ISelectJoinClause.innerJoin(bucket: Bucket, onKeys: CMField<out Any>) = innerJoin(bucket, onKeys.toDopeType())
-fun ISelectJoinClause.innerJoin(bucket: Bucket, onKey: CMField<out Any>, forBucket: Bucket) = innerJoin(bucket, onKey.toDopeType(), forBucket)
+fun ISelectJoinClause.innerJoin(bucket: Bucket, onKeys: CMJsonField<out Any>) = innerJoin(bucket, onKeys.toDopeType())
+fun ISelectJoinClause.innerJoin(bucket: Bucket, onKey: CMJsonField<out Any>, forBucket: Bucket) =
+    innerJoin(bucket, onKey.toDopeType(), forBucket)
 
-fun ISelectJoinClause.leftJoin(bucket: Bucket, onKeys: CMField<out Any>) = leftJoin(bucket, onKeys.toDopeType())
-fun ISelectJoinClause.leftJoin(bucket: Bucket, onKey: CMField<out Any>, forBucket: Bucket) = leftJoin(bucket, onKey.toDopeType(), forBucket)
+fun ISelectJoinClause.leftJoin(bucket: Bucket, onKeys: CMJsonField<out Any>) = leftJoin(bucket, onKeys.toDopeType())
+fun ISelectJoinClause.leftJoin(bucket: Bucket, onKey: CMJsonField<out Any>, forBucket: Bucket) =
+    leftJoin(bucket, onKey.toDopeType(), forBucket)
 
 @JvmName("unnestString")
-fun ISelectUnnestClause.unnest(arrayField: CMList<String>) = unnest(arrayField.toDopeType())
+fun ISelectUnnestClause.unnest(arrayField: CMJsonList<String>) = unnest(arrayField.toDopeType())
 
 @JvmName("unnestNumber")
-fun ISelectUnnestClause.unnest(arrayField: CMList<Number>) = unnest(arrayField.toDopeType())
+fun ISelectUnnestClause.unnest(arrayField: CMJsonList<Number>) = unnest(arrayField.toDopeType())
 
 @JvmName("unnestBoolean")
-fun ISelectUnnestClause.unnest(arrayField: CMList<Boolean>) = unnest(arrayField.toDopeType())
+fun ISelectUnnestClause.unnest(arrayField: CMJsonList<Boolean>) = unnest(arrayField.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/UpdateClause.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/UpdateClause.kt
index 9a4daec7..f3b689de 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/UpdateClause.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/UpdateClause.kt
@@ -15,16 +15,17 @@ import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMType
 
 fun IUpdateLimitClause.returning(field: CMType, vararg fields: CMType) =
     returning(field.toDopeType(), *fields.map { it.toDopeType() }.toTypedArray())
 
-fun IUpdateWhereClause.limit(numberField: CMField<Number>) = limit(numberField.toDopeType())
+fun IUpdateWhereClause.limit(numberField: CMJsonField<Number>) = limit(numberField.toDopeType())
 
-fun IUpdateUnsetClause.where(whereExpression: CMField<Boolean>) = where(whereExpression.toDopeType())
+fun IUpdateUnsetClause.where(whereExpression: CMJsonField<Boolean>) = where(whereExpression.toDopeType())
 
 fun IUpdateUnsetClause.unset(field: CMType) =
     UnsetClause(field.toDopeType(), parentClause = this)
@@ -34,183 +35,219 @@ fun UnsetClause.unset(field: CMType) =
 
 @JvmName("setCMNumberFieldToCMNumberField")
 fun IUpdateSetClause.set(
-    field: CMField<out Number>,
-    value: CMField<out Number>,
+    field: CMJsonField<out Number>,
+    value: CMJsonField<out Number>,
 ) = SetClause(field.toDopeType().to(value.toDopeType()), parentClause = this)
 
 @JvmName("setCMNumberFieldToCMNumberField")
 fun SetClause.set(
-    field: CMField<out Number>,
-    value: CMField<out Number>,
-) = this.set(field.toDopeType(), value.toDopeType())
+    field: CMJsonField<out Number>,
+    value: CMJsonField<out Number>,
+) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMStringFieldToCMStringField")
 fun IUpdateUseKeysClause.set(
-    field: CMField<String>,
-    value: CMField<String>,
+    field: CMJsonField<String>,
+    value: CMJsonField<String>,
 ) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMStringFieldToCMStringField")
 fun SetClause.set(
-    field: CMField<String>,
-    value: CMField<String>,
-) = this.set(field.toDopeType(), value.toDopeType())
+    field: CMJsonField<String>,
+    value: CMJsonField<String>,
+) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMBooleanFieldToCMBooleanField")
 fun IUpdateUseKeysClause.set(
-    field: CMField<Boolean>,
-    value: CMField<Boolean>,
+    field: CMJsonField<Boolean>,
+    value: CMJsonField<Boolean>,
 ) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMBooleanFieldToCMBooleanField")
 fun SetClause.set(
-    field: CMField<Boolean>,
-    value: CMField<Boolean>,
-) = this.set(field.toDopeType(), value.toDopeType())
+    field: CMJsonField<Boolean>,
+    value: CMJsonField<Boolean>,
+) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMNumberListToCMNumberList")
 fun IUpdateUseKeysClause.set(
-    field: CMList<out Number>,
-    value: CMList<out Number>,
+    field: CMJsonList<out Number>,
+    value: CMJsonList<out Number>,
 ) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMNumberListToCMNumberList")
 fun SetClause.set(
-    field: CMList<out Number>,
-    value: CMList<out Number>,
-) = this.set(field.toDopeType(), value.toDopeType())
+    field: CMJsonList<out Number>,
+    value: CMJsonList<out Number>,
+) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMStringListToCMStringList")
 fun IUpdateUseKeysClause.set(
-    field: CMList<String>,
-    value: CMList<String>,
+    field: CMJsonList<String>,
+    value: CMJsonList<String>,
 ) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMStringListToCMStringList")
 fun SetClause.set(
-    field: CMList<String>,
-    value: CMList<String>,
-) = this.set(field.toDopeType(), value.toDopeType())
+    field: CMJsonList<String>,
+    value: CMJsonList<String>,
+) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMBooleanListToCMBooleanList")
 fun IUpdateUseKeysClause.set(
-    field: CMList<Boolean>,
-    value: CMList<Boolean>,
+    field: CMJsonList<Boolean>,
+    value: CMJsonList<Boolean>,
 ) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMBooleanListToCMBooleanList")
 fun SetClause.set(
-    field: CMList<Boolean>,
-    value: CMList<Boolean>,
-) = this.set(field.toDopeType(), value.toDopeType())
+    field: CMJsonList<Boolean>,
+    value: CMJsonList<Boolean>,
+) = set(field.toDopeType(), value.toDopeType())
 
 @JvmName("setCMNumberFieldToNumberTypeExpression")
 fun IUpdateUseKeysClause.set(
-    field: CMField<out Number>,
+    field: CMJsonField<out Number>,
     value: TypeExpression<NumberType>,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMNumberFieldToNumberTypeExpression")
 fun SetClause.set(
-    field: CMField<out Number>,
+    field: CMJsonField<out Number>,
     value: TypeExpression<NumberType>,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
 
 @JvmName("setCMStringFieldToStringTypeExpression")
 fun IUpdateUseKeysClause.set(
-    field: CMField<String>,
+    field: CMJsonField<String>,
     value: TypeExpression<StringType>,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMStringFieldToStringTypeExpression")
 fun SetClause.set(
-    field: CMField<String>,
+    field: CMJsonField<String>,
     value: TypeExpression<StringType>,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
 
 @JvmName("setCMBooleanFieldToBooleanTypeExpression")
 fun IUpdateUseKeysClause.set(
-    field: CMField<Boolean>,
+    field: CMJsonField<Boolean>,
     value: TypeExpression<BooleanType>,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMBooleanFieldToBooleanTypeExpression")
 fun SetClause.set(
-    field: CMField<Boolean>,
+    field: CMJsonField<Boolean>,
     value: TypeExpression<BooleanType>,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
 
 @JvmName("setCMNumberListToNumberArrayTypeExpression")
 fun IUpdateUseKeysClause.set(
-    field: CMList<out Number>,
+    field: CMJsonList<out Number>,
     value: TypeExpression<ArrayType<NumberType>>,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMNumberListToNumberArrayTypeExpression")
 fun SetClause.set(
-    field: CMList<out Number>,
+    field: CMJsonList<out Number>,
     value: TypeExpression<ArrayType<NumberType>>,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
 
 @JvmName("setCMStringListToStringArrayTypeExpression")
 fun IUpdateUseKeysClause.set(
-    field: CMList<String>,
+    field: CMJsonList<String>,
     value: TypeExpression<ArrayType<StringType>>,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMStringListToStringArrayTypeExpression")
 fun SetClause.set(
-    field: CMList<String>,
+    field: CMJsonList<String>,
     value: TypeExpression<ArrayType<StringType>>,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
 
 @JvmName("setCMBooleanListToBooleanArrayTypeExpression")
 fun IUpdateUseKeysClause.set(
-    field: CMList<Boolean>,
+    field: CMJsonList<Boolean>,
     value: TypeExpression<ArrayType<BooleanType>>,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMBooleanListToBooleanArrayTypeExpression")
 fun SetClause.set(
-    field: CMList<Boolean>,
+    field: CMJsonList<Boolean>,
     value: TypeExpression<ArrayType<BooleanType>>,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
 
 @JvmName("setCMNumberFieldToNumber")
 fun IUpdateUseKeysClause.set(
-    field: CMField<out Number>,
+    field: CMJsonField<out Number>,
     value: Number,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMNumberFieldToNumber")
 fun SetClause.set(
-    field: CMField<out Number>,
+    field: CMJsonField<out Number>,
     value: Number,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
+
+@JvmName("setCMConverterNumberFieldToNumber")
+fun <Convertable : Any, JsonType : Number> IUpdateUseKeysClause.set(
+    field: CMConverterField<Convertable, JsonType>,
+    value: Convertable,
+) = set(field.toDopeType(), field.toDopeType(value))
+
+@JvmName("setCMConverterNumberFieldToNumber")
+fun <Convertable : Any, JsonType : Number> SetClause.set(
+    field: CMConverterField<Convertable, JsonType>,
+    value: Convertable,
+) = set(field.toDopeType(), field.toDopeType(value))
 
 @JvmName("setCMStringFieldToString")
 fun IUpdateUseKeysClause.set(
-    field: CMField<String>,
+    field: CMJsonField<String>,
     value: String,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMStringFieldToString")
 fun SetClause.set(
-    field: CMField<String>,
+    field: CMJsonField<String>,
     value: String,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
+
+@JvmName("setCMConverterStringFieldToNumber")
+fun <Convertable : Any> IUpdateUseKeysClause.set(
+    field: CMConverterField<Convertable, String>,
+    value: Convertable,
+) = set(field.toDopeType(), field.toDopeType(value))
+
+@JvmName("setCMConverterStringFieldToNumber")
+fun <Convertable : Any> SetClause.set(
+    field: CMConverterField<Convertable, String>,
+    value: Convertable,
+) = set(field.toDopeType(), field.toDopeType(value))
 
 @JvmName("setCMBooleanFieldToBoolean")
 fun IUpdateUseKeysClause.set(
-    field: CMField<Boolean>,
+    field: CMJsonField<Boolean>,
     value: Boolean,
 ) = set(field.toDopeType(), value)
 
 @JvmName("setCMBooleanFieldToBoolean")
 fun SetClause.set(
-    field: CMField<Boolean>,
+    field: CMJsonField<Boolean>,
     value: Boolean,
-) = this.set(field.toDopeType(), value)
+) = set(field.toDopeType(), value)
+
+@JvmName("setCMConverterBooleanFieldToNumber")
+fun <Convertable : Any> IUpdateUseKeysClause.set(
+    field: CMConverterField<Convertable, Boolean>,
+    value: Convertable,
+) = set(field.toDopeType(), field.toDopeType(value))
+
+@JvmName("setCMConverterBooleanFieldToNumber")
+fun <Convertable : Any> SetClause.set(
+    field: CMConverterField<Convertable, Boolean>,
+    value: Convertable,
+) = set(field.toDopeType(), field.toDopeType(value))
 
-fun IUpdateClause.useKeys(useKeys: CMField<String>) = useKeys(useKeys.toDopeType())
-fun IUpdateClause.useKeys(useKeys: CMList<String>) = useKeys(useKeys.toDopeType())
+fun IUpdateClause.useKeys(useKeys: CMJsonField<String>) = useKeys(useKeys.toDopeType())
+fun IUpdateClause.useKeys(useKeys: CMJsonList<String>) = useKeys(useKeys.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/Negation.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/Negation.kt
index 5de718f9..5a1d3bdd 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/Negation.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/Negation.kt
@@ -2,6 +2,6 @@ package ch.ergon.dope.extension.type.arithmetic
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.arithmetic.neg
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun neg(number: CMField<out Number>) = neg(number.toDopeType())
+fun neg(number: CMJsonField<out Number>) = neg(number.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/NumberInfix.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/NumberInfix.kt
index 2f679423..40df8a31 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/NumberInfix.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/arithmetic/NumberInfix.kt
@@ -9,54 +9,70 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.arithmetic.sub
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun CMField<out Number>.add(numberExpression: TypeExpression<NumberType>) = toDopeType().add(numberExpression)
+fun CMJsonField<out Number>.add(numberExpression: TypeExpression<NumberType>) = toDopeType().add(numberExpression)
 
-fun CMField<out Number>.add(number: CMField<out Number>) = toDopeType().add(number.toDopeType())
+fun CMJsonField<out Number>.add(number: CMJsonField<out Number>) = toDopeType().add(number.toDopeType())
 
-fun TypeExpression<NumberType>.add(number: CMField<out Number>) = add(number.toDopeType())
+fun TypeExpression<NumberType>.add(number: CMJsonField<out Number>) = add(number.toDopeType())
 
-fun Number.add(number: CMField<out Number>) = toDopeType().add(number.toDopeType())
+fun Number.add(number: CMJsonField<out Number>) = toDopeType().add(number.toDopeType())
 
-fun CMField<out Number>.add(number: Number) = toDopeType().add(number.toDopeType())
+fun CMJsonField<out Number>.add(number: Number) = toDopeType().add(number.toDopeType())
 
-fun CMField<out Number>.sub(numberExpression: TypeExpression<NumberType>) = toDopeType().sub(numberExpression)
+fun <Convertable : Any, JsonType : Number> Convertable.add(other: CMConverterField<Convertable, JsonType>) =
+    toDopeType(other).add(other.toDopeType())
 
-fun CMField<out Number>.sub(number: CMField<out Number>) = toDopeType().sub(number.toDopeType())
+fun CMJsonField<out Number>.sub(numberExpression: TypeExpression<NumberType>) = toDopeType().sub(numberExpression)
 
-fun TypeExpression<NumberType>.sub(number: CMField<out Number>) = sub(number.toDopeType())
+fun CMJsonField<out Number>.sub(number: CMJsonField<out Number>) = toDopeType().sub(number.toDopeType())
 
-fun Number.sub(number: CMField<out Number>) = toDopeType().sub(number.toDopeType())
+fun TypeExpression<NumberType>.sub(number: CMJsonField<out Number>) = sub(number.toDopeType())
 
-fun CMField<out Number>.sub(number: Number) = toDopeType().sub(number.toDopeType())
+fun Number.sub(number: CMJsonField<out Number>) = toDopeType().sub(number.toDopeType())
 
-fun CMField<out Number>.mul(numberExpression: TypeExpression<NumberType>) = toDopeType().mul(numberExpression)
+fun CMJsonField<out Number>.sub(number: Number) = toDopeType().sub(number.toDopeType())
 
-fun CMField<out Number>.mul(number: CMField<out Number>) = toDopeType().mul(number.toDopeType())
+fun <Convertable : Any, JsonType : Number> Convertable.sub(other: CMConverterField<Convertable, JsonType>) =
+    toDopeType(other).sub(other.toDopeType())
 
-fun TypeExpression<NumberType>.mul(number: CMField<out Number>) = mul(number.toDopeType())
+fun CMJsonField<out Number>.mul(numberExpression: TypeExpression<NumberType>) = toDopeType().mul(numberExpression)
 
-fun Number.mul(number: CMField<out Number>) = toDopeType().mul(number.toDopeType())
+fun CMJsonField<out Number>.mul(number: CMJsonField<out Number>) = toDopeType().mul(number.toDopeType())
 
-fun CMField<out Number>.mul(number: Number) = toDopeType().mul(number.toDopeType())
+fun TypeExpression<NumberType>.mul(number: CMJsonField<out Number>) = mul(number.toDopeType())
 
-fun CMField<out Number>.div(numberExpression: TypeExpression<NumberType>) = toDopeType().div(numberExpression)
+fun Number.mul(number: CMJsonField<out Number>) = toDopeType().mul(number.toDopeType())
 
-fun CMField<out Number>.div(number: CMField<out Number>) = toDopeType().div(number.toDopeType())
+fun CMJsonField<out Number>.mul(number: Number) = toDopeType().mul(number.toDopeType())
 
-fun TypeExpression<NumberType>.div(number: CMField<out Number>) = div(number.toDopeType())
+fun <Convertable : Any, JsonType : Number> Convertable.mul(other: CMConverterField<Convertable, JsonType>) =
+    toDopeType(other).mul(other.toDopeType())
 
-fun Number.div(number: CMField<out Number>) = toDopeType().div(number.toDopeType())
+fun CMJsonField<out Number>.div(numberExpression: TypeExpression<NumberType>) = toDopeType().div(numberExpression)
 
-fun CMField<out Number>.div(number: Number) = toDopeType().div(number.toDopeType())
+fun CMJsonField<out Number>.div(number: CMJsonField<out Number>) = toDopeType().div(number.toDopeType())
 
-fun CMField<out Number>.mod(numberExpression: TypeExpression<NumberType>) = toDopeType().mod(numberExpression)
+fun TypeExpression<NumberType>.div(number: CMJsonField<out Number>) = div(number.toDopeType())
 
-fun CMField<out Number>.mod(number: CMField<out Number>) = toDopeType().mod(number.toDopeType())
+fun Number.div(number: CMJsonField<out Number>) = toDopeType().div(number.toDopeType())
 
-fun TypeExpression<NumberType>.mod(number: CMField<out Number>) = mod(number.toDopeType())
+fun CMJsonField<out Number>.div(number: Number) = toDopeType().div(number.toDopeType())
 
-fun Number.mod(number: CMField<out Number>) = toDopeType().mod(number.toDopeType())
+fun <Convertable : Any, JsonType : Number> Convertable.div(other: CMConverterField<Convertable, JsonType>) =
+    toDopeType(other).div(other.toDopeType())
 
-fun CMField<out Number>.mod(number: Number) = toDopeType().mod(number.toDopeType())
+fun CMJsonField<out Number>.mod(numberExpression: TypeExpression<NumberType>) = toDopeType().mod(numberExpression)
+
+fun CMJsonField<out Number>.mod(number: CMJsonField<out Number>) = toDopeType().mod(number.toDopeType())
+
+fun TypeExpression<NumberType>.mod(number: CMJsonField<out Number>) = mod(number.toDopeType())
+
+fun Number.mod(number: CMJsonField<out Number>) = toDopeType().mod(number.toDopeType())
+
+fun CMJsonField<out Number>.mod(number: Number) = toDopeType().mod(number.toDopeType())
+
+fun <Convertable : Any, JsonType : Number> Convertable.mod(other: CMConverterField<Convertable, JsonType>) =
+    toDopeType(other).mod(other.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayConcat.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayConcat.kt
index ed9c749f..6cb18b71 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayConcat.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayConcat.kt
@@ -6,13 +6,13 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("stringArrayConcat")
 fun arrayConcat(
-    firstArray: CMList<String>,
-    secondArray: CMList<String>,
-    vararg additionalArrays: CMList<String>,
+    firstArray: CMJsonList<String>,
+    secondArray: CMJsonList<String>,
+    vararg additionalArrays: CMJsonList<String>,
 ): ArrayConcatExpression<StringType> = arrayConcat(
     firstArray.toDopeType(),
     secondArray.toDopeType(),
@@ -21,9 +21,9 @@ fun arrayConcat(
 
 @JvmName("numberArrayConcat")
 fun arrayConcat(
-    firstArray: CMList<Number>,
-    secondArray: CMList<Number>,
-    vararg additionalArrays: CMList<Number>,
+    firstArray: CMJsonList<Number>,
+    secondArray: CMJsonList<Number>,
+    vararg additionalArrays: CMJsonList<Number>,
 ): ArrayConcatExpression<NumberType> = arrayConcat(
     firstArray.toDopeType(),
     secondArray.toDopeType(),
@@ -32,9 +32,9 @@ fun arrayConcat(
 
 @JvmName("booleanArrayConcat")
 fun arrayConcat(
-    firstArray: CMList<Boolean>,
-    secondArray: CMList<Boolean>,
-    vararg additionalArrays: CMList<Boolean>,
+    firstArray: CMJsonList<Boolean>,
+    secondArray: CMJsonList<Boolean>,
+    vararg additionalArrays: CMJsonList<Boolean>,
 ): ArrayConcatExpression<BooleanType> = arrayConcat(
     firstArray.toDopeType(),
     secondArray.toDopeType(),
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayContains.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayContains.kt
index d7f91a3e..70c4fcc7 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayContains.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayContains.kt
@@ -7,26 +7,39 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMConverterList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberArrayContains")
-fun arrayContains(array: CMList<Number>, value: CMField<Number>): ArrayContainsExpression<NumberType> =
+fun arrayContains(array: CMJsonList<Number>, value: CMJsonField<Number>): ArrayContainsExpression<NumberType> =
     arrayContains(array.toDopeType(), value.toDopeType())
 
-fun arrayContains(array: CMList<Number>, value: Number): ArrayContainsExpression<NumberType> =
+fun arrayContains(array: CMJsonList<Number>, value: Number): ArrayContainsExpression<NumberType> =
     arrayContains(array.toDopeType(), value.toDopeType())
 
+@JvmName("numberArrayContains")
+fun <Convertable : Any, JsonType : Number> arrayContains(array: CMConverterList<Convertable, JsonType>, value: Convertable):
+    ArrayContainsExpression<NumberType> = arrayContains(array.toDopeType(), value.toDopeType(array))
+
 @JvmName("stringArrayContains")
-fun arrayContains(array: CMList<String>, value: CMField<String>): ArrayContainsExpression<StringType> =
+fun arrayContains(array: CMJsonList<String>, value: CMJsonField<String>): ArrayContainsExpression<StringType> =
     arrayContains(array.toDopeType(), value.toDopeType())
 
-fun arrayContains(array: CMList<String>, value: String): ArrayContainsExpression<StringType> =
+fun arrayContains(array: CMJsonList<String>, value: String): ArrayContainsExpression<StringType> =
     arrayContains(array.toDopeType(), value.toDopeType())
 
+@JvmName("stringArrayContains")
+fun <Convertable : Any> arrayContains(array: CMConverterList<Convertable, String>, value: Convertable):
+    ArrayContainsExpression<StringType> = arrayContains(array.toDopeType(), value.toDopeType(array))
+
 @JvmName("booleanArrayContains")
-fun arrayContains(array: CMList<Boolean>, value: CMField<Boolean>): ArrayContainsExpression<BooleanType> =
+fun arrayContains(array: CMJsonList<Boolean>, value: CMJsonField<Boolean>): ArrayContainsExpression<BooleanType> =
     arrayContains(array.toDopeType(), value.toDopeType())
 
-fun arrayContains(array: CMList<Boolean>, value: Boolean): ArrayContainsExpression<BooleanType> =
+fun arrayContains(array: CMJsonList<Boolean>, value: Boolean): ArrayContainsExpression<BooleanType> =
     arrayContains(array.toDopeType(), value.toDopeType())
+
+@JvmName("booleanArrayContains")
+fun <Convertable : Any> arrayContains(array: CMConverterList<Convertable, Boolean>, value: Convertable):
+    ArrayContainsExpression<BooleanType> = arrayContains(array.toDopeType(), value.toDopeType(array))
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayDistinct.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayDistinct.kt
index e5b61b6a..435a2229 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayDistinct.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayDistinct.kt
@@ -6,16 +6,16 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberArrayDistinct")
-fun arrayDistinct(array: CMList<Number>): ArrayDistinctExpression<NumberType> =
+fun arrayDistinct(array: CMJsonList<Number>): ArrayDistinctExpression<NumberType> =
     arrayDistinct(array.toDopeType())
 
 @JvmName("stringArrayDistinct")
-fun arrayDistinct(array: CMList<String>): ArrayDistinctExpression<StringType> =
+fun arrayDistinct(array: CMJsonList<String>): ArrayDistinctExpression<StringType> =
     arrayDistinct(array.toDopeType())
 
 @JvmName("booleanArrayDistinct")
-fun arrayDistinct(array: CMList<Boolean>): ArrayDistinctExpression<BooleanType> =
+fun arrayDistinct(array: CMJsonList<Boolean>): ArrayDistinctExpression<BooleanType> =
     arrayDistinct(array.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayIntersect.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayIntersect.kt
index 31dda006..e6507779 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayIntersect.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayIntersect.kt
@@ -6,13 +6,13 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("stringArrayIntersect")
 fun arrayIntersect(
-    firstArray: CMList<String>,
-    secondArray: CMList<String>,
-    vararg additionalArrays: CMList<String>,
+    firstArray: CMJsonList<String>,
+    secondArray: CMJsonList<String>,
+    vararg additionalArrays: CMJsonList<String>,
 ): ArrayIntersectExpression<StringType> = arrayIntersect(
     firstArray.toDopeType(),
     secondArray.toDopeType(),
@@ -21,9 +21,9 @@ fun arrayIntersect(
 
 @JvmName("numberArrayIntersect")
 fun arrayIntersect(
-    firstArray: CMList<Number>,
-    secondArray: CMList<Number>,
-    vararg additionalArrays: CMList<Number>,
+    firstArray: CMJsonList<Number>,
+    secondArray: CMJsonList<Number>,
+    vararg additionalArrays: CMJsonList<Number>,
 ): ArrayIntersectExpression<NumberType> = arrayIntersect(
     firstArray.toDopeType(),
     secondArray.toDopeType(),
@@ -32,9 +32,9 @@ fun arrayIntersect(
 
 @JvmName("booleanArrayIntersect")
 fun arrayIntersect(
-    firstArray: CMList<Boolean>,
-    secondArray: CMList<Boolean>,
-    vararg additionalArrays: CMList<Boolean>,
+    firstArray: CMJsonList<Boolean>,
+    secondArray: CMJsonList<Boolean>,
+    vararg additionalArrays: CMJsonList<Boolean>,
 ): ArrayIntersectExpression<BooleanType> = arrayIntersect(
     firstArray.toDopeType(),
     secondArray.toDopeType(),
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayLength.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayLength.kt
index d5fc45d8..69ec90bf 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayLength.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArrayLength.kt
@@ -6,16 +6,16 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberArrayLength")
-fun arrayLength(array: CMList<Number>): ArrayLengthExpression<NumberType> =
+fun arrayLength(array: CMJsonList<Number>): ArrayLengthExpression<NumberType> =
     arrayLength(array.toDopeType())
 
 @JvmName("stringArrayLength")
-fun arrayLength(array: CMList<String>): ArrayLengthExpression<StringType> =
+fun arrayLength(array: CMJsonList<String>): ArrayLengthExpression<StringType> =
     arrayLength(array.toDopeType())
 
 @JvmName("booleanArrayLength")
-fun arrayLength(array: CMList<Boolean>): ArrayLengthExpression<BooleanType> =
+fun arrayLength(array: CMJsonList<Boolean>): ArrayLengthExpression<BooleanType> =
     arrayLength(array.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArraySum.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArraySum.kt
index 81b60b04..38ad527f 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArraySum.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/array/ArraySum.kt
@@ -6,16 +6,16 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberArraySum")
-fun arraySum(array: CMList<Number>): ArraySumExpression<NumberType> =
+fun arraySum(array: CMJsonList<Number>): ArraySumExpression<NumberType> =
     arraySum(array.toDopeType())
 
 @JvmName("stringArraySum")
-fun arraySum(array: CMList<String>): ArraySumExpression<StringType> =
+fun arraySum(array: CMJsonList<String>): ArraySumExpression<StringType> =
     arraySum(array.toDopeType())
 
 @JvmName("booleanArraySum")
-fun arraySum(array: CMList<Boolean>): ArraySumExpression<BooleanType> =
+fun arraySum(array: CMJsonList<Boolean>): ArraySumExpression<BooleanType> =
     arraySum(array.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissing.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissing.kt
index 49b007e4..e55b6db0 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissing.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissing.kt
@@ -2,14 +2,14 @@ package ch.ergon.dope.extension.type.conditional
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.conditional.ifMissing
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("ifCMNumberFieldIsMissing")
 fun ifMissing(
-    firstExpression: CMField<out Number>,
-    secondExpression: CMField<out Number>,
-    vararg additionalExpressions: CMField<out Number>,
+    firstExpression: CMJsonField<out Number>,
+    secondExpression: CMJsonField<out Number>,
+    vararg additionalExpressions: CMJsonField<out Number>,
 ) = ifMissing(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -18,9 +18,9 @@ fun ifMissing(
 
 @JvmName("ifCMStringFieldIsMissing")
 fun ifMissing(
-    firstExpression: CMField<String>,
-    secondExpression: CMField<String>,
-    vararg additionalExpressions: CMField<String>,
+    firstExpression: CMJsonField<String>,
+    secondExpression: CMJsonField<String>,
+    vararg additionalExpressions: CMJsonField<String>,
 ) = ifMissing(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -29,9 +29,9 @@ fun ifMissing(
 
 @JvmName("ifCMBooleanFieldIsMissing")
 fun ifMissing(
-    firstExpression: CMField<Boolean>,
-    secondExpression: CMField<Boolean>,
-    vararg additionalExpressions: CMField<Boolean>,
+    firstExpression: CMJsonField<Boolean>,
+    secondExpression: CMJsonField<Boolean>,
+    vararg additionalExpressions: CMJsonField<Boolean>,
 ) = ifMissing(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -40,9 +40,9 @@ fun ifMissing(
 
 @JvmName("ifCMNumberStringIsMissing")
 fun ifMissing(
-    firstExpression: CMList<out Number>,
-    secondExpression: CMList<out Number>,
-    vararg additionalExpressions: CMList<out Number>,
+    firstExpression: CMJsonList<out Number>,
+    secondExpression: CMJsonList<out Number>,
+    vararg additionalExpressions: CMJsonList<out Number>,
 ) = ifMissing(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -51,9 +51,9 @@ fun ifMissing(
 
 @JvmName("ifCMStringListIsMissing")
 fun ifMissing(
-    firstExpression: CMList<String>,
-    secondExpression: CMList<String>,
-    vararg additionalExpressions: CMList<String>,
+    firstExpression: CMJsonList<String>,
+    secondExpression: CMJsonList<String>,
+    vararg additionalExpressions: CMJsonList<String>,
 ) = ifMissing(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -62,9 +62,9 @@ fun ifMissing(
 
 @JvmName("ifCMBooleanListIsMissing")
 fun ifMissing(
-    firstExpression: CMList<Boolean>,
-    secondExpression: CMList<Boolean>,
-    vararg additionalExpressions: CMList<Boolean>,
+    firstExpression: CMJsonList<Boolean>,
+    secondExpression: CMJsonList<Boolean>,
+    vararg additionalExpressions: CMJsonList<Boolean>,
 ) = ifMissing(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissingOrNull.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissingOrNull.kt
index 190f9c71..2bac4481 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissingOrNull.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfMissingOrNull.kt
@@ -3,14 +3,14 @@ package ch.ergon.dope.extension.type.conditional
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.conditional.coalesce
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.conditional.ifMissingOrNull
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("ifCMNumberFieldIsMissingOrNull")
 fun ifMissingOrNull(
-    firstExpression: CMField<out Number>,
-    secondExpression: CMField<out Number>,
-    vararg additionalExpressions: CMField<out Number>,
+    firstExpression: CMJsonField<out Number>,
+    secondExpression: CMJsonField<out Number>,
+    vararg additionalExpressions: CMJsonField<out Number>,
 ) = ifMissingOrNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -19,9 +19,9 @@ fun ifMissingOrNull(
 
 @JvmName("ifCMStringFieldIsMissingOrNull")
 fun ifMissingOrNull(
-    firstExpression: CMField<String>,
-    secondExpression: CMField<String>,
-    vararg additionalExpressions: CMField<String>,
+    firstExpression: CMJsonField<String>,
+    secondExpression: CMJsonField<String>,
+    vararg additionalExpressions: CMJsonField<String>,
 ) = ifMissingOrNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -30,9 +30,9 @@ fun ifMissingOrNull(
 
 @JvmName("ifCMBooleanFieldIsMissingOrNull")
 fun ifMissingOrNull(
-    firstExpression: CMField<Boolean>,
-    secondExpression: CMField<Boolean>,
-    vararg additionalExpressions: CMField<Boolean>,
+    firstExpression: CMJsonField<Boolean>,
+    secondExpression: CMJsonField<Boolean>,
+    vararg additionalExpressions: CMJsonField<Boolean>,
 ) = ifMissingOrNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -41,9 +41,9 @@ fun ifMissingOrNull(
 
 @JvmName("ifCMNumberListIsMissingOrNull")
 fun ifMissingOrNull(
-    firstExpression: CMList<out Number>,
-    secondExpression: CMList<out Number>,
-    vararg additionalExpressions: CMList<out Number>,
+    firstExpression: CMJsonList<out Number>,
+    secondExpression: CMJsonList<out Number>,
+    vararg additionalExpressions: CMJsonList<out Number>,
 ) = ifMissingOrNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -52,9 +52,9 @@ fun ifMissingOrNull(
 
 @JvmName("ifCMStringListIsMissingOrNull")
 fun ifMissingOrNull(
-    firstExpression: CMList<String>,
-    secondExpression: CMList<String>,
-    vararg additionalExpressions: CMList<String>,
+    firstExpression: CMJsonList<String>,
+    secondExpression: CMJsonList<String>,
+    vararg additionalExpressions: CMJsonList<String>,
 ) = ifMissingOrNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -63,9 +63,9 @@ fun ifMissingOrNull(
 
 @JvmName("ifCMBooleanListIsMissingOrNull")
 fun ifMissingOrNull(
-    firstExpression: CMList<Boolean>,
-    secondExpression: CMList<Boolean>,
-    vararg additionalExpressions: CMList<Boolean>,
+    firstExpression: CMJsonList<Boolean>,
+    secondExpression: CMJsonList<Boolean>,
+    vararg additionalExpressions: CMJsonList<Boolean>,
 ) = ifMissingOrNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -74,9 +74,9 @@ fun ifMissingOrNull(
 
 @JvmName("coalesceCMNumberField")
 fun coalesce(
-    firstExpression: CMField<out Number>,
-    secondExpression: CMField<out Number>,
-    vararg additionalExpressions: CMField<out Number>,
+    firstExpression: CMJsonField<out Number>,
+    secondExpression: CMJsonField<out Number>,
+    vararg additionalExpressions: CMJsonField<out Number>,
 ) = coalesce(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -85,9 +85,9 @@ fun coalesce(
 
 @JvmName("coalesceCMStringField")
 fun coalesce(
-    firstExpression: CMField<String>,
-    secondExpression: CMField<String>,
-    vararg additionalExpressions: CMField<String>,
+    firstExpression: CMJsonField<String>,
+    secondExpression: CMJsonField<String>,
+    vararg additionalExpressions: CMJsonField<String>,
 ) = coalesce(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -96,9 +96,9 @@ fun coalesce(
 
 @JvmName("coalesceCMBooleanField")
 fun coalesce(
-    firstExpression: CMField<Boolean>,
-    secondExpression: CMField<Boolean>,
-    vararg additionalExpressions: CMField<Boolean>,
+    firstExpression: CMJsonField<Boolean>,
+    secondExpression: CMJsonField<Boolean>,
+    vararg additionalExpressions: CMJsonField<Boolean>,
 ) = coalesce(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -107,9 +107,9 @@ fun coalesce(
 
 @JvmName("coalesceCMNumberList")
 fun coalesce(
-    firstExpression: CMList<out Number>,
-    secondExpression: CMList<out Number>,
-    vararg additionalExpressions: CMList<out Number>,
+    firstExpression: CMJsonList<out Number>,
+    secondExpression: CMJsonList<out Number>,
+    vararg additionalExpressions: CMJsonList<out Number>,
 ) = coalesce(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -118,9 +118,9 @@ fun coalesce(
 
 @JvmName("coalesceCMStringList")
 fun coalesce(
-    firstExpression: CMList<String>,
-    secondExpression: CMList<String>,
-    vararg additionalExpressions: CMList<String>,
+    firstExpression: CMJsonList<String>,
+    secondExpression: CMJsonList<String>,
+    vararg additionalExpressions: CMJsonList<String>,
 ) = coalesce(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -129,9 +129,9 @@ fun coalesce(
 
 @JvmName("coalesceCMBooleanField")
 fun coalesce(
-    firstExpression: CMList<Boolean>,
-    secondExpression: CMList<Boolean>,
-    vararg additionalExpressions: CMList<Boolean>,
+    firstExpression: CMJsonList<Boolean>,
+    secondExpression: CMJsonList<Boolean>,
+    vararg additionalExpressions: CMJsonList<Boolean>,
 ) = coalesce(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfNull.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfNull.kt
index df4768cd..5f11e0d8 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfNull.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/IfNull.kt
@@ -2,14 +2,14 @@ package ch.ergon.dope.extension.type.conditional
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.conditional.ifNull
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("ifCMNumberFieldIsNull")
 fun ifNull(
-    firstExpression: CMField<out Number>,
-    secondExpression: CMField<out Number>,
-    vararg additionalExpressions: CMField<out Number>,
+    firstExpression: CMJsonField<out Number>,
+    secondExpression: CMJsonField<out Number>,
+    vararg additionalExpressions: CMJsonField<out Number>,
 ) = ifNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -18,9 +18,9 @@ fun ifNull(
 
 @JvmName("ifCMStringFieldIsNull")
 fun ifNull(
-    firstExpression: CMField<String>,
-    secondExpression: CMField<String>,
-    vararg additionalExpressions: CMField<String>,
+    firstExpression: CMJsonField<String>,
+    secondExpression: CMJsonField<String>,
+    vararg additionalExpressions: CMJsonField<String>,
 ) = ifNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -29,9 +29,9 @@ fun ifNull(
 
 @JvmName("ifCMBooleanFieldIsNull")
 fun ifNull(
-    firstExpression: CMField<Boolean>,
-    secondExpression: CMField<Boolean>,
-    vararg additionalExpressions: CMField<Boolean>,
+    firstExpression: CMJsonField<Boolean>,
+    secondExpression: CMJsonField<Boolean>,
+    vararg additionalExpressions: CMJsonField<Boolean>,
 ) = ifNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -40,9 +40,9 @@ fun ifNull(
 
 @JvmName("ifCMNumberListIsNull")
 fun ifNull(
-    firstExpression: CMList<out Number>,
-    secondExpression: CMList<out Number>,
-    vararg additionalExpressions: CMList<out Number>,
+    firstExpression: CMJsonList<out Number>,
+    secondExpression: CMJsonList<out Number>,
+    vararg additionalExpressions: CMJsonList<out Number>,
 ) = ifNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -51,9 +51,9 @@ fun ifNull(
 
 @JvmName("ifCMStringListIsNull")
 fun ifNull(
-    firstExpression: CMList<String>,
-    secondExpression: CMList<String>,
-    vararg additionalExpressions: CMList<String>,
+    firstExpression: CMJsonList<String>,
+    secondExpression: CMJsonList<String>,
+    vararg additionalExpressions: CMJsonList<String>,
 ) = ifNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -62,9 +62,9 @@ fun ifNull(
 
 @JvmName("ifCMBooleanListIsNull")
 fun ifNull(
-    firstExpression: CMList<Boolean>,
-    secondExpression: CMList<Boolean>,
-    vararg additionalExpressions: CMList<Boolean>,
+    firstExpression: CMJsonList<Boolean>,
+    secondExpression: CMJsonList<Boolean>,
+    vararg additionalExpressions: CMJsonList<Boolean>,
 ) = ifNull(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl.kt
index a9a97818..e2518e02 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl.kt
@@ -1,42 +1,56 @@
 package ch.ergon.dope.extension.type.conditional
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.conditional.nvl
+import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("nvlCMNumberField")
-fun nvl(initialExpression: CMField<out Number>, substituteExpression: CMField<out Number>) =
+fun nvl(initialExpression: CMJsonField<out Number>, substituteExpression: CMJsonField<out Number>) =
     nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMStringField")
-fun nvl(initialExpression: CMField<String>, substituteExpression: CMField<String>) =
+fun nvl(initialExpression: CMJsonField<String>, substituteExpression: CMJsonField<String>) =
     nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMBooleanField")
-fun nvl(initialExpression: CMField<Boolean>, substituteExpression: CMField<Boolean>) =
+fun nvl(initialExpression: CMJsonField<Boolean>, substituteExpression: CMJsonField<Boolean>) =
     nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMNumberList")
-fun nvl(initialExpression: CMList<out Number>, substituteExpression: CMList<out Number>) =
+fun nvl(initialExpression: CMJsonList<out Number>, substituteExpression: CMJsonList<out Number>) =
     nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMStringList")
-fun nvl(initialExpression: CMList<String>, substituteExpression: CMList<String>) =
+fun nvl(initialExpression: CMJsonList<String>, substituteExpression: CMJsonList<String>) =
     nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMBooleanList")
-fun nvl(initialExpression: CMList<Boolean>, substituteExpression: CMList<Boolean>) =
+fun nvl(initialExpression: CMJsonList<Boolean>, substituteExpression: CMJsonList<Boolean>) =
     nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMNumberFieldAndNumber")
-fun nvl(initialExpression: CMField<out Number>, substituteExpression: Number) =
-    nvl(initialExpression.toDopeType(), substituteExpression)
+fun nvl(initialExpression: CMJsonField<out Number>, substituteExpression: Number) =
+    nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMStringFieldAndString")
-fun nvl(initialExpression: CMField<String>, substituteExpression: String) =
-    nvl(initialExpression.toDopeType(), substituteExpression)
+fun nvl(initialExpression: CMJsonField<String>, substituteExpression: String) =
+    nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
 
 @JvmName("nvlCMBooleanFieldAndBoolean")
-fun nvl(initialExpression: CMField<Boolean>, substituteExpression: Boolean) =
-    nvl(initialExpression.toDopeType(), substituteExpression)
+fun nvl(initialExpression: CMJsonField<Boolean>, substituteExpression: Boolean) =
+    nvl(initialExpression.toDopeType(), substituteExpression.toDopeType())
+
+@JvmName("nvlCMConverterNumberList")
+fun <Convertable : Any, JsonType : Number> nvl(initialExpression: CMConverterField<Convertable, JsonType>, substituteExpression: Convertable) =
+    nvl(initialExpression.toDopeType(), substituteExpression.toDopeType(initialExpression))
+
+@JvmName("nvlCMConverterStringList")
+fun <Convertable : Any> nvl(initialExpression: CMConverterField<Convertable, String>, substituteExpression: Convertable) =
+    nvl(initialExpression.toDopeType(), substituteExpression.toDopeType(initialExpression))
+
+@JvmName("nvlCMConverterBooleanList")
+fun <Convertable : Any> nvl(initialExpression: CMConverterField<Convertable, Boolean>, substituteExpression: Convertable) =
+    nvl(initialExpression.toDopeType(), substituteExpression.toDopeType(initialExpression))
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl2.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl2.kt
index 7567a45e..8dfe7b92 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl2.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/conditional/Nvl2.kt
@@ -8,112 +8,112 @@ import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMType
 
 @JvmName("nvl2CMNumberFieldAndCMNumberField")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<out Number>,
-    valueIfNotExists: CMField<out Number>,
+    valueIfExists: CMJsonField<out Number>,
+    valueIfNotExists: CMJsonField<out Number>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMStringFieldAndCMStringField")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<String>,
-    valueIfNotExists: CMField<String>,
+    valueIfExists: CMJsonField<String>,
+    valueIfNotExists: CMJsonField<String>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMBooleanFieldAndCMBooleanField")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<Boolean>,
-    valueIfNotExists: CMField<Boolean>,
+    valueIfExists: CMJsonField<Boolean>,
+    valueIfNotExists: CMJsonField<Boolean>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMNumberListAndCMNumberList")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMList<out Number>,
-    valueIfNotExists: CMList<out Number>,
+    valueIfExists: CMJsonList<out Number>,
+    valueIfNotExists: CMJsonList<out Number>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMStringListAndCMStringList")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMList<String>,
-    valueIfNotExists: CMList<String>,
+    valueIfExists: CMJsonList<String>,
+    valueIfNotExists: CMJsonList<String>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMBooleanListAndCMBooleanList")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMList<Boolean>,
-    valueIfNotExists: CMList<Boolean>,
+    valueIfExists: CMJsonList<Boolean>,
+    valueIfNotExists: CMJsonList<Boolean>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMNumberFieldAndNumberType")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<out Number>,
+    valueIfExists: CMJsonField<out Number>,
     valueIfNotExists: UnaliasedExpression<NumberType>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMStringFieldAndStringType")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<String>,
+    valueIfExists: CMJsonField<String>,
     valueIfNotExists: UnaliasedExpression<StringType>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMBooleanFieldAndBooleanType")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<Boolean>,
+    valueIfExists: CMJsonField<Boolean>,
     valueIfNotExists: UnaliasedExpression<BooleanType>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMNumberListAndArrayNumberType")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMList<out Number>,
+    valueIfExists: CMJsonList<out Number>,
     valueIfNotExists: UnaliasedExpression<ArrayType<NumberType>>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMStringListAndArrayStringType")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMList<String>,
+    valueIfExists: CMJsonList<String>,
     valueIfNotExists: UnaliasedExpression<ArrayType<StringType>>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMBooleanListAndArrayBooleanType")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMList<Boolean>,
+    valueIfExists: CMJsonList<Boolean>,
     valueIfNotExists: UnaliasedExpression<ArrayType<BooleanType>>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMNumberFieldAndNumber")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<out Number>,
+    valueIfExists: CMJsonField<out Number>,
     valueIfNotExists: Number,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMStringFieldAndString")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<String>,
+    valueIfExists: CMJsonField<String>,
     valueIfNotExists: String,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMBooleanFieldAndBoolean")
 fun nvl2(
     initialExpression: CMType,
-    valueIfExists: CMField<Boolean>,
+    valueIfExists: CMJsonField<Boolean>,
     valueIfNotExists: Boolean,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists.toDopeType(), valueIfNotExists)
 
@@ -121,63 +121,63 @@ fun nvl2(
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: UnaliasedExpression<NumberType>,
-    valueIfNotExists: CMField<out Number>,
+    valueIfNotExists: CMJsonField<out Number>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2StringTypeAndCMStringField")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: UnaliasedExpression<StringType>,
-    valueIfNotExists: CMField<String>,
+    valueIfNotExists: CMJsonField<String>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2BooleanTypeAndCMBooleanField")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: UnaliasedExpression<BooleanType>,
-    valueIfNotExists: CMField<Boolean>,
+    valueIfNotExists: CMJsonField<Boolean>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2ArrayNumberTypeAndCMNumberList")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: UnaliasedExpression<ArrayType<NumberType>>,
-    valueIfNotExists: CMList<out Number>,
+    valueIfNotExists: CMJsonList<out Number>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2ArrayStringTypeAndCMStringList")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: UnaliasedExpression<ArrayType<StringType>>,
-    valueIfNotExists: CMList<String>,
+    valueIfNotExists: CMJsonList<String>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2ArrayBooleanTypeAndCMBooleanList")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: UnaliasedExpression<ArrayType<BooleanType>>,
-    valueIfNotExists: CMList<Boolean>,
+    valueIfNotExists: CMJsonList<Boolean>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2NumberAndCMNumberField")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: Number,
-    valueIfNotExists: CMField<out Number>,
+    valueIfNotExists: CMJsonField<out Number>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2StringAndCMStringField")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: String,
-    valueIfNotExists: CMField<String>,
+    valueIfNotExists: CMJsonField<String>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2BooleanAndCMBooleanField")
 fun nvl2(
     initialExpression: CMType,
     valueIfExists: Boolean,
-    valueIfNotExists: CMField<Boolean>,
+    valueIfNotExists: CMJsonField<Boolean>,
 ) = nvl2(initialExpression.toDopeType(), valueIfExists, valueIfNotExists.toDopeType())
 
 fun nvl2(
@@ -201,105 +201,105 @@ fun nvl2(
 @JvmName("nvl2CMNumberFieldAndCMNumberField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<out Number>,
-    valueIfNotExists: CMField<out Number>,
+    valueIfExists: CMJsonField<out Number>,
+    valueIfNotExists: CMJsonField<out Number>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMStringFieldAndCMStringField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<String>,
-    valueIfNotExists: CMField<String>,
+    valueIfExists: CMJsonField<String>,
+    valueIfNotExists: CMJsonField<String>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMBooleanFieldAndCMBooleanField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<Boolean>,
-    valueIfNotExists: CMField<Boolean>,
+    valueIfExists: CMJsonField<Boolean>,
+    valueIfNotExists: CMJsonField<Boolean>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMNumberListAndCMNumberList")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMList<out Number>,
-    valueIfNotExists: CMList<out Number>,
+    valueIfExists: CMJsonList<out Number>,
+    valueIfNotExists: CMJsonList<out Number>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMStringListAndCMStringList")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMList<String>,
-    valueIfNotExists: CMList<String>,
+    valueIfExists: CMJsonList<String>,
+    valueIfNotExists: CMJsonList<String>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMBooleanListAndCMBooleanList")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMList<Boolean>,
-    valueIfNotExists: CMList<Boolean>,
+    valueIfExists: CMJsonList<Boolean>,
+    valueIfNotExists: CMJsonList<Boolean>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists.toDopeType())
 
 @JvmName("nvl2CMNumberFieldAndNumberType")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<out Number>,
+    valueIfExists: CMJsonField<out Number>,
     valueIfNotExists: UnaliasedExpression<NumberType>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMStringFieldAndStringType")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<String>,
+    valueIfExists: CMJsonField<String>,
     valueIfNotExists: UnaliasedExpression<StringType>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMBooleanFieldAndBooleanType")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<Boolean>,
+    valueIfExists: CMJsonField<Boolean>,
     valueIfNotExists: UnaliasedExpression<BooleanType>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMNumberListAndArrayNumberType")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMList<out Number>,
+    valueIfExists: CMJsonList<out Number>,
     valueIfNotExists: UnaliasedExpression<ArrayType<NumberType>>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMStringListAndArrayStringType")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMList<String>,
+    valueIfExists: CMJsonList<String>,
     valueIfNotExists: UnaliasedExpression<ArrayType<StringType>>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMBooleanListAndArrayBooleanType")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMList<Boolean>,
+    valueIfExists: CMJsonList<Boolean>,
     valueIfNotExists: UnaliasedExpression<ArrayType<BooleanType>>,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMNumberFieldAndNumber")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<out Number>,
+    valueIfExists: CMJsonField<out Number>,
     valueIfNotExists: Number,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMStringFieldAndString")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<String>,
+    valueIfExists: CMJsonField<String>,
     valueIfNotExists: String,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
 @JvmName("nvl2CMBooleanFieldAndBoolean")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
-    valueIfExists: CMField<Boolean>,
+    valueIfExists: CMJsonField<Boolean>,
     valueIfNotExists: Boolean,
 ) = nvl2(initialExpression, valueIfExists.toDopeType(), valueIfNotExists)
 
@@ -307,61 +307,61 @@ fun nvl2(
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: UnaliasedExpression<NumberType>,
-    valueIfNotExists: CMField<out Number>,
+    valueIfNotExists: CMJsonField<out Number>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2StringTypeAndCMStringField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: UnaliasedExpression<StringType>,
-    valueIfNotExists: CMField<String>,
+    valueIfNotExists: CMJsonField<String>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2BooleanTypeAndCMBooleanField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: UnaliasedExpression<BooleanType>,
-    valueIfNotExists: CMField<Boolean>,
+    valueIfNotExists: CMJsonField<Boolean>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2ArrayNumberTypeAndCMNumberList")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: UnaliasedExpression<ArrayType<NumberType>>,
-    valueIfNotExists: CMList<out Number>,
+    valueIfNotExists: CMJsonList<out Number>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2ArrayStringTypeAndCMStringList")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: UnaliasedExpression<ArrayType<StringType>>,
-    valueIfNotExists: CMList<String>,
+    valueIfNotExists: CMJsonList<String>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2ArrayBooleanTypeAndCMBooleanList")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: UnaliasedExpression<ArrayType<BooleanType>>,
-    valueIfNotExists: CMList<Boolean>,
+    valueIfNotExists: CMJsonList<Boolean>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2NumberAndCMNumberField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: Number,
-    valueIfNotExists: CMField<out Number>,
+    valueIfNotExists: CMJsonField<out Number>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2StringAndCMStringField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: String,
-    valueIfNotExists: CMField<String>,
+    valueIfNotExists: CMJsonField<String>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
 
 @JvmName("nvl2BooleanAndCMBooleanField")
 fun nvl2(
     initialExpression: UnaliasedExpression<out ValidType>,
     valueIfExists: Boolean,
-    valueIfNotExists: CMField<Boolean>,
+    valueIfNotExists: CMJsonField<Boolean>,
 ) = nvl2(initialExpression, valueIfExists, valueIfNotExists.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/LogicalInfix.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/LogicalInfix.kt
index b8fce4b3..daeb5859 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/LogicalInfix.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/LogicalInfix.kt
@@ -6,24 +6,29 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.logical.or
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun TypeExpression<BooleanType>.or(boolean: CMField<Boolean>) = or(boolean.toDopeType())
+fun TypeExpression<BooleanType>.or(boolean: CMJsonField<Boolean>) = or(boolean.toDopeType())
 
-fun CMField<Boolean>.or(booleanExpression: TypeExpression<BooleanType>) = toDopeType().or(booleanExpression)
+fun CMJsonField<Boolean>.or(booleanExpression: TypeExpression<BooleanType>) = toDopeType().or(booleanExpression)
 
-fun CMField<Boolean>.or(boolean: Boolean) = toDopeType().or(boolean.toDopeType())
+fun CMJsonField<Boolean>.or(boolean: Boolean) = toDopeType().or(boolean.toDopeType())
 
-fun CMField<Boolean>.or(boolean: CMField<Boolean>) = toDopeType().or(boolean.toDopeType())
+fun CMJsonField<Boolean>.or(boolean: CMJsonField<Boolean>) = toDopeType().or(boolean.toDopeType())
 
-fun Boolean.or(booleanExpression: CMField<Boolean>) = toDopeType().or(booleanExpression.toDopeType())
+fun Boolean.or(booleanExpression: CMJsonField<Boolean>) = toDopeType().or(booleanExpression.toDopeType())
 
-fun TypeExpression<BooleanType>.and(boolean: CMField<Boolean>) = and(boolean.toDopeType())
+fun <Convertable : Any> CMConverterField<Convertable, Boolean>.or(boolean: Convertable) = toDopeType().or(boolean.toDopeType(this))
 
-fun CMField<Boolean>.and(booleanExpression: TypeExpression<BooleanType>) = toDopeType().and(booleanExpression)
+fun TypeExpression<BooleanType>.and(boolean: CMJsonField<Boolean>) = and(boolean.toDopeType())
 
-fun CMField<Boolean>.and(boolean: Boolean) = toDopeType().and(boolean.toDopeType())
+fun CMJsonField<Boolean>.and(booleanExpression: TypeExpression<BooleanType>) = toDopeType().and(booleanExpression)
 
-fun CMField<Boolean>.and(boolean: CMField<Boolean>) = toDopeType().and(boolean.toDopeType())
+fun CMJsonField<Boolean>.and(boolean: Boolean) = toDopeType().and(boolean.toDopeType())
 
-fun Boolean.and(booleanExpression: CMField<Boolean>) = toDopeType().and(booleanExpression.toDopeType())
+fun CMJsonField<Boolean>.and(boolean: CMJsonField<Boolean>) = toDopeType().and(boolean.toDopeType())
+
+fun Boolean.and(booleanExpression: CMJsonField<Boolean>) = toDopeType().and(booleanExpression.toDopeType())
+
+fun <Convertable : Any> CMConverterField<Convertable, Boolean>.and(boolean: Convertable) = toDopeType().and(boolean.toDopeType(this))
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/Not.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/Not.kt
index 140883f3..f2786fc8 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/Not.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/logical/Not.kt
@@ -2,6 +2,6 @@ package ch.ergon.dope.extension.type.logical
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.logical.not
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun not(boolean: CMField<Boolean>) = not(boolean.toDopeType())
+fun not(boolean: CMJsonField<Boolean>) = not(boolean.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Absolute.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Absolute.kt
index c46a4699..17236708 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Absolute.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Absolute.kt
@@ -2,6 +2,6 @@ package ch.ergon.dope.extension.type.numberfunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.abs
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun abs(field: CMField<out Number>) = abs(field.toDopeType())
+fun abs(field: CMJsonField<out Number>) = abs(field.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/LogarithmicExponentFunctions.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/LogarithmicExponentFunctions.kt
index 36bb16a0..d78f827c 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/LogarithmicExponentFunctions.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/LogarithmicExponentFunctions.kt
@@ -8,22 +8,22 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.power
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.sqrt
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun exp(field: CMField<out Number>) = exp(field.toDopeType())
+fun exp(field: CMJsonField<out Number>) = exp(field.toDopeType())
 
-fun log(field: CMField<out Number>) = log(field.toDopeType())
+fun log(field: CMJsonField<out Number>) = log(field.toDopeType())
 
-fun ln(field: CMField<out Number>) = ln(field.toDopeType())
+fun ln(field: CMJsonField<out Number>) = ln(field.toDopeType())
 
-fun power(base: CMField<out Number>, exponent: CMField<out Number>) = power(base.toDopeType(), exponent.toDopeType())
+fun power(base: CMJsonField<out Number>, exponent: CMJsonField<out Number>) = power(base.toDopeType(), exponent.toDopeType())
 
-fun power(base: CMField<out Number>, exponent: TypeExpression<NumberType>) = power(base.toDopeType(), exponent)
+fun power(base: CMJsonField<out Number>, exponent: TypeExpression<NumberType>) = power(base.toDopeType(), exponent)
 
-fun power(base: CMField<out Number>, exponent: Number) = power(base.toDopeType(), exponent)
+fun power(base: CMJsonField<out Number>, exponent: Number) = power(base.toDopeType(), exponent)
 
-fun power(base: TypeExpression<NumberType>, exponent: CMField<out Number>) = power(base, exponent.toDopeType())
+fun power(base: TypeExpression<NumberType>, exponent: CMJsonField<out Number>) = power(base, exponent.toDopeType())
 
-fun power(base: Number, exponent: CMField<out Number>) = power(base, exponent.toDopeType())
+fun power(base: Number, exponent: CMJsonField<out Number>) = power(base, exponent.toDopeType())
 
-fun sqrt(field: CMField<out Number>) = sqrt(field.toDopeType())
+fun sqrt(field: CMJsonField<out Number>) = sqrt(field.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Random.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Random.kt
index a52eed42..49412274 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Random.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Random.kt
@@ -2,6 +2,6 @@ package ch.ergon.dope.extension.type.numberfunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.random
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun random(field: CMField<out Number>) = random(field.toDopeType())
+fun random(field: CMJsonField<out Number>) = random(field.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/RoundingFunctions.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/RoundingFunctions.kt
index d35fc021..3841947e 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/RoundingFunctions.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/RoundingFunctions.kt
@@ -7,32 +7,32 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.round
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.trunc
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun ceil(field: CMField<out Number>) = ceil(field.toDopeType())
+fun ceil(field: CMJsonField<out Number>) = ceil(field.toDopeType())
 
-fun floor(field: CMField<out Number>) = floor(field.toDopeType())
+fun floor(field: CMJsonField<out Number>) = floor(field.toDopeType())
 
-fun round(field: CMField<out Number>) = round(field.toDopeType())
+fun round(field: CMJsonField<out Number>) = round(field.toDopeType())
 
-fun round(field: CMField<out Number>, digits: CMField<out Number>) = round(field.toDopeType(), digits.toDopeType())
+fun round(field: CMJsonField<out Number>, digits: CMJsonField<out Number>) = round(field.toDopeType(), digits.toDopeType())
 
-fun round(field: CMField<out Number>, digits: TypeExpression<NumberType>) = round(field.toDopeType(), digits)
+fun round(field: CMJsonField<out Number>, digits: TypeExpression<NumberType>) = round(field.toDopeType(), digits)
 
-fun round(field: CMField<out Number>, digits: Number) = round(field.toDopeType(), digits)
+fun round(field: CMJsonField<out Number>, digits: Number) = round(field.toDopeType(), digits)
 
-fun round(value: TypeExpression<NumberType>, digits: CMField<out Number>) = round(value, digits.toDopeType())
+fun round(value: TypeExpression<NumberType>, digits: CMJsonField<out Number>) = round(value, digits.toDopeType())
 
-fun round(value: Number, digits: CMField<out Number>) = round(value, digits.toDopeType())
+fun round(value: Number, digits: CMJsonField<out Number>) = round(value, digits.toDopeType())
 
-fun trunc(field: CMField<out Number>) = trunc(field.toDopeType())
+fun trunc(field: CMJsonField<out Number>) = trunc(field.toDopeType())
 
-fun trunc(field: CMField<out Number>, digits: CMField<out Number>) = trunc(field.toDopeType(), digits.toDopeType())
+fun trunc(field: CMJsonField<out Number>, digits: CMJsonField<out Number>) = trunc(field.toDopeType(), digits.toDopeType())
 
-fun trunc(field: CMField<out Number>, digits: TypeExpression<NumberType>) = trunc(field.toDopeType(), digits)
+fun trunc(field: CMJsonField<out Number>, digits: TypeExpression<NumberType>) = trunc(field.toDopeType(), digits)
 
-fun trunc(field: CMField<out Number>, digits: Number) = trunc(field.toDopeType(), digits)
+fun trunc(field: CMJsonField<out Number>, digits: Number) = trunc(field.toDopeType(), digits)
 
-fun trunc(value: TypeExpression<NumberType>, digits: CMField<out Number>) = trunc(value, digits.toDopeType())
+fun trunc(value: TypeExpression<NumberType>, digits: CMJsonField<out Number>) = trunc(value, digits.toDopeType())
 
-fun trunc(value: Number, digits: CMField<out Number>) = trunc(value, digits.toDopeType())
+fun trunc(value: Number, digits: CMJsonField<out Number>) = trunc(value, digits.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Sign.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Sign.kt
index 9236828f..dfbe41d6 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Sign.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/Sign.kt
@@ -2,6 +2,6 @@ package ch.ergon.dope.extension.type.numberfunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.sign
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun sign(field: CMField<out Number>) = sign(field.toDopeType())
+fun sign(field: CMJsonField<out Number>) = sign(field.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/TrigonometryFunctions.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/TrigonometryFunctions.kt
index 86e6ce83..543086ae 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/TrigonometryFunctions.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/numberfunction/TrigonometryFunctions.kt
@@ -12,35 +12,35 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.sin
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.numeric.tan
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun acos(field: CMField<out Number>) = acos(field.toDopeType())
+fun acos(field: CMJsonField<out Number>) = acos(field.toDopeType())
 
-fun asin(field: CMField<out Number>) = asin(field.toDopeType())
+fun asin(field: CMJsonField<out Number>) = asin(field.toDopeType())
 
-fun atan(field: CMField<out Number>) = atan(field.toDopeType())
+fun atan(field: CMJsonField<out Number>) = atan(field.toDopeType())
 
-fun atan2(divisor: CMField<out Number>, dividend: CMField<out Number>) =
+fun atan2(divisor: CMJsonField<out Number>, dividend: CMJsonField<out Number>) =
     atan2(divisor.toDopeType(), dividend.toDopeType())
 
-fun atan2(divisor: CMField<out Number>, dividend: TypeExpression<NumberType>) =
+fun atan2(divisor: CMJsonField<out Number>, dividend: TypeExpression<NumberType>) =
     atan2(divisor.toDopeType(), dividend)
 
-fun atan2(divisor: CMField<out Number>, dividend: Number) =
+fun atan2(divisor: CMJsonField<out Number>, dividend: Number) =
     atan2(divisor.toDopeType(), dividend)
 
-fun atan2(divisor: TypeExpression<NumberType>, dividend: CMField<out Number>) =
+fun atan2(divisor: TypeExpression<NumberType>, dividend: CMJsonField<out Number>) =
     atan2(divisor, dividend.toDopeType())
 
-fun atan2(divisor: Number, dividend: CMField<out Number>) =
+fun atan2(divisor: Number, dividend: CMJsonField<out Number>) =
     atan2(divisor, dividend.toDopeType())
 
-fun cos(field: CMField<out Number>) = cos(field.toDopeType())
+fun cos(field: CMJsonField<out Number>) = cos(field.toDopeType())
 
-fun degrees(field: CMField<out Number>) = degrees(field.toDopeType())
+fun degrees(field: CMJsonField<out Number>) = degrees(field.toDopeType())
 
-fun radians(field: CMField<out Number>) = radians(field.toDopeType())
+fun radians(field: CMJsonField<out Number>) = radians(field.toDopeType())
 
-fun sin(field: CMField<out Number>) = sin(field.toDopeType())
+fun sin(field: CMJsonField<out Number>) = sin(field.toDopeType())
 
-fun tan(field: CMField<out Number>) = tan(field.toDopeType())
+fun tan(field: CMJsonField<out Number>) = tan(field.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Between.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Between.kt
index 4f9a02df..2a5f0d2d 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Between.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Between.kt
@@ -8,116 +8,133 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.relational.notBetween
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("betweenNumber")
-fun CMField<out Number>.between(start: CMField<out Number>, end: CMField<out Number>): BetweenExpression<NumberType> =
+fun CMJsonField<out Number>.between(start: CMJsonField<out Number>, end: CMJsonField<out Number>): BetweenExpression<NumberType> =
     toDopeType().between(start.toDopeType(), end.toDopeType())
 
 @JvmName("betweenNumber")
-fun CMField<out Number>.between(start: CMField<out Number>, end: TypeExpression<NumberType>): BetweenExpression<NumberType> =
+fun CMJsonField<out Number>.between(start: CMJsonField<out Number>, end: TypeExpression<NumberType>): BetweenExpression<NumberType> =
     toDopeType().between(start.toDopeType(), end)
 
 @JvmName("betweenNumber")
-fun CMField<out Number>.between(start: TypeExpression<NumberType>, end: CMField<out Number>): BetweenExpression<NumberType> =
+fun CMJsonField<out Number>.between(start: TypeExpression<NumberType>, end: CMJsonField<out Number>): BetweenExpression<NumberType> =
     toDopeType().between(start, end.toDopeType())
 
 @JvmName("betweenNumber")
-fun CMField<out Number>.between(start: TypeExpression<NumberType>, end: TypeExpression<NumberType>): BetweenExpression<NumberType> =
+fun CMJsonField<out Number>.between(start: TypeExpression<NumberType>, end: TypeExpression<NumberType>): BetweenExpression<NumberType> =
     toDopeType().between(start, end)
 
 @JvmName("betweenNumber")
-fun TypeExpression<NumberType>.between(start: CMField<out Number>, end: CMField<out Number>): BetweenExpression<NumberType> =
-    this.between(start.toDopeType(), end.toDopeType())
+fun TypeExpression<NumberType>.between(start: CMJsonField<out Number>, end: CMJsonField<out Number>): BetweenExpression<NumberType> =
+    between(start.toDopeType(), end.toDopeType())
 
 @JvmName("betweenNumber")
-fun TypeExpression<NumberType>.between(start: CMField<out Number>, end: TypeExpression<NumberType>): BetweenExpression<NumberType> =
-    this.between(start.toDopeType(), end)
+fun TypeExpression<NumberType>.between(start: CMJsonField<out Number>, end: TypeExpression<NumberType>): BetweenExpression<NumberType> =
+    between(start.toDopeType(), end)
 
 @JvmName("betweenNumber")
-fun TypeExpression<NumberType>.between(start: TypeExpression<NumberType>, end: CMField<out Number>): BetweenExpression<NumberType> =
-    this.between(start, end.toDopeType())
+fun TypeExpression<NumberType>.between(start: TypeExpression<NumberType>, end: CMJsonField<out Number>): BetweenExpression<NumberType> =
+    between(start, end.toDopeType())
+
+@JvmName("betweenNumber")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.between(start: Convertable, end: Convertable):
+    BetweenExpression<NumberType> = toDopeType().between(toDopeType(start), toDopeType(end))
 
 @JvmName("betweenString")
-fun CMField<String>.between(start: CMField<String>, end: CMField<String>): BetweenExpression<StringType> =
+fun CMJsonField<String>.between(start: CMJsonField<String>, end: CMJsonField<String>): BetweenExpression<StringType> =
     toDopeType().between(start.toDopeType(), end.toDopeType())
 
 @JvmName("betweenString")
-fun CMField<String>.between(start: CMField<String>, end: TypeExpression<StringType>): BetweenExpression<StringType> =
+fun CMJsonField<String>.between(start: CMJsonField<String>, end: TypeExpression<StringType>): BetweenExpression<StringType> =
     toDopeType().between(start.toDopeType(), end)
 
 @JvmName("betweenString")
-fun CMField<String>.between(start: TypeExpression<StringType>, end: CMField<String>): BetweenExpression<StringType> =
+fun CMJsonField<String>.between(start: TypeExpression<StringType>, end: CMJsonField<String>): BetweenExpression<StringType> =
     toDopeType().between(start, end.toDopeType())
 
 @JvmName("betweenString")
-fun CMField<String>.between(start: TypeExpression<StringType>, end: TypeExpression<StringType>): BetweenExpression<StringType> =
+fun CMJsonField<String>.between(start: TypeExpression<StringType>, end: TypeExpression<StringType>): BetweenExpression<StringType> =
     toDopeType().between(start, end)
 
 @JvmName("betweenString")
-fun TypeExpression<StringType>.between(start: CMField<String>, end: CMField<String>): BetweenExpression<StringType> =
-    this.between(start.toDopeType(), end.toDopeType())
+fun TypeExpression<StringType>.between(start: CMJsonField<String>, end: CMJsonField<String>): BetweenExpression<StringType> =
+    between(start.toDopeType(), end.toDopeType())
 
 @JvmName("betweenString")
-fun TypeExpression<StringType>.between(start: CMField<String>, end: TypeExpression<StringType>): BetweenExpression<StringType> =
-    this.between(start.toDopeType(), end)
+fun TypeExpression<StringType>.between(start: CMJsonField<String>, end: TypeExpression<StringType>): BetweenExpression<StringType> =
+    between(start.toDopeType(), end)
 
 @JvmName("betweenString")
-fun TypeExpression<StringType>.between(start: TypeExpression<StringType>, end: CMField<String>): BetweenExpression<StringType> =
-    this.between(start, end.toDopeType())
+fun TypeExpression<StringType>.between(start: TypeExpression<StringType>, end: CMJsonField<String>): BetweenExpression<StringType> =
+    between(start, end.toDopeType())
 
-@JvmName("betweenNumber")
-fun CMField<out Number>.notBetween(start: CMField<out Number>, end: CMField<out Number>): NotBetweenExpression<NumberType> =
+@JvmName("betweenString")
+fun <Convertable : Any> CMConverterField<Convertable, String>.between(start: Convertable, end: Convertable): BetweenExpression<StringType> =
+    toDopeType().between(toDopeType(start), toDopeType(end))
+
+@JvmName("notBetweenNumber")
+fun CMJsonField<out Number>.notBetween(start: CMJsonField<out Number>, end: CMJsonField<out Number>): NotBetweenExpression<NumberType> =
     toDopeType().notBetween(start.toDopeType(), end.toDopeType())
 
-@JvmName("betweenNumber")
-fun CMField<out Number>.notBetween(start: CMField<out Number>, end: TypeExpression<NumberType>): NotBetweenExpression<NumberType> =
+@JvmName("notBetweenNumber")
+fun CMJsonField<out Number>.notBetween(start: CMJsonField<out Number>, end: TypeExpression<NumberType>): NotBetweenExpression<NumberType> =
     toDopeType().notBetween(start.toDopeType(), end)
 
-@JvmName("betweenNumber")
-fun CMField<out Number>.notBetween(start: TypeExpression<NumberType>, end: CMField<out Number>): NotBetweenExpression<NumberType> =
+@JvmName("notBetweenNumber")
+fun CMJsonField<out Number>.notBetween(start: TypeExpression<NumberType>, end: CMJsonField<out Number>): NotBetweenExpression<NumberType> =
     toDopeType().notBetween(start, end.toDopeType())
 
-@JvmName("betweenNumber")
-fun CMField<out Number>.notBetween(start: TypeExpression<NumberType>, end: TypeExpression<NumberType>): NotBetweenExpression<NumberType> =
+@JvmName("notBetweenNumber")
+fun CMJsonField<out Number>.notBetween(start: TypeExpression<NumberType>, end: TypeExpression<NumberType>): NotBetweenExpression<NumberType> =
     toDopeType().notBetween(start, end)
 
-@JvmName("betweenNumber")
-fun TypeExpression<NumberType>.notBetween(start: CMField<out Number>, end: CMField<out Number>): NotBetweenExpression<NumberType> =
+@JvmName("notBetweenNumber")
+fun TypeExpression<NumberType>.notBetween(start: CMJsonField<out Number>, end: CMJsonField<out Number>): NotBetweenExpression<NumberType> =
     this.notBetween(start.toDopeType(), end.toDopeType())
 
-@JvmName("betweenNumber")
-fun TypeExpression<NumberType>.notBetween(start: CMField<out Number>, end: TypeExpression<NumberType>): NotBetweenExpression<NumberType> =
+@JvmName("notBetweenNumber")
+fun TypeExpression<NumberType>.notBetween(start: CMJsonField<out Number>, end: TypeExpression<NumberType>): NotBetweenExpression<NumberType> =
     this.notBetween(start.toDopeType(), end)
 
-@JvmName("betweenNumber")
-fun TypeExpression<NumberType>.notBetween(start: TypeExpression<NumberType>, end: CMField<out Number>): NotBetweenExpression<NumberType> =
+@JvmName("notBetweenNumber")
+fun TypeExpression<NumberType>.notBetween(start: TypeExpression<NumberType>, end: CMJsonField<out Number>): NotBetweenExpression<NumberType> =
     this.notBetween(start, end.toDopeType())
 
-@JvmName("betweenString")
-fun CMField<String>.notBetween(start: CMField<String>, end: CMField<String>): NotBetweenExpression<StringType> =
+@JvmName("notBetweenNumber")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.notBetween(start: Convertable, end: Convertable):
+    NotBetweenExpression<NumberType> = toDopeType().notBetween(toDopeType(start), toDopeType(end))
+
+@JvmName("notBetweenString")
+fun CMJsonField<String>.notBetween(start: CMJsonField<String>, end: CMJsonField<String>): NotBetweenExpression<StringType> =
     toDopeType().notBetween(start.toDopeType(), end.toDopeType())
 
-@JvmName("betweenString")
-fun CMField<String>.notBetween(start: CMField<String>, end: TypeExpression<StringType>): NotBetweenExpression<StringType> =
+@JvmName("notBetweenString")
+fun CMJsonField<String>.notBetween(start: CMJsonField<String>, end: TypeExpression<StringType>): NotBetweenExpression<StringType> =
     toDopeType().notBetween(start.toDopeType(), end)
 
-@JvmName("betweenString")
-fun CMField<String>.notBetween(start: TypeExpression<StringType>, end: CMField<String>): NotBetweenExpression<StringType> =
+@JvmName("notBetweenString")
+fun CMJsonField<String>.notBetween(start: TypeExpression<StringType>, end: CMJsonField<String>): NotBetweenExpression<StringType> =
     toDopeType().notBetween(start, end.toDopeType())
 
-@JvmName("betweenString")
-fun CMField<String>.notBetween(start: TypeExpression<StringType>, end: TypeExpression<StringType>): NotBetweenExpression<StringType> =
+@JvmName("notBetweenString")
+fun CMJsonField<String>.notBetween(start: TypeExpression<StringType>, end: TypeExpression<StringType>): NotBetweenExpression<StringType> =
     toDopeType().notBetween(start, end)
 
-@JvmName("betweenString")
-fun TypeExpression<StringType>.notBetween(start: CMField<String>, end: CMField<String>): NotBetweenExpression<StringType> =
+@JvmName("notBetweenString")
+fun TypeExpression<StringType>.notBetween(start: CMJsonField<String>, end: CMJsonField<String>): NotBetweenExpression<StringType> =
     this.notBetween(start.toDopeType(), end.toDopeType())
 
-@JvmName("betweenString")
-fun TypeExpression<StringType>.notBetween(start: CMField<String>, end: TypeExpression<StringType>): NotBetweenExpression<StringType> =
+@JvmName("notBetweenString")
+fun TypeExpression<StringType>.notBetween(start: CMJsonField<String>, end: TypeExpression<StringType>): NotBetweenExpression<StringType> =
     this.notBetween(start.toDopeType(), end)
 
-@JvmName("betweenString")
-fun TypeExpression<StringType>.notBetween(start: TypeExpression<StringType>, end: CMField<String>): NotBetweenExpression<StringType> =
+@JvmName("notBetweenString")
+fun TypeExpression<StringType>.notBetween(start: TypeExpression<StringType>, end: CMJsonField<String>): NotBetweenExpression<StringType> =
     this.notBetween(start, end.toDopeType())
+
+@JvmName("notBetweenString")
+fun <Convertable : Any> CMConverterField<Convertable, String>.notBetween(start: Convertable, end: Convertable):
+    NotBetweenExpression<StringType> = toDopeType().notBetween(toDopeType(start), toDopeType(end))
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Equals.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Equals.kt
index 446fa921..25cad23b 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Equals.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Equals.kt
@@ -10,124 +10,149 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isEqualToNumber")
-fun CMField<out Number>.isEqualTo(right: Number): EqualsExpression<NumberType> =
+fun CMJsonField<out Number>.isEqualTo(right: Number): EqualsExpression<NumberType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToNumber")
-fun Number.isEqualTo(right: CMField<out Number>): EqualsExpression<NumberType> =
+fun Number.isEqualTo(right: CMJsonField<out Number>): EqualsExpression<NumberType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToNumber")
-fun CMField<out Number>.isEqualTo(right: CMField<out Number>): EqualsExpression<NumberType> =
+fun CMJsonField<out Number>.isEqualTo(right: CMJsonField<out Number>): EqualsExpression<NumberType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToNumber")
-fun TypeExpression<NumberType>.isEqualTo(right: CMField<out Number>): EqualsExpression<NumberType> =
+fun TypeExpression<NumberType>.isEqualTo(right: CMJsonField<out Number>): EqualsExpression<NumberType> =
     isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToNumber")
-fun CMField<out Number>.isEqualTo(right: TypeExpression<NumberType>): EqualsExpression<NumberType> =
+fun CMJsonField<out Number>.isEqualTo(right: TypeExpression<NumberType>): EqualsExpression<NumberType> =
     toDopeType().isEqualTo(right)
 
+@JvmName("isEqualToNumberConverter")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.isEqualTo(other: Convertable): EqualsExpression<NumberType> =
+    toDopeType().isEqualTo(toDopeType(other))
+
+@JvmName("isEqualToNumberConverter")
+fun <Convertable : Any, JsonType : Number> Convertable.isEqualTo(other: CMConverterField<Convertable, JsonType>): EqualsExpression<NumberType> =
+    toDopeType(other).isEqualTo(other.toDopeType())
+
 @JvmName("isEqualToString")
-fun CMField<String>.isEqualTo(right: String): EqualsExpression<StringType> =
+fun CMJsonField<String>.isEqualTo(right: String): EqualsExpression<StringType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToString")
-fun String.isEqualTo(right: CMField<String>): EqualsExpression<StringType> =
+fun String.isEqualTo(right: CMJsonField<String>): EqualsExpression<StringType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToString")
-fun CMField<String>.isEqualTo(right: CMField<String>): EqualsExpression<StringType> =
+fun CMJsonField<String>.isEqualTo(right: CMJsonField<String>): EqualsExpression<StringType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToString")
-fun TypeExpression<StringType>.isEqualTo(right: CMField<String>): EqualsExpression<StringType> =
+fun TypeExpression<StringType>.isEqualTo(right: CMJsonField<String>): EqualsExpression<StringType> =
     isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToString")
-fun CMField<String>.isEqualTo(right: TypeExpression<StringType>): EqualsExpression<StringType> =
+fun CMJsonField<String>.isEqualTo(right: TypeExpression<StringType>): EqualsExpression<StringType> =
     toDopeType().isEqualTo(right)
 
+@JvmName("isEqualToStringConverter")
+fun <JsonType : Any> CMConverterField<JsonType, String>.isEqualTo(other: JsonType): EqualsExpression<StringType> =
+    toDopeType().isEqualTo(toDopeType(other))
+
+@JvmName("isEqualToStringConverter")
+fun <Convertable : Any> Convertable.isEqualTo(other: CMConverterField<Convertable, String>): EqualsExpression<StringType> =
+    toDopeType(other).isEqualTo(other.toDopeType())
+
 @JvmName("isEqualToBoolean")
-fun CMField<Boolean>.isEqualTo(right: Boolean): EqualsExpression<BooleanType> =
+fun CMJsonField<Boolean>.isEqualTo(right: Boolean): EqualsExpression<BooleanType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToBoolean")
-fun Boolean.isEqualTo(right: CMField<Boolean>): EqualsExpression<BooleanType> =
+fun Boolean.isEqualTo(right: CMJsonField<Boolean>): EqualsExpression<BooleanType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToBoolean")
-fun CMField<Boolean>.isEqualTo(right: CMField<Boolean>): EqualsExpression<BooleanType> =
+fun CMJsonField<Boolean>.isEqualTo(right: CMJsonField<Boolean>): EqualsExpression<BooleanType> =
     toDopeType().isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToBoolean")
-fun TypeExpression<BooleanType>.isEqualTo(right: CMField<Boolean>): EqualsExpression<BooleanType> =
+fun TypeExpression<BooleanType>.isEqualTo(right: CMJsonField<Boolean>): EqualsExpression<BooleanType> =
     isEqualTo(right.toDopeType())
 
 @JvmName("isEqualToBoolean")
-fun CMField<Boolean>.isEqualTo(right: TypeExpression<BooleanType>): EqualsExpression<BooleanType> =
+fun CMJsonField<Boolean>.isEqualTo(right: TypeExpression<BooleanType>): EqualsExpression<BooleanType> =
     toDopeType().isEqualTo(right)
 
+@JvmName("isEqualToBooleanConverter")
+fun <JsonType : Any> CMConverterField<JsonType, Boolean>.isEqualTo(other: JsonType): EqualsExpression<BooleanType> =
+    toDopeType().isEqualTo(toDopeType(other))
+
+@JvmName("isEqualToBooleanConverter")
+fun <Convertable : Any> Convertable.isEqualTo(other: CMConverterField<Convertable, Boolean>): EqualsExpression<BooleanType> =
+    toDopeType(other).isEqualTo(other.toDopeType())
+
 @JvmName("isNotEqualToNumber")
-fun CMField<out Number>.isNotEqualTo(right: Number): NotEqualsExpression<NumberType> =
+fun CMJsonField<out Number>.isNotEqualTo(right: Number): NotEqualsExpression<NumberType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToNumber")
-fun Number.isNotEqualTo(right: CMField<out Number>): NotEqualsExpression<NumberType> =
+fun Number.isNotEqualTo(right: CMJsonField<out Number>): NotEqualsExpression<NumberType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToNumber")
-fun CMField<out Number>.isNotEqualTo(right: CMField<out Number>): NotEqualsExpression<NumberType> =
+fun CMJsonField<out Number>.isNotEqualTo(right: CMJsonField<out Number>): NotEqualsExpression<NumberType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToNumber")
-fun TypeExpression<NumberType>.isNotEqualTo(right: CMField<out Number>): NotEqualsExpression<NumberType> =
+fun TypeExpression<NumberType>.isNotEqualTo(right: CMJsonField<out Number>): NotEqualsExpression<NumberType> =
     isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToNumber")
-fun CMField<out Number>.isNotEqualTo(right: TypeExpression<NumberType>): NotEqualsExpression<NumberType> =
+fun CMJsonField<out Number>.isNotEqualTo(right: TypeExpression<NumberType>): NotEqualsExpression<NumberType> =
     toDopeType().isNotEqualTo(right)
 
 @JvmName("isNotEqualToString")
-fun CMField<String>.isNotEqualTo(right: String): NotEqualsExpression<StringType> =
+fun CMJsonField<String>.isNotEqualTo(right: String): NotEqualsExpression<StringType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToString")
-fun String.isNotEqualTo(right: CMField<String>): NotEqualsExpression<StringType> =
+fun String.isNotEqualTo(right: CMJsonField<String>): NotEqualsExpression<StringType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToString")
-fun CMField<String>.isNotEqualTo(right: CMField<String>): NotEqualsExpression<StringType> =
+fun CMJsonField<String>.isNotEqualTo(right: CMJsonField<String>): NotEqualsExpression<StringType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToString")
-fun TypeExpression<StringType>.isNotEqualTo(right: CMField<String>): NotEqualsExpression<StringType> =
+fun TypeExpression<StringType>.isNotEqualTo(right: CMJsonField<String>): NotEqualsExpression<StringType> =
     isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToString")
-fun CMField<String>.isNotEqualTo(right: TypeExpression<StringType>): NotEqualsExpression<StringType> =
+fun CMJsonField<String>.isNotEqualTo(right: TypeExpression<StringType>): NotEqualsExpression<StringType> =
     toDopeType().isNotEqualTo(right)
 
 @JvmName("isNotEqualToBoolean")
-fun CMField<Boolean>.isNotEqualTo(right: Boolean): NotEqualsExpression<BooleanType> =
+fun CMJsonField<Boolean>.isNotEqualTo(right: Boolean): NotEqualsExpression<BooleanType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToBoolean")
-fun Boolean.isNotEqualTo(right: CMField<Boolean>): NotEqualsExpression<BooleanType> =
+fun Boolean.isNotEqualTo(right: CMJsonField<Boolean>): NotEqualsExpression<BooleanType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToBoolean")
-fun CMField<Boolean>.isNotEqualTo(right: CMField<Boolean>): NotEqualsExpression<BooleanType> =
+fun CMJsonField<Boolean>.isNotEqualTo(right: CMJsonField<Boolean>): NotEqualsExpression<BooleanType> =
     toDopeType().isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToBoolean")
-fun TypeExpression<BooleanType>.isNotEqualTo(right: CMField<Boolean>): NotEqualsExpression<BooleanType> =
+fun TypeExpression<BooleanType>.isNotEqualTo(right: CMJsonField<Boolean>): NotEqualsExpression<BooleanType> =
     isNotEqualTo(right.toDopeType())
 
 @JvmName("isNotEqualToBoolean")
-fun CMField<Boolean>.isNotEqualTo(right: TypeExpression<BooleanType>): NotEqualsExpression<BooleanType> =
+fun CMJsonField<Boolean>.isNotEqualTo(right: TypeExpression<BooleanType>): NotEqualsExpression<BooleanType> =
     toDopeType().isNotEqualTo(right)
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Exists.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Exists.kt
index bf946601..591f190a 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Exists.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Exists.kt
@@ -6,13 +6,13 @@ import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("existsNumberArray")
-fun exists(field: CMList<out Number>): ExistsExpression<NumberType> = exists(field.toDopeType())
+fun exists(field: CMJsonList<out Number>): ExistsExpression<NumberType> = exists(field.toDopeType())
 
 @JvmName("existsStringArray")
-fun exists(field: CMList<String>): ExistsExpression<StringType> = exists(field.toDopeType())
+fun exists(field: CMJsonList<String>): ExistsExpression<StringType> = exists(field.toDopeType())
 
 @JvmName("existsExistsArray")
-fun exists(field: CMList<Boolean>): ExistsExpression<BooleanType> = exists(field.toDopeType())
+fun exists(field: CMJsonList<Boolean>): ExistsExpression<BooleanType> = exists(field.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterOrEqualThan.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterOrEqualThan.kt
index 5d0bebf4..5b1ba8be 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterOrEqualThan.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterOrEqualThan.kt
@@ -7,44 +7,61 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isGreaterOrEqualThanNumber")
-fun CMField<out Number>.isGreaterOrEqualThan(right: CMField<out Number>): GreaterOrEqualThanExpression<NumberType> =
+fun CMJsonField<out Number>.isGreaterOrEqualThan(right: CMJsonField<out Number>): GreaterOrEqualThanExpression<NumberType> =
     toDopeType().isGreaterOrEqualThan(right.toDopeType())
 
 @JvmName("isGreaterOrEqualThanNumber")
-fun TypeExpression<NumberType>.isGreaterOrEqualThan(right: CMField<out Number>): GreaterOrEqualThanExpression<NumberType> =
+fun TypeExpression<NumberType>.isGreaterOrEqualThan(right: CMJsonField<out Number>): GreaterOrEqualThanExpression<NumberType> =
     isGreaterOrEqualThan(right.toDopeType())
 
 @JvmName("isGreaterOrEqualThanNumber")
-fun Number.isGreaterOrEqualThan(right: CMField<out Number>): GreaterOrEqualThanExpression<NumberType> =
+fun Number.isGreaterOrEqualThan(right: CMJsonField<out Number>): GreaterOrEqualThanExpression<NumberType> =
     toDopeType().isGreaterOrEqualThan(right.toDopeType())
 
 @JvmName("isGreaterOrEqualThanNumber")
-fun CMField<out Number>.isGreaterOrEqualThan(right: TypeExpression<NumberType>): GreaterOrEqualThanExpression<NumberType> =
+fun CMJsonField<out Number>.isGreaterOrEqualThan(right: TypeExpression<NumberType>): GreaterOrEqualThanExpression<NumberType> =
     toDopeType().isGreaterOrEqualThan(right)
 
 @JvmName("isGreaterOrEqualThanNumber")
-fun CMField<out Number>.isGreaterOrEqualThan(right: Number): GreaterOrEqualThanExpression<NumberType> =
+fun CMJsonField<out Number>.isGreaterOrEqualThan(right: Number): GreaterOrEqualThanExpression<NumberType> =
     toDopeType().isGreaterOrEqualThan(right.toDopeType())
 
+@JvmName("isGreaterOrEqualThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.isGreaterOrEqualThan(other: Convertable):
+    GreaterOrEqualThanExpression<NumberType> = toDopeType().isGreaterOrEqualThan(toDopeType(other))
+
+@JvmName("isGreaterOrEqualThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> Convertable.isGreaterOrEqualThan(other: CMConverterField<Convertable, JsonType>):
+    GreaterOrEqualThanExpression<NumberType> = toDopeType(other).isGreaterOrEqualThan(other.toDopeType())
+
 @JvmName("isGreaterOrEqualThanString")
-fun CMField<String>.isGreaterOrEqualThan(right: CMField<String>): GreaterOrEqualThanExpression<StringType> =
+fun CMJsonField<String>.isGreaterOrEqualThan(right: CMJsonField<String>): GreaterOrEqualThanExpression<StringType> =
     toDopeType().isGreaterOrEqualThan(right.toDopeType())
 
 @JvmName("isGreaterOrEqualThanString")
-fun TypeExpression<StringType>.isGreaterOrEqualThan(right: CMField<String>): GreaterOrEqualThanExpression<StringType> =
+fun TypeExpression<StringType>.isGreaterOrEqualThan(right: CMJsonField<String>): GreaterOrEqualThanExpression<StringType> =
     isGreaterOrEqualThan(right.toDopeType())
 
 @JvmName("isGreaterOrEqualThanString")
-fun String.isGreaterOrEqualThan(right: CMField<String>): GreaterOrEqualThanExpression<StringType> =
+fun String.isGreaterOrEqualThan(right: CMJsonField<String>): GreaterOrEqualThanExpression<StringType> =
     toDopeType().isGreaterOrEqualThan(right.toDopeType())
 
 @JvmName("isGreaterOrEqualThanString")
-fun CMField<String>.isGreaterOrEqualThan(right: TypeExpression<StringType>): GreaterOrEqualThanExpression<StringType> =
+fun CMJsonField<String>.isGreaterOrEqualThan(right: TypeExpression<StringType>): GreaterOrEqualThanExpression<StringType> =
     toDopeType().isGreaterOrEqualThan(right)
 
 @JvmName("isGreaterOrEqualThanString")
-fun CMField<String>.isGreaterOrEqualThan(right: String): GreaterOrEqualThanExpression<StringType> =
+fun CMJsonField<String>.isGreaterOrEqualThan(right: String): GreaterOrEqualThanExpression<StringType> =
     toDopeType().isGreaterOrEqualThan(right.toDopeType())
+
+@JvmName("isGreaterOrEqualThanStringConverter")
+fun <Convertable : Any> CMConverterField<Convertable, String>.isGreaterOrEqualThan(other: Convertable):
+    GreaterOrEqualThanExpression<StringType> = toDopeType().isGreaterOrEqualThan(toDopeType(other))
+
+@JvmName("isGreaterOrEqualThanStringConverter")
+fun <Convertable : Any> Convertable.isGreaterOrEqualThan(other: CMConverterField<Convertable, String>):
+    GreaterOrEqualThanExpression<StringType> = toDopeType(other).isGreaterOrEqualThan(other.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterThan.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterThan.kt
index 6c6aba35..b30bed2a 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterThan.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/GreaterThan.kt
@@ -7,44 +7,61 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isGreaterThanNumber")
-fun CMField<out Number>.isGreaterThan(right: CMField<out Number>): GreaterThanExpression<NumberType> =
+fun CMJsonField<out Number>.isGreaterThan(right: CMJsonField<out Number>): GreaterThanExpression<NumberType> =
     toDopeType().isGreaterThan(right.toDopeType())
 
 @JvmName("isGreaterThanNumber")
-fun TypeExpression<NumberType>.isGreaterThan(right: CMField<out Number>): GreaterThanExpression<NumberType> =
+fun TypeExpression<NumberType>.isGreaterThan(right: CMJsonField<out Number>): GreaterThanExpression<NumberType> =
     isGreaterThan(right.toDopeType())
 
 @JvmName("isGreaterThanNumber")
-fun Number.isGreaterThan(right: CMField<out Number>): GreaterThanExpression<NumberType> =
+fun Number.isGreaterThan(right: CMJsonField<out Number>): GreaterThanExpression<NumberType> =
     toDopeType().isGreaterThan(right.toDopeType())
 
 @JvmName("isGreaterThanNumber")
-fun CMField<out Number>.isGreaterThan(right: TypeExpression<NumberType>): GreaterThanExpression<NumberType> =
+fun CMJsonField<out Number>.isGreaterThan(right: TypeExpression<NumberType>): GreaterThanExpression<NumberType> =
     toDopeType().isGreaterThan(right)
 
 @JvmName("isGreaterThanNumber")
-fun CMField<out Number>.isGreaterThan(right: Number): GreaterThanExpression<NumberType> =
+fun CMJsonField<out Number>.isGreaterThan(right: Number): GreaterThanExpression<NumberType> =
     toDopeType().isGreaterThan(right.toDopeType())
 
+@JvmName("isGreaterThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.isGreaterThan(other: Convertable):
+    GreaterThanExpression<NumberType> = toDopeType().isGreaterThan(toDopeType(other))
+
+@JvmName("isGreaterThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> Convertable.isGreaterThan(other: CMConverterField<Convertable, JsonType>):
+    GreaterThanExpression<NumberType> = toDopeType(other).isGreaterThan(other.toDopeType())
+
 @JvmName("isGreaterThanString")
-fun CMField<String>.isGreaterThan(right: CMField<String>): GreaterThanExpression<StringType> =
+fun CMJsonField<String>.isGreaterThan(right: CMJsonField<String>): GreaterThanExpression<StringType> =
     toDopeType().isGreaterThan(right.toDopeType())
 
 @JvmName("isGreaterThanString")
-fun TypeExpression<StringType>.isGreaterThan(right: CMField<String>): GreaterThanExpression<StringType> =
+fun TypeExpression<StringType>.isGreaterThan(right: CMJsonField<String>): GreaterThanExpression<StringType> =
     isGreaterThan(right.toDopeType())
 
 @JvmName("isGreaterThanString")
-fun String.isGreaterThan(right: CMField<String>): GreaterThanExpression<StringType> =
+fun String.isGreaterThan(right: CMJsonField<String>): GreaterThanExpression<StringType> =
     toDopeType().isGreaterThan(right.toDopeType())
 
 @JvmName("isGreaterThanString")
-fun CMField<String>.isGreaterThan(right: TypeExpression<StringType>): GreaterThanExpression<StringType> =
+fun CMJsonField<String>.isGreaterThan(right: TypeExpression<StringType>): GreaterThanExpression<StringType> =
     toDopeType().isGreaterThan(right)
 
 @JvmName("isGreaterThanString")
-fun CMField<String>.isGreaterThan(right: String): GreaterThanExpression<StringType> =
+fun CMJsonField<String>.isGreaterThan(right: String): GreaterThanExpression<StringType> =
     toDopeType().isGreaterThan(right.toDopeType())
+
+@JvmName("isGreaterThanStringConverter")
+fun <JsonType : Any> CMConverterField<JsonType, String>.isGreaterThan(other: JsonType): GreaterThanExpression<StringType> =
+    toDopeType().isGreaterThan(toDopeType(other))
+
+@JvmName("isGreaterThanStringConverter")
+fun <Convertable : Any> Convertable.isGreaterThan(other: CMConverterField<Convertable, String>): GreaterThanExpression<StringType> =
+    toDopeType(other).isGreaterThan(other.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Greatest.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Greatest.kt
index 8327676b..c0260b36 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Greatest.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Greatest.kt
@@ -2,13 +2,13 @@ package ch.ergon.dope.extension.type.relational
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.comparison.greatestOf
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("greatestOfCMNumberField")
 fun greatestOf(
-    firstExpression: CMField<out Number>,
-    secondExpression: CMField<out Number>,
-    vararg additionalExpressions: CMField<out Number>,
+    firstExpression: CMJsonField<out Number>,
+    secondExpression: CMJsonField<out Number>,
+    vararg additionalExpressions: CMJsonField<out Number>,
 ) = greatestOf(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -17,9 +17,9 @@ fun greatestOf(
 
 @JvmName("greatestOfCMStringField")
 fun greatestOf(
-    firstExpression: CMField<String>,
-    secondExpression: CMField<String>,
-    vararg additionalExpressions: CMField<String>,
+    firstExpression: CMJsonField<String>,
+    secondExpression: CMJsonField<String>,
+    vararg additionalExpressions: CMJsonField<String>,
 ) = greatestOf(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/In.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/In.kt
index 2226d9b5..294ac5af 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/In.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/In.kt
@@ -11,125 +11,151 @@ import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMConverterList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("inArrayNumber")
-fun CMField<out Number>.inArray(array: TypeExpression<ArrayType<NumberType>>): InExpression<NumberType> =
+fun CMJsonField<out Number>.inArray(array: TypeExpression<ArrayType<NumberType>>): InExpression<NumberType> =
     toDopeType().inArray(array)
 
 @JvmName("inArrayString")
-fun CMField<String>.inArray(array: TypeExpression<ArrayType<StringType>>): InExpression<StringType> =
+fun CMJsonField<String>.inArray(array: TypeExpression<ArrayType<StringType>>): InExpression<StringType> =
     toDopeType().inArray(array)
 
 @JvmName("inArrayBoolean")
-fun CMField<Boolean>.inArray(array: TypeExpression<ArrayType<BooleanType>>): InExpression<BooleanType> =
+fun CMJsonField<Boolean>.inArray(array: TypeExpression<ArrayType<BooleanType>>): InExpression<BooleanType> =
     toDopeType().inArray(array)
 
 @JvmName("inArrayNumber")
-fun TypeExpression<NumberType>.inArray(array: CMList<out Number>): InExpression<NumberType> =
-    this.inArray(array.toDopeType())
+fun TypeExpression<NumberType>.inArray(array: CMJsonList<out Number>): InExpression<NumberType> =
+    inArray(array.toDopeType())
 
 @JvmName("inArrayString")
-fun TypeExpression<StringType>.inArray(array: CMList<String>): InExpression<StringType> =
-    this.inArray(array.toDopeType())
+fun TypeExpression<StringType>.inArray(array: CMJsonList<String>): InExpression<StringType> =
+    inArray(array.toDopeType())
 
 @JvmName("inArrayBoolean")
-fun TypeExpression<BooleanType>.inArray(array: CMList<Boolean>): InExpression<BooleanType> =
-    this.inArray(array.toDopeType())
+fun TypeExpression<BooleanType>.inArray(array: CMJsonList<Boolean>): InExpression<BooleanType> =
+    inArray(array.toDopeType())
 
 @JvmName("inArrayNumber")
-fun CMField<out Number>.inArray(array: CMList<out Number>): InExpression<NumberType> =
+fun CMJsonField<out Number>.inArray(array: CMJsonList<out Number>): InExpression<NumberType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayString")
-fun CMField<String>.inArray(array: CMList<String>): InExpression<StringType> =
+fun CMJsonField<String>.inArray(array: CMJsonList<String>): InExpression<StringType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayBoolean")
-fun CMField<Boolean>.inArray(array: CMList<Boolean>): InExpression<BooleanType> =
+fun CMJsonField<Boolean>.inArray(array: CMJsonList<Boolean>): InExpression<BooleanType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayNumber")
-fun CMField<out Number>.inArray(array: Collection<TypeExpression<NumberType>>): InExpression<NumberType> =
+fun CMJsonField<out Number>.inArray(array: Collection<TypeExpression<NumberType>>): InExpression<NumberType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayString")
-fun CMField<String>.inArray(array: Collection<TypeExpression<StringType>>): InExpression<StringType> =
+fun CMJsonField<String>.inArray(array: Collection<TypeExpression<StringType>>): InExpression<StringType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayBoolean")
-fun CMField<Boolean>.inArray(array: Collection<TypeExpression<BooleanType>>): InExpression<BooleanType> =
+fun CMJsonField<Boolean>.inArray(array: Collection<TypeExpression<BooleanType>>): InExpression<BooleanType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayNumber")
-fun Number.inArray(array: CMList<out Number>): InExpression<NumberType> =
+fun Number.inArray(array: CMJsonList<out Number>): InExpression<NumberType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayString")
-fun String.inArray(array: CMList<String>): InExpression<StringType> =
+fun String.inArray(array: CMJsonList<String>): InExpression<StringType> =
     toDopeType().inArray(array.toDopeType())
 
 @JvmName("inArrayBoolean")
-fun Boolean.inArray(array: CMList<Boolean>): InExpression<BooleanType> =
+fun Boolean.inArray(array: CMJsonList<Boolean>): InExpression<BooleanType> =
     toDopeType().inArray(array.toDopeType())
 
+@JvmName("inArrayNumberConverter")
+fun <Convertable : Any, JsonType : Number> Convertable.inArray(array: CMConverterList<Convertable, JsonType>): InExpression<NumberType> =
+    toDopeType(array).inArray(array.toDopeType())
+
+@JvmName("inArrayStringConverter")
+fun <Convertable : Any> Convertable.inArray(array: CMConverterList<Convertable, String>): InExpression<StringType> =
+    toDopeType(array).inArray(array.toDopeType())
+
+@JvmName("inArrayBooleanConverter")
+fun <Convertable : Any> Convertable.inArray(array: CMConverterList<Convertable, Boolean>): InExpression<BooleanType> =
+    toDopeType(array).inArray(array.toDopeType())
+
+@JvmName("inArrayNumberConverter")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.inArray(array: Collection<Convertable>):
+    InExpression<NumberType> = toDopeType().inArray(array.map { it.toDopeType(this) }.toDopeType())
+
+@JvmName("inArrayStringConverter")
+fun <Convertable : Any> CMConverterField<Convertable, String>.inArray(array: Collection<Convertable>): InExpression<StringType> =
+    toDopeType().inArray(array.map { it.toDopeType(this) }.toDopeType())
+
+@JvmName("inArrayBooleanConverter")
+fun <Convertable : Any> CMConverterField<Convertable, Boolean>.inArray(array: Collection<Convertable>): InExpression<BooleanType> =
+    toDopeType().inArray(array.map { it.toDopeType(this) }.toDopeType())
+
 @JvmName("notInArrayNumber")
-fun CMField<out Number>.notInArray(array: TypeExpression<ArrayType<NumberType>>): NotInExpression<NumberType> =
+fun CMJsonField<out Number>.notInArray(array: TypeExpression<ArrayType<NumberType>>): NotInExpression<NumberType> =
     toDopeType().notInArray(array)
 
 @JvmName("notInArrayString")
-fun CMField<String>.notInArray(array: TypeExpression<ArrayType<StringType>>): NotInExpression<StringType> =
+fun CMJsonField<String>.notInArray(array: TypeExpression<ArrayType<StringType>>): NotInExpression<StringType> =
     toDopeType().notInArray(array)
 
 @JvmName("notInArrayBoolean")
-fun CMField<Boolean>.notInArray(array: TypeExpression<ArrayType<BooleanType>>): NotInExpression<BooleanType> =
+fun CMJsonField<Boolean>.notInArray(array: TypeExpression<ArrayType<BooleanType>>): NotInExpression<BooleanType> =
     toDopeType().notInArray(array)
 
 @JvmName("notInArrayNumber")
-fun TypeExpression<NumberType>.notInArray(array: CMList<out Number>): NotInExpression<NumberType> =
+fun TypeExpression<NumberType>.notInArray(array: CMJsonList<out Number>): NotInExpression<NumberType> =
     this.notInArray(array.toDopeType())
 
 @JvmName("notInArrayString")
-fun TypeExpression<StringType>.notInArray(array: CMList<String>): NotInExpression<StringType> =
+fun TypeExpression<StringType>.notInArray(array: CMJsonList<String>): NotInExpression<StringType> =
     this.notInArray(array.toDopeType())
 
 @JvmName("notInArrayBoolean")
-fun TypeExpression<BooleanType>.notInArray(array: CMList<Boolean>): NotInExpression<BooleanType> =
+fun TypeExpression<BooleanType>.notInArray(array: CMJsonList<Boolean>): NotInExpression<BooleanType> =
     this.notInArray(array.toDopeType())
 
 @JvmName("notInArrayNumber")
-fun CMField<out Number>.notInArray(array: CMList<out Number>): NotInExpression<NumberType> =
+fun CMJsonField<out Number>.notInArray(array: CMJsonList<out Number>): NotInExpression<NumberType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayString")
-fun CMField<String>.notInArray(array: CMList<String>): NotInExpression<StringType> =
+fun CMJsonField<String>.notInArray(array: CMJsonList<String>): NotInExpression<StringType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayBoolean")
-fun CMField<Boolean>.notInArray(array: CMList<Boolean>): NotInExpression<BooleanType> =
+fun CMJsonField<Boolean>.notInArray(array: CMJsonList<Boolean>): NotInExpression<BooleanType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayNumber")
-fun CMField<out Number>.notInArray(array: Collection<TypeExpression<NumberType>>): NotInExpression<NumberType> =
+fun CMJsonField<out Number>.notInArray(array: Collection<TypeExpression<NumberType>>): NotInExpression<NumberType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayString")
-fun CMField<String>.notInArray(array: Collection<TypeExpression<StringType>>): NotInExpression<StringType> =
+fun CMJsonField<String>.notInArray(array: Collection<TypeExpression<StringType>>): NotInExpression<StringType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayBoolean")
-fun CMField<Boolean>.notInArray(array: Collection<TypeExpression<BooleanType>>): NotInExpression<BooleanType> =
+fun CMJsonField<Boolean>.notInArray(array: Collection<TypeExpression<BooleanType>>): NotInExpression<BooleanType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayNumber")
-fun Number.notInArray(array: CMList<out Number>): NotInExpression<NumberType> =
+fun Number.notInArray(array: CMJsonList<out Number>): NotInExpression<NumberType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayString")
-fun String.notInArray(array: CMList<String>): NotInExpression<StringType> =
+fun String.notInArray(array: CMJsonList<String>): NotInExpression<StringType> =
     toDopeType().notInArray(array.toDopeType())
 
 @JvmName("notInArrayBoolean")
-fun Boolean.notInArray(array: CMList<Boolean>): NotInExpression<BooleanType> =
+fun Boolean.notInArray(array: CMJsonList<Boolean>): NotInExpression<BooleanType> =
     toDopeType().notInArray(array.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsMissing.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsMissing.kt
index 4528bb0f..6b0dcb9d 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsMissing.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsMissing.kt
@@ -3,22 +3,22 @@ package ch.ergon.dope.extension.type.relational
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isMissing
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isNotMissing
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isMissingNumber")
-fun CMField<out Number>.isMissing() = toDopeType().isMissing()
+fun CMJsonField<out Number>.isMissing() = toDopeType().isMissing()
 
 @JvmName("isMissingString")
-fun CMField<String>.isMissing() = toDopeType().isMissing()
+fun CMJsonField<String>.isMissing() = toDopeType().isMissing()
 
 @JvmName("isMissingBoolean")
-fun CMField<Boolean>.isMissing() = toDopeType().isMissing()
+fun CMJsonField<Boolean>.isMissing() = toDopeType().isMissing()
 
 @JvmName("isNotMissingNumber")
-fun CMField<out Number>.isNotMissing() = toDopeType().isNotMissing()
+fun CMJsonField<out Number>.isNotMissing() = toDopeType().isNotMissing()
 
 @JvmName("isNotMissingString")
-fun CMField<String>.isNotMissing() = toDopeType().isNotMissing()
+fun CMJsonField<String>.isNotMissing() = toDopeType().isNotMissing()
 
 @JvmName("isNotMissingBoolean")
-fun CMField<Boolean>.isNotMissing() = toDopeType().isNotMissing()
+fun CMJsonField<Boolean>.isNotMissing() = toDopeType().isNotMissing()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsNull.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsNull.kt
index 8d69bf4d..7ae1097f 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsNull.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsNull.kt
@@ -3,22 +3,22 @@ package ch.ergon.dope.extension.type.relational
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isNotNull
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isNull
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isNullNumber")
-fun CMField<out Number>.isNull() = toDopeType().isNull()
+fun CMJsonField<out Number>.isNull() = toDopeType().isNull()
 
 @JvmName("isNullString")
-fun CMField<String>.isNull() = toDopeType().isNull()
+fun CMJsonField<String>.isNull() = toDopeType().isNull()
 
 @JvmName("isNullBoolean")
-fun CMField<Boolean>.isNull() = toDopeType().isNull()
+fun CMJsonField<Boolean>.isNull() = toDopeType().isNull()
 
 @JvmName("isNotNullNumber")
-fun CMField<out Number>.isNotNull() = toDopeType().isNotNull()
+fun CMJsonField<out Number>.isNotNull() = toDopeType().isNotNull()
 
 @JvmName("isNotNullString")
-fun CMField<String>.isNotNull() = toDopeType().isNotNull()
+fun CMJsonField<String>.isNotNull() = toDopeType().isNotNull()
 
 @JvmName("isNotNullBoolean")
-fun CMField<Boolean>.isNotNull() = toDopeType().isNotNull()
+fun CMJsonField<Boolean>.isNotNull() = toDopeType().isNotNull()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsValued.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsValued.kt
index 792494e1..a9cdf8b6 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsValued.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/IsValued.kt
@@ -3,22 +3,22 @@ package ch.ergon.dope.extension.type.relational
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isNotValued
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isValued
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isValuedNumber")
-fun CMField<out Number>.isValued() = toDopeType().isValued()
+fun CMJsonField<out Number>.isValued() = toDopeType().isValued()
 
 @JvmName("isValuedString")
-fun CMField<String>.isValued() = toDopeType().isValued()
+fun CMJsonField<String>.isValued() = toDopeType().isValued()
 
 @JvmName("isValuedBoolean")
-fun CMField<Boolean>.isValued() = toDopeType().isValued()
+fun CMJsonField<Boolean>.isValued() = toDopeType().isValued()
 
 @JvmName("isNotValuedNumber")
-fun CMField<out Number>.isNotValued() = toDopeType().isNotValued()
+fun CMJsonField<out Number>.isNotValued() = toDopeType().isNotValued()
 
 @JvmName("isNotValuedString")
-fun CMField<String>.isNotValued() = toDopeType().isNotValued()
+fun CMJsonField<String>.isNotValued() = toDopeType().isNotValued()
 
 @JvmName("isNotValuedBoolean")
-fun CMField<Boolean>.isNotValued() = toDopeType().isNotValued()
+fun CMJsonField<Boolean>.isNotValued() = toDopeType().isNotValued()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Least.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Least.kt
index cc88be66..a7359346 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Least.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Least.kt
@@ -2,13 +2,13 @@ package ch.ergon.dope.extension.type.relational
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.comparison.leastOf
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("leastOfCMNumberField")
 fun leastOf(
-    firstExpression: CMField<out Number>,
-    secondExpression: CMField<out Number>,
-    vararg additionalExpressions: CMField<out Number>,
+    firstExpression: CMJsonField<out Number>,
+    secondExpression: CMJsonField<out Number>,
+    vararg additionalExpressions: CMJsonField<out Number>,
 ) = leastOf(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
@@ -17,9 +17,9 @@ fun leastOf(
 
 @JvmName("leastOfCMStringField")
 fun leastOf(
-    firstExpression: CMField<String>,
-    secondExpression: CMField<String>,
-    vararg additionalExpressions: CMField<String>,
+    firstExpression: CMJsonField<String>,
+    secondExpression: CMJsonField<String>,
+    vararg additionalExpressions: CMJsonField<String>,
 ) = leastOf(
     firstExpression.toDopeType(),
     secondExpression.toDopeType(),
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessOrEqualThan.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessOrEqualThan.kt
index 20197520..99a99606 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessOrEqualThan.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessOrEqualThan.kt
@@ -7,44 +7,61 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isLessOrEqualThanNumber")
-fun CMField<out Number>.isLessOrEqualThan(right: CMField<out Number>): LessOrEqualThanExpression<NumberType> =
+fun CMJsonField<out Number>.isLessOrEqualThan(right: CMJsonField<out Number>): LessOrEqualThanExpression<NumberType> =
     toDopeType().isLessOrEqualThan(right.toDopeType())
 
 @JvmName("isLessOrEqualThanNumber")
-fun TypeExpression<NumberType>.isLessOrEqualThan(right: CMField<out Number>): LessOrEqualThanExpression<NumberType> =
+fun TypeExpression<NumberType>.isLessOrEqualThan(right: CMJsonField<out Number>): LessOrEqualThanExpression<NumberType> =
     isLessOrEqualThan(right.toDopeType())
 
 @JvmName("isLessOrEqualThanNumber")
-fun Number.isLessOrEqualThan(right: CMField<out Number>): LessOrEqualThanExpression<NumberType> =
+fun Number.isLessOrEqualThan(right: CMJsonField<out Number>): LessOrEqualThanExpression<NumberType> =
     toDopeType().isLessOrEqualThan(right.toDopeType())
 
 @JvmName("isLessOrEqualThanNumber")
-fun CMField<out Number>.isLessOrEqualThan(right: TypeExpression<NumberType>): LessOrEqualThanExpression<NumberType> =
+fun CMJsonField<out Number>.isLessOrEqualThan(right: TypeExpression<NumberType>): LessOrEqualThanExpression<NumberType> =
     toDopeType().isLessOrEqualThan(right)
 
 @JvmName("isLessOrEqualThanNumber")
-fun CMField<out Number>.isLessOrEqualThan(right: Number): LessOrEqualThanExpression<NumberType> =
+fun CMJsonField<out Number>.isLessOrEqualThan(right: Number): LessOrEqualThanExpression<NumberType> =
     toDopeType().isLessOrEqualThan(right.toDopeType())
 
+@JvmName("isLessOrEqualThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.isLessOrEqualThan(other: Convertable):
+    LessOrEqualThanExpression<NumberType> = toDopeType().isLessOrEqualThan(toDopeType(other))
+
+@JvmName("isLessOrEqualThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> Convertable.isLessOrEqualThan(other: CMConverterField<Convertable, JsonType>):
+    LessOrEqualThanExpression<NumberType> = toDopeType(other).isLessOrEqualThan(other.toDopeType())
+
 @JvmName("isLessOrEqualThanString")
-fun CMField<String>.isLessOrEqualThan(right: CMField<String>): LessOrEqualThanExpression<StringType> =
+fun CMJsonField<String>.isLessOrEqualThan(right: CMJsonField<String>): LessOrEqualThanExpression<StringType> =
     toDopeType().isLessOrEqualThan(right.toDopeType())
 
 @JvmName("isLessOrEqualThanString")
-fun TypeExpression<StringType>.isLessOrEqualThan(right: CMField<String>): LessOrEqualThanExpression<StringType> =
+fun TypeExpression<StringType>.isLessOrEqualThan(right: CMJsonField<String>): LessOrEqualThanExpression<StringType> =
     isLessOrEqualThan(right.toDopeType())
 
 @JvmName("isLessOrEqualThanString")
-fun String.isLessOrEqualThan(right: CMField<String>): LessOrEqualThanExpression<StringType> =
+fun String.isLessOrEqualThan(right: CMJsonField<String>): LessOrEqualThanExpression<StringType> =
     toDopeType().isLessOrEqualThan(right.toDopeType())
 
 @JvmName("isLessOrEqualThanString")
-fun CMField<String>.isLessOrEqualThan(right: TypeExpression<StringType>): LessOrEqualThanExpression<StringType> =
+fun CMJsonField<String>.isLessOrEqualThan(right: TypeExpression<StringType>): LessOrEqualThanExpression<StringType> =
     toDopeType().isLessOrEqualThan(right)
 
 @JvmName("isLessOrEqualThanString")
-fun CMField<String>.isLessOrEqualThan(right: String): LessOrEqualThanExpression<StringType> =
+fun CMJsonField<String>.isLessOrEqualThan(right: String): LessOrEqualThanExpression<StringType> =
     toDopeType().isLessOrEqualThan(right.toDopeType())
+
+@JvmName("isLessOrEqualThanStringConverter")
+fun <JsonType : Any> CMConverterField<JsonType, String>.isLessOrEqualThan(other: JsonType): LessOrEqualThanExpression<StringType> =
+    toDopeType().isLessOrEqualThan(toDopeType(other))
+
+@JvmName("isLessOrEqualThanStringConverter")
+fun <Convertable : Any> Convertable.isLessOrEqualThan(other: CMConverterField<Convertable, String>): LessOrEqualThanExpression<StringType> =
+    toDopeType(other).isLessOrEqualThan(other.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessThan.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessThan.kt
index 8e67d5c2..b5314012 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessThan.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/LessThan.kt
@@ -7,44 +7,61 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("isLessThanNumber")
-fun CMField<out Number>.isLessThan(right: CMField<out Number>): LessThanExpression<NumberType> =
+fun CMJsonField<out Number>.isLessThan(right: CMJsonField<out Number>): LessThanExpression<NumberType> =
     toDopeType().isLessThan(right.toDopeType())
 
 @JvmName("isLessThanNumber")
-fun TypeExpression<NumberType>.isLessThan(right: CMField<out Number>): LessThanExpression<NumberType> =
+fun TypeExpression<NumberType>.isLessThan(right: CMJsonField<out Number>): LessThanExpression<NumberType> =
     isLessThan(right.toDopeType())
 
 @JvmName("isLessThanNumber")
-fun Number.isLessThan(right: CMField<out Number>): LessThanExpression<NumberType> =
+fun Number.isLessThan(right: CMJsonField<out Number>): LessThanExpression<NumberType> =
     toDopeType().isLessThan(right.toDopeType())
 
 @JvmName("isLessThanNumber")
-fun CMField<out Number>.isLessThan(right: TypeExpression<NumberType>): LessThanExpression<NumberType> =
+fun CMJsonField<out Number>.isLessThan(right: TypeExpression<NumberType>): LessThanExpression<NumberType> =
     toDopeType().isLessThan(right)
 
 @JvmName("isLessThanNumber")
-fun CMField<out Number>.isLessThan(right: Number): LessThanExpression<NumberType> =
+fun CMJsonField<out Number>.isLessThan(right: Number): LessThanExpression<NumberType> =
     toDopeType().isLessThan(right.toDopeType())
 
+@JvmName("isLessThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> CMConverterField<Convertable, JsonType>.isLessThan(other: Convertable):
+    LessThanExpression<NumberType> = toDopeType().isLessThan(toDopeType(other))
+
+@JvmName("isLessThanNumberConverter")
+fun <Convertable : Any, JsonType : Number> Convertable.isLessThan(other: CMConverterField<Convertable, JsonType>):
+    LessThanExpression<NumberType> = toDopeType(other).isLessThan(other.toDopeType())
+
 @JvmName("isLessThanString")
-fun CMField<String>.isLessThan(right: CMField<String>): LessThanExpression<StringType> =
+fun CMJsonField<String>.isLessThan(right: CMJsonField<String>): LessThanExpression<StringType> =
     toDopeType().isLessThan(right.toDopeType())
 
 @JvmName("isLessThanString")
-fun TypeExpression<StringType>.isLessThan(right: CMField<String>): LessThanExpression<StringType> =
+fun TypeExpression<StringType>.isLessThan(right: CMJsonField<String>): LessThanExpression<StringType> =
     isLessThan(right.toDopeType())
 
 @JvmName("isLessThanString")
-fun String.isLessThan(right: CMField<String>): LessThanExpression<StringType> =
+fun String.isLessThan(right: CMJsonField<String>): LessThanExpression<StringType> =
     toDopeType().isLessThan(right.toDopeType())
 
 @JvmName("isLessThanString")
-fun CMField<String>.isLessThan(right: TypeExpression<StringType>): LessThanExpression<StringType> =
+fun CMJsonField<String>.isLessThan(right: TypeExpression<StringType>): LessThanExpression<StringType> =
     toDopeType().isLessThan(right)
 
 @JvmName("isLessThanString")
-fun CMField<String>.isLessThan(right: String): LessThanExpression<StringType> =
+fun CMJsonField<String>.isLessThan(right: String): LessThanExpression<StringType> =
     toDopeType().isLessThan(right.toDopeType())
+
+@JvmName("isLessThanStringConverter")
+fun <JsonType : Any> CMConverterField<JsonType, String>.isLessThan(other: JsonType): LessThanExpression<StringType> =
+    toDopeType().isLessThan(toDopeType(other))
+
+@JvmName("isLessThanStringConverter")
+fun <Convertable : Any> Convertable.isLessThan(other: CMConverterField<Convertable, String>): LessThanExpression<StringType> =
+    toDopeType(other).isLessThan(other.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Like.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Like.kt
index be89f6ba..dff0b612 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Like.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Like.kt
@@ -8,32 +8,32 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
-fun Field<out ValidType>.isLike(right: CMField<String>) = isLike(right.toDopeType())
+fun Field<out ValidType>.isLike(right: CMJsonField<String>) = isLike(right.toDopeType())
 
 @JvmName("isLikeNumber")
-fun CMField<out Number>.isLike(right: String) = toDopeType().isLike(right.toDopeType())
+fun CMJsonField<out Number>.isLike(right: String) = toDopeType().isLike(right.toDopeType())
 
 @JvmName("isLikeString")
-fun CMField<String>.isLike(right: String) = toDopeType().isLike(right.toDopeType())
+fun CMJsonField<String>.isLike(right: String) = toDopeType().isLike(right.toDopeType())
 
 @JvmName("isLikeString")
-fun CMField<String>.isLike(right: TypeExpression<StringType>) = toDopeType().isLike(right)
+fun CMJsonField<String>.isLike(right: TypeExpression<StringType>) = toDopeType().isLike(right)
 
 @JvmName("isLikeBoolean")
-fun CMField<Boolean>.isLike(right: String) = toDopeType().isLike(right.toDopeType())
+fun CMJsonField<Boolean>.isLike(right: String) = toDopeType().isLike(right.toDopeType())
 
-fun Field<out ValidType>.isNotLike(right: CMField<String>) = isNotLike(right.toDopeType())
+fun Field<out ValidType>.isNotLike(right: CMJsonField<String>) = isNotLike(right.toDopeType())
 
 @JvmName("isNotLikeNumber")
-fun CMField<out Number>.isNotLike(right: String) = toDopeType().isNotLike(right.toDopeType())
+fun CMJsonField<out Number>.isNotLike(right: String) = toDopeType().isNotLike(right.toDopeType())
 
 @JvmName("isNotLikeString")
-fun CMField<String>.isNotLike(right: String) = toDopeType().isNotLike(right.toDopeType())
+fun CMJsonField<String>.isNotLike(right: String) = toDopeType().isNotLike(right.toDopeType())
 
 @JvmName("isNotLikeString")
-fun CMField<String>.isNotLike(right: TypeExpression<StringType>) = toDopeType().isNotLike(right)
+fun CMJsonField<String>.isNotLike(right: TypeExpression<StringType>) = toDopeType().isNotLike(right)
 
 @JvmName("isNotLikeBoolean")
-fun CMField<Boolean>.isNotLike(right: String) = toDopeType().isNotLike(right.toDopeType())
+fun CMJsonField<Boolean>.isNotLike(right: String) = toDopeType().isNotLike(right.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/SatisfiesSchemaExpression.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/SatisfiesSchemaExpression.kt
index 6e6cba13..dae57ac8 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/SatisfiesSchemaExpression.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/SatisfiesSchemaExpression.kt
@@ -14,8 +14,8 @@ import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.DopeSchemaArray
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMObject
 import com.schwarz.crystalapi.schema.CMObjectList
 import com.schwarz.crystalapi.schema.CMType
@@ -42,8 +42,8 @@ class SchemaIterator<S : Schema>(val variable: String, val schema: S) {
         val schemaAttribute = schema.getCMType()
         val newPath = if (schemaAttribute.path.isBlank()) variable else "${schemaAttribute.path}`.`$variable"
         return when (schemaAttribute) {
-            is CMField<*> -> CMField<Any>(schemaAttribute.name, newPath) as A
-            is CMList<*> -> CMList<Any>(schemaAttribute.name, newPath) as A
+            is CMJsonField<*> -> CMJsonField<Any>(schemaAttribute.name, newPath) as A
+            is CMJsonList<*> -> CMJsonList<Any>(schemaAttribute.name, newPath) as A
             is CMObject<*> -> CMObject(schemaAttribute.element, newPath) as A
             is CMObjectList<*> -> CMObjectList(schemaAttribute.element, schemaAttribute.name, newPath) as A
             else -> error("Unsupported CMType: $schemaAttribute")
@@ -74,19 +74,19 @@ fun <S : Schema> CMObjectList<S>.any(
 ) = AnySatisfiesSchemaExpression(iteratorName, toDopeType(), predicate)
 
 @JvmName("anyNumber")
-fun CMList<Number>.any(
+fun CMJsonList<Number>.any(
     iteratorName: String? = null,
     predicate: (Iterator<NumberType>) -> TypeExpression<BooleanType>,
 ) = toDopeType().any(iteratorName, predicate)
 
 @JvmName("anyString")
-fun CMList<String>.any(
+fun CMJsonList<String>.any(
     iteratorName: String? = null,
     predicate: (Iterator<StringType>) -> TypeExpression<BooleanType>,
 ) = toDopeType().any(iteratorName, predicate)
 
 @JvmName("anyBoolean")
-fun CMList<Boolean>.any(
+fun CMJsonList<Boolean>.any(
     iteratorName: String? = null,
     predicate: (Iterator<BooleanType>) -> TypeExpression<BooleanType>,
 ) = toDopeType().any(iteratorName, predicate)
@@ -102,19 +102,19 @@ fun <S : Schema> CMObjectList<S>.every(
 ) = EverySatisfiesSchemaExpression(iteratorName, toDopeType(), predicate)
 
 @JvmName("everyNumber")
-fun CMList<Number>.every(
+fun CMJsonList<Number>.every(
     iteratorName: String? = null,
     predicate: (Iterator<NumberType>) -> TypeExpression<BooleanType>,
 ) = toDopeType().every(iteratorName, predicate)
 
 @JvmName("everyString")
-fun CMList<String>.every(
+fun CMJsonList<String>.every(
     iteratorName: String? = null,
     predicate: (Iterator<StringType>) -> TypeExpression<BooleanType>,
 ) = toDopeType().every(iteratorName, predicate)
 
 @JvmName("everyBoolean")
-fun CMList<Boolean>.every(
+fun CMJsonList<Boolean>.every(
     iteratorName: String? = null,
     predicate: (Iterator<BooleanType>) -> TypeExpression<BooleanType>,
 ) = toDopeType().every(iteratorName, predicate)
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Within.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Within.kt
index 9c8e12cd..b2b92f33 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Within.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/relational/Within.kt
@@ -11,125 +11,138 @@ import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMConverterList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("withinNumberArray")
-fun CMField<out Number>.withinArray(array: TypeExpression<ArrayType<NumberType>>): WithinExpression<NumberType> =
+fun CMJsonField<out Number>.withinArray(array: TypeExpression<ArrayType<NumberType>>): WithinExpression<NumberType> =
     toDopeType().withinArray(array)
 
 @JvmName("withinStringArray")
-fun CMField<String>.withinArray(array: TypeExpression<ArrayType<StringType>>): WithinExpression<StringType> =
+fun CMJsonField<String>.withinArray(array: TypeExpression<ArrayType<StringType>>): WithinExpression<StringType> =
     toDopeType().withinArray(array)
 
 @JvmName("withinBooleanArray")
-fun CMField<Boolean>.withinArray(array: TypeExpression<ArrayType<BooleanType>>): WithinExpression<BooleanType> =
+fun CMJsonField<Boolean>.withinArray(array: TypeExpression<ArrayType<BooleanType>>): WithinExpression<BooleanType> =
     toDopeType().withinArray(array)
 
 @JvmName("withinNumberArray")
-fun TypeExpression<NumberType>.withinArray(array: CMList<out Number>): WithinExpression<NumberType> =
-    this.withinArray(array.toDopeType())
+fun TypeExpression<NumberType>.withinArray(array: CMJsonList<out Number>): WithinExpression<NumberType> =
+    withinArray(array.toDopeType())
 
 @JvmName("withinStringArray")
-fun TypeExpression<StringType>.withinArray(array: CMList<String>): WithinExpression<StringType> =
-    this.withinArray(array.toDopeType())
+fun TypeExpression<StringType>.withinArray(array: CMJsonList<String>): WithinExpression<StringType> =
+    withinArray(array.toDopeType())
 
 @JvmName("withinBooleanArray")
-fun TypeExpression<BooleanType>.withinArray(array: CMList<Boolean>): WithinExpression<BooleanType> =
-    this.withinArray(array.toDopeType())
+fun TypeExpression<BooleanType>.withinArray(array: CMJsonList<Boolean>): WithinExpression<BooleanType> =
+    withinArray(array.toDopeType())
 
 @JvmName("withinNumberArray")
-fun CMField<out Number>.withinArray(array: CMList<out Number>): WithinExpression<NumberType> =
+fun CMJsonField<out Number>.withinArray(array: CMJsonList<out Number>): WithinExpression<NumberType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinStringArray")
-fun CMField<String>.withinArray(array: CMList<String>): WithinExpression<StringType> =
+fun CMJsonField<String>.withinArray(array: CMJsonList<String>): WithinExpression<StringType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinBooleanArray")
-fun CMField<Boolean>.withinArray(array: CMList<Boolean>): WithinExpression<BooleanType> =
+fun CMJsonField<Boolean>.withinArray(array: CMJsonList<Boolean>): WithinExpression<BooleanType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinNumberArray")
-fun CMField<out Number>.withinArray(array: Collection<TypeExpression<NumberType>>): WithinExpression<NumberType> =
+fun CMJsonField<out Number>.withinArray(array: Collection<TypeExpression<NumberType>>): WithinExpression<NumberType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinStringArray")
-fun CMField<String>.withinArray(array: Collection<TypeExpression<StringType>>): WithinExpression<StringType> =
+fun CMJsonField<String>.withinArray(array: Collection<TypeExpression<StringType>>): WithinExpression<StringType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinBooleanArray")
-fun CMField<Boolean>.withinArray(array: Collection<TypeExpression<BooleanType>>): WithinExpression<BooleanType> =
+fun CMJsonField<Boolean>.withinArray(array: Collection<TypeExpression<BooleanType>>): WithinExpression<BooleanType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinNumberArray")
-fun Number.withinArray(array: CMList<out Number>): WithinExpression<NumberType> =
+fun Number.withinArray(array: CMJsonList<out Number>): WithinExpression<NumberType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinStringArray")
-fun String.withinArray(array: CMList<String>): WithinExpression<StringType> =
+fun String.withinArray(array: CMJsonList<String>): WithinExpression<StringType> =
     toDopeType().withinArray(array.toDopeType())
 
 @JvmName("withinBooleanArray")
-fun Boolean.withinArray(array: CMList<Boolean>): WithinExpression<BooleanType> =
+fun Boolean.withinArray(array: CMJsonList<Boolean>): WithinExpression<BooleanType> =
     toDopeType().withinArray(array.toDopeType())
 
+@JvmName("withinArrayNumberConverter")
+fun <Convertable : Any, JsonType : Number> Convertable.withinArray(array: CMConverterList<Convertable, JsonType>): WithinExpression<NumberType> =
+    toDopeType(array).withinArray(array.toDopeType())
+
+@JvmName("withinArrayStringConverter")
+fun <Convertable : Any> Convertable.withinArray(array: CMConverterList<Convertable, String>): WithinExpression<StringType> =
+    toDopeType(array).withinArray(array.toDopeType())
+
+@JvmName("withinArrayBooleanConverter")
+fun <Convertable : Any> Convertable.withinArray(array: CMConverterList<Convertable, Boolean>): WithinExpression<BooleanType> =
+    toDopeType(array).withinArray(array.toDopeType())
+
 @JvmName("notWithinNumberArray")
-fun CMField<out Number>.notWithinArray(array: TypeExpression<ArrayType<NumberType>>): NotWithinExpression<NumberType> =
+fun CMJsonField<out Number>.notWithinArray(array: TypeExpression<ArrayType<NumberType>>): NotWithinExpression<NumberType> =
     toDopeType().notWithinArray(array)
 
 @JvmName("notWithinStringArray")
-fun CMField<String>.notWithinArray(array: TypeExpression<ArrayType<StringType>>): NotWithinExpression<StringType> =
+fun CMJsonField<String>.notWithinArray(array: TypeExpression<ArrayType<StringType>>): NotWithinExpression<StringType> =
     toDopeType().notWithinArray(array)
 
 @JvmName("notWithinBooleanArray")
-fun CMField<Boolean>.notWithinArray(array: TypeExpression<ArrayType<BooleanType>>): NotWithinExpression<BooleanType> =
+fun CMJsonField<Boolean>.notWithinArray(array: TypeExpression<ArrayType<BooleanType>>): NotWithinExpression<BooleanType> =
     toDopeType().notWithinArray(array)
 
 @JvmName("notWithinNumberArray")
-fun TypeExpression<NumberType>.notWithinArray(array: CMList<out Number>): NotWithinExpression<NumberType> =
+fun TypeExpression<NumberType>.notWithinArray(array: CMJsonList<out Number>): NotWithinExpression<NumberType> =
     this.notWithinArray(array.toDopeType())
 
 @JvmName("notWithinStringArray")
-fun TypeExpression<StringType>.notWithinArray(array: CMList<String>): NotWithinExpression<StringType> =
+fun TypeExpression<StringType>.notWithinArray(array: CMJsonList<String>): NotWithinExpression<StringType> =
     this.notWithinArray(array.toDopeType())
 
 @JvmName("notWithinBooleanArray")
-fun TypeExpression<BooleanType>.notWithinArray(array: CMList<Boolean>): NotWithinExpression<BooleanType> =
+fun TypeExpression<BooleanType>.notWithinArray(array: CMJsonList<Boolean>): NotWithinExpression<BooleanType> =
     this.notWithinArray(array.toDopeType())
 
 @JvmName("notWithinNumberArray")
-fun CMField<out Number>.notWithinArray(array: CMList<out Number>): NotWithinExpression<NumberType> =
+fun CMJsonField<out Number>.notWithinArray(array: CMJsonList<out Number>): NotWithinExpression<NumberType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinStringArray")
-fun CMField<String>.notWithinArray(array: CMList<String>): NotWithinExpression<StringType> =
+fun CMJsonField<String>.notWithinArray(array: CMJsonList<String>): NotWithinExpression<StringType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinBooleanArray")
-fun CMField<Boolean>.notWithinArray(array: CMList<Boolean>): NotWithinExpression<BooleanType> =
+fun CMJsonField<Boolean>.notWithinArray(array: CMJsonList<Boolean>): NotWithinExpression<BooleanType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinNumberArray")
-fun CMField<out Number>.notWithinArray(array: Collection<TypeExpression<NumberType>>): NotWithinExpression<NumberType> =
+fun CMJsonField<out Number>.notWithinArray(array: Collection<TypeExpression<NumberType>>): NotWithinExpression<NumberType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinStringArray")
-fun CMField<String>.notWithinArray(array: Collection<TypeExpression<StringType>>): NotWithinExpression<StringType> =
+fun CMJsonField<String>.notWithinArray(array: Collection<TypeExpression<StringType>>): NotWithinExpression<StringType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinBooleanArray")
-fun CMField<Boolean>.notWithinArray(array: Collection<TypeExpression<BooleanType>>): NotWithinExpression<BooleanType> =
+fun CMJsonField<Boolean>.notWithinArray(array: Collection<TypeExpression<BooleanType>>): NotWithinExpression<BooleanType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinNumberArray")
-fun Number.notWithinArray(array: CMList<out Number>): NotWithinExpression<NumberType> =
+fun Number.notWithinArray(array: CMJsonList<out Number>): NotWithinExpression<NumberType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinStringArray")
-fun String.notWithinArray(array: CMList<String>): NotWithinExpression<StringType> =
+fun String.notWithinArray(array: CMJsonList<String>): NotWithinExpression<StringType> =
     toDopeType().notWithinArray(array.toDopeType())
 
 @JvmName("notWithinBooleanArray")
-fun Boolean.notWithinArray(array: CMList<Boolean>): NotWithinExpression<BooleanType> =
+fun Boolean.notWithinArray(array: CMJsonList<Boolean>): NotWithinExpression<BooleanType> =
     toDopeType().notWithinArray(array.toDopeType())
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsArray.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsArray.kt
index 2acd8e42..465107b4 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsArray.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsArray.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.isArray
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberIsArray")
-fun CMField<out Number>.isArray() = toDopeType().isArray()
+fun CMJsonField<out Number>.isArray() = toDopeType().isArray()
 
 @JvmName("stringIsArray")
-fun CMField<String>.isArray() = toDopeType().isArray()
+fun CMJsonField<String>.isArray() = toDopeType().isArray()
 
 @JvmName("booleanIsArray")
-fun CMField<Boolean>.isArray() = toDopeType().isArray()
+fun CMJsonField<Boolean>.isArray() = toDopeType().isArray()
 
 @JvmName("numberListIsArray")
-fun CMList<out Number>.isArray() = toDopeType().isArray()
+fun CMJsonList<out Number>.isArray() = toDopeType().isArray()
 
 @JvmName("stringListIsArray")
-fun CMList<String>.isArray() = toDopeType().isArray()
+fun CMJsonList<String>.isArray() = toDopeType().isArray()
 
 @JvmName("booleanListIsArray")
-fun CMList<Boolean>.isArray() = toDopeType().isArray()
+fun CMJsonList<Boolean>.isArray() = toDopeType().isArray()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsAtom.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsAtom.kt
index 02dab37c..21c1639c 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsAtom.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsAtom.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.isAtom
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberIsAtom")
-fun CMField<out Number>.isAtom() = toDopeType().isAtom()
+fun CMJsonField<out Number>.isAtom() = toDopeType().isAtom()
 
 @JvmName("stringIsAtom")
-fun CMField<String>.isAtom() = toDopeType().isAtom()
+fun CMJsonField<String>.isAtom() = toDopeType().isAtom()
 
 @JvmName("booleanIsAtom")
-fun CMField<Boolean>.isAtom() = toDopeType().isAtom()
+fun CMJsonField<Boolean>.isAtom() = toDopeType().isAtom()
 
 @JvmName("numberListIsAtom")
-fun CMList<out Number>.isAtom() = toDopeType().isAtom()
+fun CMJsonList<out Number>.isAtom() = toDopeType().isAtom()
 
 @JvmName("stringListIsAtom")
-fun CMList<String>.isAtom() = toDopeType().isAtom()
+fun CMJsonList<String>.isAtom() = toDopeType().isAtom()
 
 @JvmName("booleanListIsAtom")
-fun CMList<Boolean>.isAtom() = toDopeType().isAtom()
+fun CMJsonList<Boolean>.isAtom() = toDopeType().isAtom()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsBoolean.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsBoolean.kt
index 0e33c746..928a1adb 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsBoolean.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsBoolean.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.isBoolean
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberIsBoolean")
-fun CMField<out Number>.isBoolean() = toDopeType().isBoolean()
+fun CMJsonField<out Number>.isBoolean() = toDopeType().isBoolean()
 
 @JvmName("stringIsBoolean")
-fun CMField<String>.isBoolean() = toDopeType().isBoolean()
+fun CMJsonField<String>.isBoolean() = toDopeType().isBoolean()
 
 @JvmName("booleanIsBoolean")
-fun CMField<Boolean>.isBoolean() = toDopeType().isBoolean()
+fun CMJsonField<Boolean>.isBoolean() = toDopeType().isBoolean()
 
 @JvmName("numberListIsBoolean")
-fun CMList<out Number>.isBoolean() = toDopeType().isBoolean()
+fun CMJsonList<out Number>.isBoolean() = toDopeType().isBoolean()
 
 @JvmName("stringListIsBoolean")
-fun CMList<String>.isBoolean() = toDopeType().isBoolean()
+fun CMJsonList<String>.isBoolean() = toDopeType().isBoolean()
 
 @JvmName("booleanListIsBoolean")
-fun CMList<Boolean>.isBoolean() = toDopeType().isBoolean()
+fun CMJsonList<Boolean>.isBoolean() = toDopeType().isBoolean()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsNumber.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsNumber.kt
index 4062cdb3..1df9e5aa 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsNumber.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsNumber.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.isNumber
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberIsNumber")
-fun CMField<out Number>.isNumber() = toDopeType().isNumber()
+fun CMJsonField<out Number>.isNumber() = toDopeType().isNumber()
 
 @JvmName("stringIsNumber")
-fun CMField<String>.isNumber() = toDopeType().isNumber()
+fun CMJsonField<String>.isNumber() = toDopeType().isNumber()
 
 @JvmName("booleanIsNumber")
-fun CMField<Boolean>.isNumber() = toDopeType().isNumber()
+fun CMJsonField<Boolean>.isNumber() = toDopeType().isNumber()
 
 @JvmName("numberListIsNumber")
-fun CMList<out Number>.isNumber() = toDopeType().isNumber()
+fun CMJsonList<out Number>.isNumber() = toDopeType().isNumber()
 
 @JvmName("stringListIsNumber")
-fun CMList<String>.isNumber() = toDopeType().isNumber()
+fun CMJsonList<String>.isNumber() = toDopeType().isNumber()
 
 @JvmName("booleanListIsNumber")
-fun CMList<Boolean>.isNumber() = toDopeType().isNumber()
+fun CMJsonList<Boolean>.isNumber() = toDopeType().isNumber()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsString.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsString.kt
index 87326a50..93bbe04a 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsString.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/IsString.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.isString
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberIsString")
-fun CMField<out Number>.isString() = toDopeType().isString()
+fun CMJsonField<out Number>.isString() = toDopeType().isString()
 
 @JvmName("stringIsString")
-fun CMField<String>.isString() = toDopeType().isString()
+fun CMJsonField<String>.isString() = toDopeType().isString()
 
 @JvmName("booleanIsString")
-fun CMField<Boolean>.isString() = toDopeType().isString()
+fun CMJsonField<Boolean>.isString() = toDopeType().isString()
 
 @JvmName("numberListIsString")
-fun CMList<out Number>.isString() = toDopeType().isString()
+fun CMJsonList<out Number>.isString() = toDopeType().isString()
 
 @JvmName("stringListIsString")
-fun CMList<String>.isString() = toDopeType().isString()
+fun CMJsonList<String>.isString() = toDopeType().isString()
 
 @JvmName("booleanListIsString")
-fun CMList<Boolean>.isString() = toDopeType().isString()
+fun CMJsonList<Boolean>.isString() = toDopeType().isString()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToArray.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToArray.kt
index 3942377d..8b4ccf69 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToArray.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToArray.kt
@@ -2,13 +2,13 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.toArray
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMJsonField
 
 @JvmName("numberToArray")
-fun CMField<out Number>.toArray() = toDopeType().toArray()
+fun CMJsonField<out Number>.toArray() = toDopeType().toArray()
 
 @JvmName("stringToArray")
-fun CMField<String>.toArray() = toDopeType().toArray()
+fun CMJsonField<String>.toArray() = toDopeType().toArray()
 
 @JvmName("booleanToArray")
-fun CMField<Boolean>.toArray() = toDopeType().toArray()
+fun CMJsonField<Boolean>.toArray() = toDopeType().toArray()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToBoolean.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToBoolean.kt
index 46ef1ce0..517b41b4 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToBoolean.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToBoolean.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.toBool
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberToBoolean")
-fun CMField<out Number>.toBool() = toDopeType().toBool()
+fun CMJsonField<out Number>.toBool() = toDopeType().toBool()
 
 @JvmName("stringToBoolean")
-fun CMField<String>.toBool() = toDopeType().toBool()
+fun CMJsonField<String>.toBool() = toDopeType().toBool()
 
 @JvmName("booleanToBoolean")
-fun CMField<Boolean>.toBool() = toDopeType().toBool()
+fun CMJsonField<Boolean>.toBool() = toDopeType().toBool()
 
 @JvmName("numberListToBoolean")
-fun CMList<out Number>.toBool() = toDopeType().toBool()
+fun CMJsonList<out Number>.toBool() = toDopeType().toBool()
 
 @JvmName("stringListToBoolean")
-fun CMList<String>.toBool() = toDopeType().toBool()
+fun CMJsonList<String>.toBool() = toDopeType().toBool()
 
 @JvmName("booleanListToBoolean")
-fun CMList<Boolean>.toBool() = toDopeType().toBool()
+fun CMJsonList<Boolean>.toBool() = toDopeType().toBool()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToNumber.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToNumber.kt
index c7e0c6c9..f553bde0 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToNumber.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToNumber.kt
@@ -5,38 +5,38 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.toDopeType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberToNumber")
-fun CMField<out Number>.toNumber() = toDopeType().toNumber()
+fun CMJsonField<out Number>.toNumber() = toDopeType().toNumber()
 
 @JvmName("stringToNumber")
-fun CMField<String>.toNumber() = toDopeType().toNumber()
+fun CMJsonField<String>.toNumber() = toDopeType().toNumber()
 
 @JvmName("stringToNumber")
-fun CMField<String>.toNumber(filterChars: String) = toDopeType().toNumber(filterChars.toDopeType())
+fun CMJsonField<String>.toNumber(filterChars: String) = toDopeType().toNumber(filterChars.toDopeType())
 
 @JvmName("stringToNumber")
-fun CMField<String>.toNumber(filterChars: TypeExpression<StringType>) = toDopeType().toNumber(filterChars)
+fun CMJsonField<String>.toNumber(filterChars: TypeExpression<StringType>) = toDopeType().toNumber(filterChars)
 
 @JvmName("stringToNumber")
-fun String.toNumber(filterChars: CMField<String>) = toDopeType().toNumber(filterChars.toDopeType())
+fun String.toNumber(filterChars: CMJsonField<String>) = toDopeType().toNumber(filterChars.toDopeType())
 
 @JvmName("stringToNumber")
-fun TypeExpression<StringType>.toNumber(filterChars: CMField<String>) = toNumber(filterChars.toDopeType())
+fun TypeExpression<StringType>.toNumber(filterChars: CMJsonField<String>) = toNumber(filterChars.toDopeType())
 
 @JvmName("stringToNumber")
-fun CMField<String>.toNumber(filterChars: CMField<String>) = toDopeType().toNumber(filterChars.toDopeType())
+fun CMJsonField<String>.toNumber(filterChars: CMJsonField<String>) = toDopeType().toNumber(filterChars.toDopeType())
 
 @JvmName("booleanToNumber")
-fun CMField<Boolean>.toNumber() = toDopeType().toNumber()
+fun CMJsonField<Boolean>.toNumber() = toDopeType().toNumber()
 
 @JvmName("numberListToNumber")
-fun CMList<out Number>.toNumber() = toDopeType().toNumber()
+fun CMJsonList<out Number>.toNumber() = toDopeType().toNumber()
 
 @JvmName("stringListToNumber")
-fun CMList<String>.toNumber() = toDopeType().toNumber()
+fun CMJsonList<String>.toNumber() = toDopeType().toNumber()
 
 @JvmName("booleanListToNumber")
-fun CMList<Boolean>.toNumber() = toDopeType().toNumber()
+fun CMJsonList<Boolean>.toNumber() = toDopeType().toNumber()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToString.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToString.kt
index 1089e3c9..6830b03a 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToString.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/ToString.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.toStr
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("numberToString")
-fun CMField<out Number>.toStr() = toDopeType().toStr()
+fun CMJsonField<out Number>.toStr() = toDopeType().toStr()
 
 @JvmName("stringToString")
-fun CMField<String>.toStr() = toDopeType().toStr()
+fun CMJsonField<String>.toStr() = toDopeType().toStr()
 
 @JvmName("booleanToString")
-fun CMField<Boolean>.toStr() = toDopeType().toStr()
+fun CMJsonField<Boolean>.toStr() = toDopeType().toStr()
 
 @JvmName("toStringNumberList")
-fun CMList<out Number>.toStr() = toDopeType().toStr()
+fun CMJsonList<out Number>.toStr() = toDopeType().toStr()
 
 @JvmName("toStringStringList")
-fun CMList<String>.toStr() = toDopeType().toStr()
+fun CMJsonList<String>.toStr() = toDopeType().toStr()
 
 @JvmName("toStringBooleanList")
-fun CMList<Boolean>.toStr() = toDopeType().toStr()
+fun CMJsonList<Boolean>.toStr() = toDopeType().toStr()
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/TypeOf.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/TypeOf.kt
index bb4ba9d0..cf3dfe8e 100644
--- a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/TypeOf.kt
+++ b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/type/typefunction/TypeOf.kt
@@ -2,23 +2,23 @@ package ch.ergon.dope.extension.type.typefunction
 
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.typefunction.typeOf
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 
 @JvmName("typeOfNumber")
-fun typeOf(field: CMField<out Number>) = typeOf(field.toDopeType())
+fun typeOf(field: CMJsonField<out Number>) = typeOf(field.toDopeType())
 
 @JvmName("typeOfString")
-fun typeOf(field: CMField<String>) = typeOf(field.toDopeType())
+fun typeOf(field: CMJsonField<String>) = typeOf(field.toDopeType())
 
 @JvmName("typeOfBoolean")
-fun typeOf(field: CMField<Boolean>) = typeOf(field.toDopeType())
+fun typeOf(field: CMJsonField<Boolean>) = typeOf(field.toDopeType())
 
 @JvmName("typeOfNumberList")
-fun typeOf(field: CMList<out Number>) = typeOf(field.toDopeType())
+fun typeOf(field: CMJsonList<out Number>) = typeOf(field.toDopeType())
 
 @JvmName("typeOfStringList")
-fun typeOf(field: CMList<String>) = typeOf(field.toDopeType())
+fun typeOf(field: CMJsonList<String>) = typeOf(field.toDopeType())
 
 @JvmName("typeOfBooleanList")
-fun typeOf(field: CMList<Boolean>) = typeOf(field.toDopeType())
+fun typeOf(field: CMJsonList<Boolean>) = typeOf(field.toDopeType())
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/CrystalMapAdapterTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/CrystalMapAdapterTest.kt
index 5985a7c8..e7623f7a 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/CrystalMapAdapterTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/CrystalMapAdapterTest.kt
@@ -1,13 +1,16 @@
 package ch.ergon.dope
 
 import ch.ergon.dope.helper.ManagerDependentTest
+import ch.ergon.dope.helper.someCorruptField
+import ch.ergon.dope.helper.someString
 import ch.ergon.dope.resolvable.expression.unaliased.type.Field
 import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
+import org.junit.jupiter.api.assertThrows
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -15,56 +18,66 @@ class CrystalMapAdapterTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should convert CMField with Number`() {
-        val cmField = CMField<Number>("testName", "testPath")
+    fun `should convert CMJsonField with Number`() {
+        val cmJsonField = CMJsonField<Number>("testName", "testPath")
 
-        val actual: Field<NumberType> = cmField.toDopeType()
+        val actual: Field<NumberType> = cmJsonField.toDopeType()
 
-        assertEquals("`${cmField.path}`.`${cmField.name}`", actual.toDopeQuery(manager).queryString)
+        assertEquals("`${cmJsonField.path}`.`${cmJsonField.name}`", actual.toDopeQuery(manager).queryString)
     }
 
     @Test
-    fun `should convert CMField with String`() {
-        val cmField = CMField<String>("testName", "testPath")
+    fun `should convert CMJsonField with String`() {
+        val cmJsonField = CMJsonField<String>("testName", "testPath")
 
-        val actual: Field<StringType> = cmField.toDopeType()
+        val actual: Field<StringType> = cmJsonField.toDopeType()
 
-        assertEquals("`${cmField.path}`.`${cmField.name}`", actual.toDopeQuery(manager).queryString)
+        assertEquals("`${cmJsonField.path}`.`${cmJsonField.name}`", actual.toDopeQuery(manager).queryString)
     }
 
     @Test
-    fun `should convert CMField with Boolean`() {
-        val cmField = CMField<Boolean>("testName", "testPath")
+    fun `should convert CMJsonField with Boolean`() {
+        val cmJsonField = CMJsonField<Boolean>("testName", "testPath")
 
-        val actual: Field<BooleanType> = cmField.toDopeType()
+        val actual: Field<BooleanType> = cmJsonField.toDopeType()
 
-        assertEquals("`${cmField.path}`.`${cmField.name}`", actual.toDopeQuery(manager).queryString)
+        assertEquals("`${cmJsonField.path}`.`${cmJsonField.name}`", actual.toDopeQuery(manager).queryString)
     }
 
     @Test
-    fun `should convert CMList string`() {
-        val cmList = CMList<String>("testName", "testPath")
+    fun `should convert CMJsonList string`() {
+        val cmJsonList = CMJsonList<String>("testName", "testPath")
 
-        val actual: Field<ArrayType<StringType>> = cmList.toDopeType()
+        val actual: Field<ArrayType<StringType>> = cmJsonList.toDopeType()
 
-        assertEquals("`${cmList.path}`.`${cmList.name}`", actual.toDopeQuery(manager).queryString)
+        assertEquals("`${cmJsonList.path}`.`${cmJsonList.name}`", actual.toDopeQuery(manager).queryString)
     }
 
     @Test
-    fun `should convert CMList number`() {
-        val cmList = CMList<Number>("testName", "testPath")
+    fun `should convert CMJsonList number`() {
+        val cmJsonList = CMJsonList<Number>("testName", "testPath")
 
-        val actual: Field<ArrayType<NumberType>> = cmList.toDopeType()
+        val actual: Field<ArrayType<NumberType>> = cmJsonList.toDopeType()
 
-        assertEquals("`${cmList.path}`.`${cmList.name}`", actual.toDopeQuery(manager).queryString)
+        assertEquals("`${cmJsonList.path}`.`${cmJsonList.name}`", actual.toDopeQuery(manager).queryString)
     }
 
     @Test
-    fun `should convert CMList boolean`() {
-        val cmList = CMList<Boolean>("testName", "testPath")
+    fun `should convert CMJsonList boolean`() {
+        val cmJsonList = CMJsonList<Boolean>("testName", "testPath")
 
-        val actual: Field<ArrayType<BooleanType>> = cmList.toDopeType()
+        val actual: Field<ArrayType<BooleanType>> = cmJsonList.toDopeType()
 
-        assertEquals("`${cmList.path}`.`${cmList.name}`", actual.toDopeQuery(manager).queryString)
+        assertEquals("`${cmJsonList.path}`.`${cmJsonList.name}`", actual.toDopeQuery(manager).queryString)
+    }
+
+    @Test
+    fun `should throw exception when resolving corrupt field`() {
+        val string = someString()
+        val corruptField = someCorruptField()
+
+        assertThrows<IllegalArgumentException> {
+            string.toDopeType(corruptField)
+        }
     }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/ArrayAggTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/ArrayAggTest.kt
index e45b93a9..ee2ea7f7 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/ArrayAggTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/ArrayAggTest.kt
@@ -19,7 +19,7 @@ class ArrayAggTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support array_agg with CMField Number`() {
+    fun `should support array_agg with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -30,7 +30,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMField Number and type`() {
+    fun `should support array_agg with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -41,7 +41,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMField string`() {
+    fun `should support array_agg with CMJsonField string`() {
         val field = someCMStringField()
         val quantifier = null
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -52,7 +52,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMField string and type`() {
+    fun `should support array_agg with CMJsonField string and type`() {
         val field = someCMStringField()
         val quantifier = ALL
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -63,7 +63,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMField boolean`() {
+    fun `should support array_agg with CMJsonField boolean`() {
         val field = someCMBooleanField()
         val quantifier = null
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -74,7 +74,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMField boolean and type`() {
+    fun `should support array_agg with CMJsonField boolean and type`() {
         val field = someCMBooleanField()
         val quantifier = ALL
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -85,7 +85,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMList Number`() {
+    fun `should support array_agg with CMJsonList Number`() {
         val field = someCMNumberList()
         val quantifier = null
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -96,7 +96,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMList Number and type`() {
+    fun `should support array_agg with CMJsonList Number and type`() {
         val field = someCMNumberList()
         val quantifier = ALL
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -107,7 +107,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMList string`() {
+    fun `should support array_agg with CMJsonList string`() {
         val field = someCMStringList()
         val quantifier = null
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -118,7 +118,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMList string and type`() {
+    fun `should support array_agg with CMJsonList string and type`() {
         val field = someCMStringList()
         val quantifier = ALL
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -129,7 +129,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMList Boolean`() {
+    fun `should support array_agg with CMJsonList Boolean`() {
         val field = someCMBooleanList()
         val quantifier = null
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
@@ -140,7 +140,7 @@ class ArrayAggTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support array_agg with CMList Boolean and type`() {
+    fun `should support array_agg with CMJsonList Boolean and type`() {
         val field = someCMBooleanList()
         val quantifier = ALL
         val expected = ArrayAggregateExpression(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/CountTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/CountTest.kt
index b4bd4858..24bad4d9 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/CountTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/CountTest.kt
@@ -19,7 +19,7 @@ class CountTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support count with CMField Number`() {
+    fun `should support count with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -30,7 +30,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMField Number and type`() {
+    fun `should support count with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -41,7 +41,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMField string`() {
+    fun `should support count with CMJsonField string`() {
         val field = someCMStringField()
         val quantifier = null
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -52,7 +52,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMField string and type`() {
+    fun `should support count with CMJsonField string and type`() {
         val field = someCMStringField()
         val quantifier = ALL
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -63,7 +63,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMField boolean`() {
+    fun `should support count with CMJsonField boolean`() {
         val field = someCMBooleanField()
         val quantifier = null
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -74,7 +74,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMField boolean and type`() {
+    fun `should support count with CMJsonField boolean and type`() {
         val field = someCMBooleanField()
         val quantifier = ALL
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -85,7 +85,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMList Number`() {
+    fun `should support count with CMJsonList Number`() {
         val field = someCMNumberList()
         val quantifier = null
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -96,7 +96,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMList Number and type`() {
+    fun `should support count with CMJsonList Number and type`() {
         val field = someCMNumberList()
         val quantifier = ALL
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -107,7 +107,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMList string`() {
+    fun `should support count with CMJsonList string`() {
         val field = someCMStringList()
         val quantifier = null
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -118,7 +118,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMList string and type`() {
+    fun `should support count with CMJsonList string and type`() {
         val field = someCMStringList()
         val quantifier = ALL
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -129,7 +129,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMList Boolean`() {
+    fun `should support count with CMJsonList Boolean`() {
         val field = someCMBooleanList()
         val quantifier = null
         val expected = CountExpression(field.toDopeType(), quantifier)
@@ -140,7 +140,7 @@ class CountTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support count with CMList Boolean and type`() {
+    fun `should support count with CMJsonList Boolean and type`() {
         val field = someCMBooleanList()
         val quantifier = ALL
         val expected = CountExpression(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MaxTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MaxTest.kt
index 89832511..08278fdf 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MaxTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MaxTest.kt
@@ -19,7 +19,7 @@ class MaxTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support max with CMField Number`() {
+    fun `should support max with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -30,7 +30,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMField Number and type`() {
+    fun `should support max with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -41,7 +41,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMField string`() {
+    fun `should support max with CMJsonField string`() {
         val field = someCMStringField()
         val quantifier = null
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -52,7 +52,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMField string and type`() {
+    fun `should support max with CMJsonField string and type`() {
         val field = someCMStringField()
         val quantifier = ALL
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -63,7 +63,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMField boolean`() {
+    fun `should support max with CMJsonField boolean`() {
         val field = someCMBooleanField()
         val quantifier = null
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -74,7 +74,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMField boolean and type`() {
+    fun `should support max with CMJsonField boolean and type`() {
         val field = someCMBooleanField()
         val quantifier = ALL
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -85,7 +85,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMList Number`() {
+    fun `should support max with CMJsonList Number`() {
         val field = someCMNumberList()
         val quantifier = null
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -96,7 +96,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMList Number and type`() {
+    fun `should support max with CMJsonList Number and type`() {
         val field = someCMNumberList()
         val quantifier = ALL
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -107,7 +107,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMList string`() {
+    fun `should support max with CMJsonList string`() {
         val field = someCMStringList()
         val quantifier = null
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -118,7 +118,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMList string and type`() {
+    fun `should support max with CMJsonList string and type`() {
         val field = someCMStringList()
         val quantifier = ALL
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -129,7 +129,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMList Boolean`() {
+    fun `should support max with CMJsonList Boolean`() {
         val field = someCMBooleanList()
         val quantifier = null
         val expected = MaxExpression(field.toDopeType(), quantifier)
@@ -140,7 +140,7 @@ class MaxTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support max with CMList Boolean and type`() {
+    fun `should support max with CMJsonList Boolean and type`() {
         val field = someCMBooleanList()
         val quantifier = ALL
         val expected = MaxExpression(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MinTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MinTest.kt
index f5f81a26..f5d77659 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MinTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MinTest.kt
@@ -19,7 +19,7 @@ class MinTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support min with CMField Number`() {
+    fun `should support min with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -30,7 +30,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMField Number and type`() {
+    fun `should support min with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -41,7 +41,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMField string`() {
+    fun `should support min with CMJsonField string`() {
         val field = someCMStringField()
         val quantifier = null
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -52,7 +52,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMField string and type`() {
+    fun `should support min with CMJsonField string and type`() {
         val field = someCMStringField()
         val quantifier = ALL
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -63,7 +63,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMField boolean`() {
+    fun `should support min with CMJsonField boolean`() {
         val field = someCMBooleanField()
         val quantifier = null
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -74,7 +74,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMField boolean and type`() {
+    fun `should support min with CMJsonField boolean and type`() {
         val field = someCMBooleanField()
         val quantifier = ALL
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -85,7 +85,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMList Number`() {
+    fun `should support min with CMJsonList Number`() {
         val field = someCMNumberList()
         val quantifier = null
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -96,7 +96,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMList Number and type`() {
+    fun `should support min with CMJsonList Number and type`() {
         val field = someCMNumberList()
         val quantifier = ALL
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -107,7 +107,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMList string`() {
+    fun `should support min with CMJsonList string`() {
         val field = someCMStringList()
         val quantifier = null
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -118,7 +118,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMList string and type`() {
+    fun `should support min with CMJsonList string and type`() {
         val field = someCMStringList()
         val quantifier = ALL
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -129,7 +129,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMList Boolean`() {
+    fun `should support min with CMJsonList Boolean`() {
         val field = someCMBooleanList()
         val quantifier = null
         val expected = MinExpression(field.toDopeType(), quantifier)
@@ -140,7 +140,7 @@ class MinTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support min with CMList Boolean and type`() {
+    fun `should support min with CMJsonList Boolean and type`() {
         val field = someCMBooleanList()
         val quantifier = ALL
         val expected = MinExpression(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/NumberAggregateTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/NumberAggregateTest.kt
index 02f3d82d..77ed2a04 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/NumberAggregateTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/NumberAggregateTest.kt
@@ -24,7 +24,7 @@ class NumberAggregateTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support avg with CMField Number`() {
+    fun `should support avg with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = AverageExpression(field.toDopeType(), quantifier)
@@ -35,7 +35,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support avg with CMField Number and type`() {
+    fun `should support avg with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = AverageExpression(field.toDopeType(), quantifier)
@@ -46,7 +46,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mean with CMField Number`() {
+    fun `should support mean with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = MeanExpression(field.toDopeType(), quantifier)
@@ -57,7 +57,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mean with CMField Number and type`() {
+    fun `should support mean with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = MeanExpression(field.toDopeType(), quantifier)
@@ -68,7 +68,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support median with CMField Number`() {
+    fun `should support median with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = MedianExpression(field.toDopeType(), quantifier)
@@ -79,7 +79,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support median with CMField Number and type`() {
+    fun `should support median with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = MedianExpression(field.toDopeType(), quantifier)
@@ -90,7 +90,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support sum with CMField Number`() {
+    fun `should support sum with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = SumExpression(field.toDopeType(), quantifier)
@@ -101,7 +101,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support sum with CMField Number and type`() {
+    fun `should support sum with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = SumExpression(field.toDopeType(), quantifier)
@@ -112,7 +112,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support stddev with CMField Number`() {
+    fun `should support stddev with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = StandardDeviationExpression(field.toDopeType(), quantifier)
@@ -123,7 +123,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support stddev with CMField Number and type`() {
+    fun `should support stddev with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = StandardDeviationExpression(field.toDopeType(), quantifier)
@@ -134,7 +134,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support variance with CMField Number`() {
+    fun `should support variance with CMJsonField Number`() {
         val field = someCMNumberField()
         val quantifier = null
         val expected = VarianceExpression(field.toDopeType(), quantifier)
@@ -145,7 +145,7 @@ class NumberAggregateTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support variance with CMField Number and type`() {
+    fun `should support variance with CMJsonField Number and type`() {
         val field = someCMNumberField()
         val quantifier = ALL
         val expected = VarianceExpression(field.toDopeType(), quantifier)
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/UpdateClauseTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/UpdateClauseTest.kt
index 91015489..5fa0e0e0 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/UpdateClauseTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/UpdateClauseTest.kt
@@ -11,10 +11,14 @@ import ch.ergon.dope.helper.ManagerDependentTest
 import ch.ergon.dope.helper.someBoolean
 import ch.ergon.dope.helper.someCMBooleanField
 import ch.ergon.dope.helper.someCMBooleanList
+import ch.ergon.dope.helper.someCMConverterBooleanField
+import ch.ergon.dope.helper.someCMConverterNumberField
+import ch.ergon.dope.helper.someCMConverterStringField
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMNumberList
 import ch.ergon.dope.helper.someCMStringField
 import ch.ergon.dope.helper.someCMStringList
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someString
 import ch.ergon.dope.helper.someUpdate
@@ -56,7 +60,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField number to CMField number`() {
+    fun `should support update set CMJsonField number to CMJsonField number`() {
         val field = someCMNumberField()
         val value = someCMNumberField()
         val parentClause = someUpdate()
@@ -68,7 +72,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField number to CMField number`() {
+    fun `should support update additional set CMJsonField number to CMJsonField number`() {
         val numberField = someCMNumberField()
         val numberValue = someCMNumberField()
         val stringField = someCMStringField()
@@ -86,7 +90,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField string to CMField string`() {
+    fun `should support update set CMJsonField string to CMJsonField string`() {
         val field = someCMStringField()
         val value = someCMStringField()
         val parentClause = someUpdate()
@@ -98,7 +102,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField string to CMField string`() {
+    fun `should support update additional set CMJsonField string to CMJsonField string`() {
         val numberField = someCMNumberField()
         val numberValue = someCMNumberField()
         val stringField = someCMStringField()
@@ -116,7 +120,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField boolean to CMField boolean`() {
+    fun `should support update set CMJsonField boolean to CMJsonField boolean`() {
         val field = someCMBooleanField()
         val value = someCMBooleanField()
         val parentClause = someUpdate()
@@ -128,7 +132,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField boolean to CMField boolean`() {
+    fun `should support update additional set CMJsonField boolean to CMJsonField boolean`() {
         val booleanField = someCMBooleanField()
         val booleanValue = someCMBooleanField()
         val stringField = someCMStringField()
@@ -146,7 +150,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMList number to CMList number`() {
+    fun `should support update set CMJsonList number to CMJsonList number`() {
         val field = someCMNumberList()
         val value = someCMNumberList()
         val parentClause = someUpdate()
@@ -158,7 +162,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMList number to CMList number`() {
+    fun `should support update additional set CMJsonList number to CMJsonList number`() {
         val numberField = someCMNumberList()
         val numberValue = someCMNumberList()
         val stringField = someCMStringList()
@@ -176,7 +180,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMList string to CMList string`() {
+    fun `should support update set CMJsonList string to CMJsonList string`() {
         val field = someCMStringList()
         val value = someCMStringList()
         val parentClause = someUpdate()
@@ -188,7 +192,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMList string to CMList string`() {
+    fun `should support update additional set CMJsonList string to CMJsonList string`() {
         val numberField = someCMNumberList()
         val numberValue = someCMNumberList()
         val stringField = someCMStringList()
@@ -206,7 +210,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMList boolean to CMList boolean`() {
+    fun `should support update set CMJsonList boolean to CMJsonList boolean`() {
         val field = someCMBooleanList()
         val value = someCMBooleanList()
         val parentClause = someUpdate()
@@ -218,7 +222,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMList boolean to CMList boolean`() {
+    fun `should support update additional set CMJsonList boolean to CMJsonList boolean`() {
         val booleanField = someCMBooleanList()
         val booleanValue = someCMBooleanList()
         val stringField = someCMStringList()
@@ -236,7 +240,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField number to TypeExpression number`() {
+    fun `should support update set CMJsonField number to TypeExpression number`() {
         val field = someCMNumberField()
         val value = someNumber().toDopeType()
         val parentClause = someUpdate()
@@ -248,7 +252,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField number to TypeExpression number`() {
+    fun `should support update additional set CMJsonField number to TypeExpression number`() {
         val numberField = someCMNumberField()
         val numberValue = someNumber().toDopeType()
         val stringField = someCMStringField()
@@ -266,7 +270,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField string to TypeExpression string`() {
+    fun `should support update set CMJsonField string to TypeExpression string`() {
         val field = someCMStringField()
         val value = someString().toDopeType()
         val parentClause = someUpdate()
@@ -278,7 +282,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField string to TypeExpression string`() {
+    fun `should support update additional set CMJsonField string to TypeExpression string`() {
         val numberField = someCMNumberField()
         val numberValue = someCMNumberField()
         val stringField = someCMStringField()
@@ -296,7 +300,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField boolean to TypeExpression boolean`() {
+    fun `should support update set CMJsonField boolean to TypeExpression boolean`() {
         val field = someCMBooleanField()
         val value = someBoolean().toDopeType()
         val parentClause = someUpdate()
@@ -308,7 +312,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField boolean to TypeExpression boolean`() {
+    fun `should support update additional set CMJsonField boolean to TypeExpression boolean`() {
         val booleanField = someCMBooleanField()
         val booleanValue = someBoolean().toDopeType()
         val stringField = someCMStringField()
@@ -326,7 +330,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMList number to TypeExpression number`() {
+    fun `should support update set CMJsonList number to TypeExpression number`() {
         val field = someCMNumberList()
         val value = listOf(someNumber().toDopeType(), someNumber().toDopeType()).toDopeType()
         val parentClause = someUpdate()
@@ -338,7 +342,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMList number to TypeExpression number`() {
+    fun `should support update additional set CMJsonList number to TypeExpression number`() {
         val numberField = someCMNumberList()
         val numberValue = listOf(someNumber().toDopeType(), someNumber().toDopeType()).toDopeType()
         val stringField = someCMStringList()
@@ -356,7 +360,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMList string to TypeExpression string`() {
+    fun `should support update set CMJsonList string to TypeExpression string`() {
         val field = someCMStringList()
         val value = listOf(someString().toDopeType(), someString().toDopeType()).toDopeType()
         val parentClause = someUpdate()
@@ -368,7 +372,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMList string to TypeExpression string`() {
+    fun `should support update additional set CMJsonList string to TypeExpression string`() {
         val numberField = someCMNumberList()
         val numberValue = someCMNumberList()
         val stringField = someCMStringList()
@@ -386,7 +390,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMList boolean to TypeExpression boolean`() {
+    fun `should support update set CMJsonList boolean to TypeExpression boolean`() {
         val field = someCMBooleanList()
         val value = listOf(someBoolean().toDopeType(), someBoolean().toDopeType()).toDopeType()
         val parentClause = someUpdate()
@@ -398,7 +402,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMList boolean to TypeExpression boolean`() {
+    fun `should support update additional set CMJsonList boolean to TypeExpression boolean`() {
         val booleanField = someCMBooleanList()
         val booleanValue = listOf(someBoolean().toDopeType(), someBoolean().toDopeType()).toDopeType()
         val stringField = someCMStringList()
@@ -416,7 +420,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField number to number`() {
+    fun `should support update set CMJsonField number to number`() {
         val field = someCMNumberField()
         val value = someNumber()
         val parentClause = someUpdate()
@@ -428,7 +432,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField number to number`() {
+    fun `should support update additional set CMJsonField number to number`() {
         val numberField = someCMNumberField()
         val numberValue = someNumber()
         val stringField = someCMStringField()
@@ -446,7 +450,37 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField string to string`() {
+    fun `should support update set CMConverterField number to date`() {
+        val field = someCMConverterNumberField()
+        val value = someDate()
+        val parentClause = someUpdate()
+        val expected = SetClause(field.toDopeType().to(value.toInstant().epochSecond.toDopeType()), parentClause = parentClause)
+
+        val actual = parentClause.set(field, value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support update additional set CMConverterField number to date`() {
+        val dateField = someCMConverterNumberField()
+        val dateValue = someDate()
+        val stringField = someCMStringField()
+        val stringValue = someCMStringField()
+        val parentClause = someUpdate()
+        val expected = SetClause(
+            stringField.toDopeType().to(stringValue.toDopeType()),
+            dateField.toDopeType().to(dateValue.toInstant().epochSecond.toDopeType()),
+            parentClause = parentClause,
+        )
+
+        val actual = parentClause.set(stringField, stringValue).set(dateField, dateValue)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support update set CMJsonField string to string`() {
         val field = someCMStringField()
         val value = someString()
         val parentClause = someUpdate()
@@ -458,7 +492,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField string to string`() {
+    fun `should support update additional set CMJsonField string to string`() {
         val numberField = someCMNumberField()
         val numberValue = someCMNumberField()
         val stringField = someCMStringField()
@@ -476,7 +510,37 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update set CMField boolean to boolean`() {
+    fun `should support update set CMConverterField string to date`() {
+        val field = someCMConverterStringField()
+        val value = someDate()
+        val parentClause = someUpdate()
+        val expected = SetClause(field.toDopeType().to(value.toInstant().epochSecond.toString().toDopeType()), parentClause = parentClause)
+
+        val actual = parentClause.set(field, value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support update additional set CMConverterField string to date`() {
+        val dateField = someCMConverterStringField()
+        val dateValue = someDate()
+        val stringField = someCMStringField()
+        val stringValue = someCMStringField()
+        val parentClause = someUpdate()
+        val expected = SetClause(
+            stringField.toDopeType().to(stringValue.toDopeType()),
+            dateField.toDopeType().to(dateValue.toInstant().epochSecond.toString().toDopeType()),
+            parentClause = parentClause,
+        )
+
+        val actual = parentClause.set(stringField, stringValue).set(dateField, dateValue)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support update set CMJsonField boolean to boolean`() {
         val field = someCMBooleanField()
         val value = someBoolean()
         val parentClause = someUpdate()
@@ -488,7 +552,7 @@ class UpdateClauseTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support update additional set CMField boolean to boolean`() {
+    fun `should support update additional set CMJsonField boolean to boolean`() {
         val booleanField = someCMBooleanField()
         val booleanValue = someBoolean()
         val stringField = someCMStringField()
@@ -505,6 +569,36 @@ class UpdateClauseTest : ManagerDependentTest {
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
+    @Test
+    fun `should support update set CMConverterField boolean to date`() {
+        val field = someCMConverterBooleanField()
+        val value = someDate()
+        val parentClause = someUpdate()
+        val expected = SetClause(field.toDopeType().to(true.toDopeType()), parentClause = parentClause)
+
+        val actual = parentClause.set(field, value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support update additional set CMConverterField boolean to date`() {
+        val dateField = someCMConverterBooleanField()
+        val dateValue = someDate()
+        val stringField = someCMStringField()
+        val stringValue = someCMStringField()
+        val parentClause = someUpdate()
+        val expected = SetClause(
+            stringField.toDopeType().to(stringValue.toDopeType()),
+            dateField.toDopeType().to(true.toDopeType()),
+            parentClause = parentClause,
+        )
+
+        val actual = parentClause.set(stringField, stringValue).set(dateField, dateValue)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
     @Test
     fun `should support update unset with CM`() {
         val stringField = someCMStringField()
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NegationTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NegationTest.kt
index b3570458..d9bec672 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NegationTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NegationTest.kt
@@ -13,7 +13,7 @@ class NegationTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support neg with CMField Number`() {
+    fun `should support neg with CMJsonField Number`() {
         val field = someCMNumberField()
         val expected = NegationExpression(field.toDopeType())
 
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NumberInfixTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NumberInfixTest.kt
index a0413592..233512db 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NumberInfixTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/arithmetic/NumberInfixTest.kt
@@ -7,7 +7,9 @@ import ch.ergon.dope.extension.type.arithmetic.mod
 import ch.ergon.dope.extension.type.arithmetic.mul
 import ch.ergon.dope.extension.type.arithmetic.sub
 import ch.ergon.dope.helper.ManagerDependentTest
+import ch.ergon.dope.helper.someCMConverterNumberField
 import ch.ergon.dope.helper.someCMNumberField
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.resolvable.expression.unaliased.type.arithmetic.AdditionExpression
@@ -24,7 +26,7 @@ class NumberInfixTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support add with CMField CMField`() {
+    fun `should support add with CMJsonField CMJsonField`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = AdditionExpression(left.toDopeType(), right.toDopeType())
@@ -35,7 +37,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support add with CMField type`() {
+    fun `should support add with CMJsonField type`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = AdditionExpression(left.toDopeType(), right)
@@ -46,7 +48,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support add with type CMField`() {
+    fun `should support add with type CMJsonField`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = AdditionExpression(left, right.toDopeType())
@@ -57,7 +59,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support add with Number CMField`() {
+    fun `should support add with Number CMJsonField`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = AdditionExpression(left.toDopeType(), right.toDopeType())
@@ -68,7 +70,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support add with CMField Number`() {
+    fun `should support add with CMJsonField Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = AdditionExpression(left.toDopeType(), right.toDopeType())
@@ -79,7 +81,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support sub with CMField CMField`() {
+    fun `should support sub with CMJsonField CMJsonField`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = SubtractionExpression(left.toDopeType(), right.toDopeType())
@@ -90,7 +92,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support sub with CMField type`() {
+    fun `should support sub with CMJsonField type`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = SubtractionExpression(left.toDopeType(), right)
@@ -101,7 +103,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support sub with type CMField`() {
+    fun `should support sub with type CMJsonField`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = SubtractionExpression(left, right.toDopeType())
@@ -112,7 +114,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support sub with Number CMField`() {
+    fun `should support sub with Number CMJsonField`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = SubtractionExpression(left.toDopeType(), right.toDopeType())
@@ -123,7 +125,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support sub with CMField Number`() {
+    fun `should support sub with CMJsonField Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = SubtractionExpression(left.toDopeType(), right.toDopeType())
@@ -134,7 +136,18 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mul with CMField CMField`() {
+    fun `should support sub with Date CMConverterNumber`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = SubtractionExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.sub(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support mul with CMJsonField CMJsonField`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = MultiplicationExpression(left.toDopeType(), right.toDopeType())
@@ -145,7 +158,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mul with CMField type`() {
+    fun `should support mul with CMJsonField type`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = MultiplicationExpression(left.toDopeType(), right)
@@ -156,7 +169,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mul with type CMField`() {
+    fun `should support mul with type CMJsonField`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = MultiplicationExpression(left, right.toDopeType())
@@ -167,7 +180,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mul with Number CMField`() {
+    fun `should support mul with Number CMJsonField`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = MultiplicationExpression(left.toDopeType(), right.toDopeType())
@@ -178,7 +191,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mul with CMField Number`() {
+    fun `should support mul with CMJsonField Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = MultiplicationExpression(left.toDopeType(), right.toDopeType())
@@ -189,7 +202,18 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support div with CMField CMField`() {
+    fun `should support mul with Date CMConverterNumber`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = MultiplicationExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.mul(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support div with CMJsonField CMJsonField`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = DivisionExpression(left.toDopeType(), right.toDopeType())
@@ -200,7 +224,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support div with CMField type`() {
+    fun `should support div with CMJsonField type`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = DivisionExpression(left.toDopeType(), right)
@@ -211,7 +235,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support div with type CMField`() {
+    fun `should support div with type CMJsonField`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = DivisionExpression(left, right.toDopeType())
@@ -222,7 +246,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support div with Number CMField`() {
+    fun `should support div with Number CMJsonField`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = DivisionExpression(left.toDopeType(), right.toDopeType())
@@ -233,7 +257,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support div with CMField Number`() {
+    fun `should support div with CMJsonField Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = DivisionExpression(left.toDopeType(), right.toDopeType())
@@ -244,7 +268,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mod with CMField CMField`() {
+    fun `should support mod with CMJsonField CMJsonField`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = ModuloExpression(left.toDopeType(), right.toDopeType())
@@ -255,7 +279,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mod with CMField type`() {
+    fun `should support mod with CMJsonField type`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = ModuloExpression(left.toDopeType(), right)
@@ -266,7 +290,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mod with type CMField`() {
+    fun `should support mod with type CMJsonField`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = ModuloExpression(left, right.toDopeType())
@@ -277,7 +301,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mod with Number CMField`() {
+    fun `should support mod with Number CMJsonField`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = ModuloExpression(left.toDopeType(), right.toDopeType())
@@ -288,7 +312,7 @@ class NumberInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support mod with CMField Number`() {
+    fun `should support mod with CMJsonField Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = ModuloExpression(left.toDopeType(), right.toDopeType())
@@ -297,4 +321,15 @@ class NumberInfixTest : ManagerDependentTest {
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
+
+    @Test
+    fun `should support mod with Date CMConverterNumber`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = ModuloExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.mod(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/array/ArrayFunctionTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/array/ArrayFunctionTest.kt
index e8175f37..7f918a88 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/array/ArrayFunctionTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/array/ArrayFunctionTest.kt
@@ -95,30 +95,30 @@ class ArrayFunctionTest : ManagerDependentTest {
 
     @Test
     fun `should support ARRAY_DISTINCT with CM Number list`() {
-        val cmList = someCMNumberList()
-        val expected = ArrayDistinctExpression(cmList.toDopeType())
+        val CMJsonList = someCMNumberList()
+        val expected = ArrayDistinctExpression(CMJsonList.toDopeType())
 
-        val actual = arrayDistinct(cmList)
+        val actual = arrayDistinct(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
     @Test
     fun `should support ARRAY_DISTINCT with CM String list`() {
-        val cmList = someCMStringList()
-        val expected = ArrayDistinctExpression(cmList.toDopeType())
+        val CMJsonList = someCMStringList()
+        val expected = ArrayDistinctExpression(CMJsonList.toDopeType())
 
-        val actual = arrayDistinct(cmList)
+        val actual = arrayDistinct(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
     @Test
     fun `should support ARRAY_DISTINCT with CM Boolean list`() {
-        val cmList = someCMBooleanList()
-        val expected = ArrayDistinctExpression(cmList.toDopeType())
+        val CMJsonList = someCMBooleanList()
+        val expected = ArrayDistinctExpression(CMJsonList.toDopeType())
 
-        val actual = arrayDistinct(cmList)
+        val actual = arrayDistinct(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
@@ -158,60 +158,60 @@ class ArrayFunctionTest : ManagerDependentTest {
 
     @Test
     fun `should support ARRAY_LENGTH with CM Number list`() {
-        val cmList = someCMNumberList()
-        val expected = ArrayLengthExpression(cmList.toDopeType())
+        val CMJsonList = someCMNumberList()
+        val expected = ArrayLengthExpression(CMJsonList.toDopeType())
 
-        val actual = arrayLength(cmList)
+        val actual = arrayLength(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
     @Test
     fun `should support ARRAY_LENGTH with CM String list`() {
-        val cmList = someCMStringList()
-        val expected = ArrayLengthExpression(cmList.toDopeType())
+        val CMJsonList = someCMStringList()
+        val expected = ArrayLengthExpression(CMJsonList.toDopeType())
 
-        val actual = arrayLength(cmList)
+        val actual = arrayLength(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
     @Test
     fun `should support ARRAY_LENGTH with CM Boolean list`() {
-        val cmList = someCMBooleanList()
-        val expected = ArrayLengthExpression(cmList.toDopeType())
+        val CMJsonList = someCMBooleanList()
+        val expected = ArrayLengthExpression(CMJsonList.toDopeType())
 
-        val actual = arrayLength(cmList)
+        val actual = arrayLength(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
     @Test
     fun `should support ARRAY_SUM with CM Number list`() {
-        val cmList = someCMNumberList()
-        val expected = ArraySumExpression(cmList.toDopeType())
+        val CMJsonList = someCMNumberList()
+        val expected = ArraySumExpression(CMJsonList.toDopeType())
 
-        val actual = arraySum(cmList)
+        val actual = arraySum(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
     @Test
     fun `should support ARRAY_SUM with CM String list`() {
-        val cmList = someCMStringList()
-        val expected = ArraySumExpression(cmList.toDopeType())
+        val CMJsonList = someCMStringList()
+        val expected = ArraySumExpression(CMJsonList.toDopeType())
 
-        val actual = arraySum(cmList)
+        val actual = arraySum(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
 
     @Test
     fun `should support ARRAY_SUM with CM Boolean list`() {
-        val cmList = someCMBooleanList()
-        val expected = ArraySumExpression(cmList.toDopeType())
+        val CMJsonList = someCMBooleanList()
+        val expected = ArraySumExpression(CMJsonList.toDopeType())
 
-        val actual = arraySum(cmList)
+        val actual = arraySum(CMJsonList)
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/conditional/NvlTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/conditional/NvlTest.kt
index 7914571e..1c98f601 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/conditional/NvlTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/conditional/NvlTest.kt
@@ -6,10 +6,14 @@ import ch.ergon.dope.helper.ManagerDependentTest
 import ch.ergon.dope.helper.someBoolean
 import ch.ergon.dope.helper.someCMBooleanField
 import ch.ergon.dope.helper.someCMBooleanList
+import ch.ergon.dope.helper.someCMConverterBooleanField
+import ch.ergon.dope.helper.someCMConverterNumberField
+import ch.ergon.dope.helper.someCMConverterStringField
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMNumberList
 import ch.ergon.dope.helper.someCMStringField
 import ch.ergon.dope.helper.someCMStringList
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someString
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.conditional.NvlExpression
@@ -119,4 +123,37 @@ class NvlTest : ManagerDependentTest {
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
+
+    @Test
+    fun `should support nvl CMNumberField date`() {
+        val initialExpression = someCMConverterNumberField()
+        val substituteExpression = someDate()
+        val expected = NvlExpression(initialExpression.toDopeType(), substituteExpression.toInstant().epochSecond.toDopeType())
+
+        val actual = nvl(initialExpression, substituteExpression)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support nvl CMStringField date`() {
+        val initialExpression = someCMConverterStringField()
+        val substituteExpression = someDate()
+        val expected = NvlExpression(initialExpression.toDopeType(), substituteExpression.toInstant().epochSecond.toString().toDopeType())
+
+        val actual = nvl(initialExpression, substituteExpression)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support nvl CMBooleanField date`() {
+        val initialExpression = someCMConverterBooleanField()
+        val substituteExpression = someDate()
+        val expected = NvlExpression(initialExpression.toDopeType(), true.toDopeType())
+
+        val actual = nvl(initialExpression, substituteExpression)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/LogicalInfixTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/LogicalInfixTest.kt
index 2ecb61cb..d16fa3e3 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/LogicalInfixTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/LogicalInfixTest.kt
@@ -18,7 +18,7 @@ class LogicalInfixTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support or with CMField CMField`() {
+    fun `should support or with CMJsonField CMJsonField`() {
         val left = someCMBooleanField()
         val right = someCMBooleanField()
         val expected = OrExpression(left.toDopeType(), right.toDopeType())
@@ -29,7 +29,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support or with CMField type`() {
+    fun `should support or with CMJsonField type`() {
         val left = someCMBooleanField()
         val right = someBooleanField()
         val expected = OrExpression(left.toDopeType(), right)
@@ -40,7 +40,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support or with type CMField`() {
+    fun `should support or with type CMJsonField`() {
         val left = someBooleanField()
         val right = someCMBooleanField()
         val expected = OrExpression(left, right.toDopeType())
@@ -51,7 +51,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support or with Boolean CMField`() {
+    fun `should support or with Boolean CMJsonField`() {
         val left = someBoolean()
         val right = someCMBooleanField()
         val expected = OrExpression(left.toDopeType(), right.toDopeType())
@@ -62,7 +62,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support or with CMField Boolean`() {
+    fun `should support or with CMJsonField Boolean`() {
         val left = someCMBooleanField()
         val right = someBoolean()
         val expected = OrExpression(left.toDopeType(), right.toDopeType())
@@ -73,7 +73,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support and with CMField CMField`() {
+    fun `should support and with CMJsonField CMJsonField`() {
         val left = someCMBooleanField()
         val right = someCMBooleanField()
         val expected = AndExpression(left.toDopeType(), right.toDopeType())
@@ -84,7 +84,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support and with CMField type`() {
+    fun `should support and with CMJsonField type`() {
         val left = someCMBooleanField()
         val right = someBooleanField()
         val expected = AndExpression(left.toDopeType(), right)
@@ -95,7 +95,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support and with type CMField`() {
+    fun `should support and with type CMJsonField`() {
         val left = someBooleanField()
         val right = someCMBooleanField()
         val expected = AndExpression(left, right.toDopeType())
@@ -106,7 +106,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support and with Boolean CMField`() {
+    fun `should support and with Boolean CMJsonField`() {
         val left = someBoolean()
         val right = someCMBooleanField()
         val expected = AndExpression(left.toDopeType(), right.toDopeType())
@@ -117,7 +117,7 @@ class LogicalInfixTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support and with CMField Boolean`() {
+    fun `should support and with CMJsonField Boolean`() {
         val left = someCMBooleanField()
         val right = someBoolean()
         val expected = AndExpression(left.toDopeType(), right.toDopeType())
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/NotTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/NotTest.kt
index c88cc874..5d563f4c 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/NotTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/logical/NotTest.kt
@@ -13,7 +13,7 @@ class NotTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support not with CMField CMField`() {
+    fun `should support not with CMJsonField CMJsonField`() {
         val expression = someCMBooleanField()
         val expected = NotExpression(expression.toDopeType())
 
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/numeric/NumberFunctionTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/numeric/NumberFunctionTest.kt
index e0a3a350..5ec9898c 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/numeric/NumberFunctionTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/numeric/NumberFunctionTest.kt
@@ -32,7 +32,7 @@ class NumberFunctionTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support ABS number function with number CMField`() {
+    fun `should support ABS number function with number CMJsonField`() {
         val expected = "ABS(`CMNumberField`)"
 
         val actual = abs(someCMNumberField()).toDopeQuery(manager).queryString
@@ -41,7 +41,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ACOS number function with number CMField`() {
+    fun `should support ACOS number function with number CMJsonField`() {
         val expected = "ACOS(`CMNumberField`)"
 
         val actual = acos(someCMNumberField()).toDopeQuery(manager).queryString
@@ -50,7 +50,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ASIN number function with number CMField`() {
+    fun `should support ASIN number function with number CMJsonField`() {
         val expected = "ASIN(`CMNumberField`)"
 
         val actual = asin(someCMNumberField()).toDopeQuery(manager).queryString
@@ -59,7 +59,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ATAN number function with number CMField`() {
+    fun `should support ATAN number function with number CMJsonField`() {
         val expected = "ATAN(`CMNumberField`)"
 
         val actual = atan(someCMNumberField()).toDopeQuery(manager).queryString
@@ -68,7 +68,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ATAN2 number function with divisor and dividend as number CMField`() {
+    fun `should support ATAN2 number function with divisor and dividend as number CMJsonField`() {
         val expected = "ATAN2(`CMNumberField`, `anotherNumberField`)"
 
         val actual = atan2(someCMNumberField(), someCMNumberField("anotherNumberField")).toDopeQuery(manager).queryString
@@ -77,7 +77,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ATAN2 number function with divisor as number CMField and dividend as TypeExpression`() {
+    fun `should support ATAN2 number function with divisor as number CMJsonField and dividend as TypeExpression`() {
         val expected = "ATAN2(`CMNumberField`, 1)"
 
         val actual = atan2(someCMNumberField(), 1.toDopeType()).toDopeQuery(manager).queryString
@@ -86,7 +86,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ATAN2 number function with divisor as number CMField and dividend as Number`() {
+    fun `should support ATAN2 number function with divisor as number CMJsonField and dividend as Number`() {
         val expected = "ATAN2(`CMNumberField`, 1)"
 
         val actual = atan2(someCMNumberField(), 1).toDopeQuery(manager).queryString
@@ -95,7 +95,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ATAN2 number function with divisor as TypeExpression and dividend as number CMField`() {
+    fun `should support ATAN2 number function with divisor as TypeExpression and dividend as number CMJsonField`() {
         val expected = "ATAN2(1, `CMNumberField`)"
 
         val actual = atan2(1.toDopeType(), someCMNumberField()).toDopeQuery(manager).queryString
@@ -104,7 +104,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ATAN2 number function with divisor as Number and dividend as number CMField`() {
+    fun `should support ATAN2 number function with divisor as Number and dividend as number CMJsonField`() {
         val expected = "ATAN2(1, `CMNumberField`)"
 
         val actual = atan2(1, someCMNumberField()).toDopeQuery(manager).queryString
@@ -113,7 +113,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support CEIL number function with number CMField`() {
+    fun `should support CEIL number function with number CMJsonField`() {
         val expected = "CEIL(`CMNumberField`)"
 
         val actual = ceil(someCMNumberField()).toDopeQuery(manager).queryString
@@ -122,7 +122,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support COS number function with number CMField`() {
+    fun `should support COS number function with number CMJsonField`() {
         val expected = "COS(`CMNumberField`)"
 
         val actual = cos(someCMNumberField()).toDopeQuery(manager).queryString
@@ -131,7 +131,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support DEGREES number function with number CMField`() {
+    fun `should support DEGREES number function with number CMJsonField`() {
         val expected = "DEGREES(`CMNumberField`)"
 
         val actual = degrees(someCMNumberField()).toDopeQuery(manager).queryString
@@ -140,7 +140,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support EXP number function with number CMField`() {
+    fun `should support EXP number function with number CMJsonField`() {
         val expected = "EXP(`CMNumberField`)"
 
         val actual = exp(someCMNumberField()).toDopeQuery(manager).queryString
@@ -149,7 +149,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support LN number function with number CMField`() {
+    fun `should support LN number function with number CMJsonField`() {
         val expected = "LN(`CMNumberField`)"
 
         val actual = ln(someCMNumberField()).toDopeQuery(manager).queryString
@@ -158,7 +158,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support LOG number function with number CMField`() {
+    fun `should support LOG number function with number CMJsonField`() {
         val expected = "LOG(`CMNumberField`)"
 
         val actual = log(someCMNumberField()).toDopeQuery(manager).queryString
@@ -167,7 +167,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support FLOOR number function with number CMField`() {
+    fun `should support FLOOR number function with number CMJsonField`() {
         val expected = "FLOOR(`CMNumberField`)"
 
         val actual = floor(someCMNumberField()).toDopeQuery(manager).queryString
@@ -176,7 +176,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support POWER number function with base and exponent as number CMField`() {
+    fun `should support POWER number function with base and exponent as number CMJsonField`() {
         val expected = "POWER(`CMNumberField`, `anotherNumberField`)"
 
         val actual = power(someCMNumberField(), someCMNumberField("anotherNumberField")).toDopeQuery(manager).queryString
@@ -185,7 +185,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support POWER number function with base as number CMField and exponent as TypeExpression`() {
+    fun `should support POWER number function with base as number CMJsonField and exponent as TypeExpression`() {
         val expected = "POWER(`CMNumberField`, 1)"
 
         val actual = power(someCMNumberField(), 1.toDopeType()).toDopeQuery(manager).queryString
@@ -194,7 +194,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support POWER number function with base as number CMField and exponent as Number`() {
+    fun `should support POWER number function with base as number CMJsonField and exponent as Number`() {
         val expected = "POWER(`CMNumberField`, 1)"
 
         val actual = power(someCMNumberField(), 1).toDopeQuery(manager).queryString
@@ -203,7 +203,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support POWER number function with base as TypeExpression and exponent as number CMField`() {
+    fun `should support POWER number function with base as TypeExpression and exponent as number CMJsonField`() {
         val expected = "POWER(1, `CMNumberField`)"
 
         val actual = power(1.toDopeType(), someCMNumberField()).toDopeQuery(manager).queryString
@@ -212,7 +212,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support POWER number function with base as Number and exponent as number CMField`() {
+    fun `should support POWER number function with base as Number and exponent as number CMJsonField`() {
         val expected = "POWER(1, `CMNumberField`)"
 
         val actual = power(1, someCMNumberField()).toDopeQuery(manager).queryString
@@ -221,7 +221,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support RADIANS number function with number CMField`() {
+    fun `should support RADIANS number function with number CMJsonField`() {
         val expected = "RADIANS(`CMNumberField`)"
 
         val actual = radians(someCMNumberField()).toDopeQuery(manager).queryString
@@ -230,7 +230,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support RANDOM number function with number CMField`() {
+    fun `should support RANDOM number function with number CMJsonField`() {
         val expected = "RANDOM(`CMNumberField`)"
 
         val actual = random(someCMNumberField()).toDopeQuery(manager).queryString
@@ -239,7 +239,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ROUND number function with number CMField`() {
+    fun `should support ROUND number function with number CMJsonField`() {
         val expected = "ROUND(`CMNumberField`)"
 
         val actual = round(someCMNumberField()).toDopeQuery(manager).queryString
@@ -248,7 +248,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ROUND number function with value and digits as number CMField`() {
+    fun `should support ROUND number function with value and digits as number CMJsonField`() {
         val expected = "ROUND(`CMNumberField`, `anotherNumberField`)"
 
         val actual = round(someCMNumberField(), someCMNumberField("anotherNumberField")).toDopeQuery(manager).queryString
@@ -257,7 +257,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ROUND number function with value as number CMField and digits as TypeExpression`() {
+    fun `should support ROUND number function with value as number CMJsonField and digits as TypeExpression`() {
         val expected = "ROUND(`CMNumberField`, 1)"
 
         val actual = round(someCMNumberField(), 1.toDopeType()).toDopeQuery(manager).queryString
@@ -266,7 +266,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ROUND number function with value as number CMField and digits as Number`() {
+    fun `should support ROUND number function with value as number CMJsonField and digits as Number`() {
         val expected = "ROUND(`CMNumberField`, 1)"
 
         val actual = round(someCMNumberField(), 1).toDopeQuery(manager).queryString
@@ -275,7 +275,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ROUND number function with value as TypeExpression and digits as number CMField`() {
+    fun `should support ROUND number function with value as TypeExpression and digits as number CMJsonField`() {
         val expected = "ROUND(1, `CMNumberField`)"
 
         val actual = round(1.toDopeType(), someCMNumberField()).toDopeQuery(manager).queryString
@@ -284,7 +284,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support ROUND number function with value as Number and digits as number CMField`() {
+    fun `should support ROUND number function with value as Number and digits as number CMJsonField`() {
         val expected = "ROUND(1, `CMNumberField`)"
 
         val actual = round(1, someCMNumberField()).toDopeQuery(manager).queryString
@@ -293,7 +293,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support SIGN number function with number CMField`() {
+    fun `should support SIGN number function with number CMJsonField`() {
         val expected = "SIGN(`CMNumberField`)"
 
         val actual = sign(someCMNumberField()).toDopeQuery(manager).queryString
@@ -302,7 +302,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support SIN number function with number CMField`() {
+    fun `should support SIN number function with number CMJsonField`() {
         val expected = "SIN(`CMNumberField`)"
 
         val actual = sin(someCMNumberField()).toDopeQuery(manager).queryString
@@ -311,7 +311,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support SQRT number function with number CMField`() {
+    fun `should support SQRT number function with number CMJsonField`() {
         val expected = "SQRT(`CMNumberField`)"
 
         val actual = sqrt(someCMNumberField()).toDopeQuery(manager).queryString
@@ -320,7 +320,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support TAN number function with number CMField`() {
+    fun `should support TAN number function with number CMJsonField`() {
         val expected = "TAN(`CMNumberField`)"
 
         val actual = tan(someCMNumberField()).toDopeQuery(manager).queryString
@@ -329,7 +329,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support TRUNC number function with number CMField`() {
+    fun `should support TRUNC number function with number CMJsonField`() {
         val expected = "TRUNC(`CMNumberField`)"
 
         val actual = trunc(someCMNumberField()).toDopeQuery(manager).queryString
@@ -338,7 +338,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support TRUNC number function with value and digits as number CMField`() {
+    fun `should support TRUNC number function with value and digits as number CMJsonField`() {
         val expected = "TRUNC(`CMNumberField`, `anotherNumberField`)"
 
         val actual = trunc(someCMNumberField(), someCMNumberField("anotherNumberField")).toDopeQuery(manager).queryString
@@ -347,7 +347,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support TRUNC number function with value as number CMField and digits as TypeExpression`() {
+    fun `should support TRUNC number function with value as number CMJsonField and digits as TypeExpression`() {
         val expected = "TRUNC(`CMNumberField`, 1)"
 
         val actual = trunc(someCMNumberField(), 1.toDopeType()).toDopeQuery(manager).queryString
@@ -356,7 +356,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support TRUNC number function with value as number CMField and digits as Number`() {
+    fun `should support TRUNC number function with value as number CMJsonField and digits as Number`() {
         val expected = "TRUNC(`CMNumberField`, 1)"
 
         val actual = trunc(someCMNumberField(), 1).toDopeQuery(manager).queryString
@@ -365,7 +365,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support TRUNC number function with value as TypeExpression and digits as number CMField`() {
+    fun `should support TRUNC number function with value as TypeExpression and digits as number CMJsonField`() {
         val expected = "TRUNC(1, `CMNumberField`)"
 
         val actual = trunc(1.toDopeType(), someCMNumberField()).toDopeQuery(manager).queryString
@@ -374,7 +374,7 @@ class NumberFunctionTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support TRUNC number function with value as Number and digits as number CMField`() {
+    fun `should support TRUNC number function with value as Number and digits as number CMJsonField`() {
         val expected = "TRUNC(1, `CMNumberField`)"
 
         val actual = trunc(1, someCMNumberField()).toDopeQuery(manager).queryString
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/EqualsTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/EqualsTest.kt
index 8568f137..df9c42ec 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/EqualsTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/EqualsTest.kt
@@ -7,8 +7,12 @@ import ch.ergon.dope.helper.ManagerDependentTest
 import ch.ergon.dope.helper.someBoolean
 import ch.ergon.dope.helper.someBooleanField
 import ch.ergon.dope.helper.someCMBooleanField
+import ch.ergon.dope.helper.someCMConverterBooleanField
+import ch.ergon.dope.helper.someCMConverterNumberField
+import ch.ergon.dope.helper.someCMConverterStringField
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMStringField
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someString
@@ -24,7 +28,7 @@ class EqualsTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support equals to with CMFieldNumber CMFieldNumber`() {
+    fun `should support equals to with CMJsonFieldNumber CMJsonFieldNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -35,7 +39,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldNumber NumberType`() {
+    fun `should support equals to with CMJsonFieldNumber NumberType`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = EqualsExpression(left.toDopeType(), right)
@@ -46,7 +50,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with NumberType CMFieldNumber`() {
+    fun `should support equals to with NumberType CMJsonFieldNumer`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = EqualsExpression(left, right.toDopeType())
@@ -57,7 +61,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with Number CMFieldNumber`() {
+    fun `should support equals to with Number CMJsonFieldNumber`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -68,7 +72,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldNumber Number`() {
+    fun `should support equals to with CMJsonFieldNumber Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -79,7 +83,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldString CMFieldString`() {
+    fun `should support equals to with CMJsonFieldString CMJsonFieldString`() {
         val left = someCMStringField()
         val right = someCMStringField()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -90,7 +94,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldString StringType`() {
+    fun `should support equals to with CMJsonFieldString StringType`() {
         val left = someCMStringField()
         val right = someStringField()
         val expected = EqualsExpression(left.toDopeType(), right)
@@ -101,7 +105,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with StringType CMFieldNumber`() {
+    fun `should support equals to with StringType CMJsonFieldNumer`() {
         val left = someStringField()
         val right = someCMStringField()
         val expected = EqualsExpression(left, right.toDopeType())
@@ -112,7 +116,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with String CMFieldString`() {
+    fun `should support equals to with String CMJsonFieldString`() {
         val left = someString()
         val right = someCMStringField()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -123,7 +127,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldString String`() {
+    fun `should support equals to with CMJsonFieldString String`() {
         val left = someCMStringField()
         val right = someString()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -134,7 +138,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldBoolean CMFieldBoolean`() {
+    fun `should support equals to with CMJsonFieldBoolean CMJsonFieldBoolean`() {
         val left = someCMBooleanField()
         val right = someCMBooleanField()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -145,7 +149,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldBoolean BooleanType`() {
+    fun `should support equals to with CMJsonFieldBoolean BooleanType`() {
         val left = someCMBooleanField()
         val right = someBooleanField()
         val expected = EqualsExpression(left.toDopeType(), right)
@@ -156,7 +160,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with BooleanType CMFieldBoolean`() {
+    fun `should support equals to with BooleanType CMJsonFieldBoolean`() {
         val left = someBooleanField()
         val right = someCMBooleanField()
         val expected = EqualsExpression(left, right.toDopeType())
@@ -167,7 +171,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with Boolean CMFieldBoolean`() {
+    fun `should support equals to with Boolean CMJsonFieldBoolean`() {
         val left = someBoolean()
         val right = someCMBooleanField()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -178,7 +182,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support equals to with CMFieldBoolean Boolean`() {
+    fun `should support equals to with CMJsonFieldBoolean Boolean`() {
         val left = someCMBooleanField()
         val right = someBoolean()
         val expected = EqualsExpression(left.toDopeType(), right.toDopeType())
@@ -189,7 +193,73 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldNumber CMFieldNumber`() {
+    fun `should support equals to with CMConverterNumberField date`() {
+        val left = someCMConverterNumberField()
+        val right = someDate()
+        val expected = EqualsExpression(left.toDopeType(), right.toInstant().epochSecond.toDopeType())
+
+        val actual = left.isEqualTo(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support equals to with date CMConverterNumberField`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = EqualsExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.isEqualTo(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support equals to with CMConverterStringField date`() {
+        val left = someCMConverterStringField()
+        val right = someDate()
+        val expected = EqualsExpression(left.toDopeType(), right.toInstant().epochSecond.toString().toDopeType())
+
+        val actual = left.isEqualTo(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support equals to with date CMConverterStringField`() {
+        val left = someDate()
+        val right = someCMConverterStringField()
+        val expected = EqualsExpression(left.toInstant().epochSecond.toString().toDopeType(), right.toDopeType())
+
+        val actual = left.isEqualTo(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support equals to with CMConverterBooleanField date`() {
+        val left = someCMConverterBooleanField()
+        val right = someDate()
+        val expected = EqualsExpression(left.toDopeType(), true.toDopeType())
+
+        val actual = left.isEqualTo(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support equals to with date CMConverterBooleanField`() {
+        val left = someDate()
+        val right = someCMConverterBooleanField()
+        val expected = EqualsExpression(true.toDopeType(), right.toDopeType())
+
+        val actual = left.isEqualTo(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support not equals to with CMJsonFieldNumber CMJsonFieldNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -200,7 +270,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldNumber NumberType`() {
+    fun `should support not equals to with CMJsonFieldNumber NumberType`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = NotEqualsExpression(left.toDopeType(), right)
@@ -211,7 +281,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with NumberType CMFieldNumber`() {
+    fun `should support not equals to with NumberType CMJsonFieldNumer`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = NotEqualsExpression(left, right.toDopeType())
@@ -222,7 +292,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with Number CMFieldNumber`() {
+    fun `should support not equals to with Number CMJsonFieldNumber`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -233,7 +303,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldNumber Number`() {
+    fun `should support not equals to with CMJsonFieldNumber Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -244,7 +314,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldString CMFieldString`() {
+    fun `should support not equals to with CMJsonFieldString CMJsonFieldString`() {
         val left = someCMStringField()
         val right = someCMStringField()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -255,7 +325,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldString StringType`() {
+    fun `should support not equals to with CMJsonFieldString StringType`() {
         val left = someCMStringField()
         val right = someStringField()
         val expected = NotEqualsExpression(left.toDopeType(), right)
@@ -266,7 +336,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with StringType CMFieldNumber`() {
+    fun `should support not equals to with StringType CMJsonFieldNumer`() {
         val left = someStringField()
         val right = someCMStringField()
         val expected = NotEqualsExpression(left, right.toDopeType())
@@ -277,7 +347,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with String CMFieldString`() {
+    fun `should support not equals to with String CMJsonFieldString`() {
         val left = someString()
         val right = someCMStringField()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -288,7 +358,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldString String`() {
+    fun `should support not equals to with CMJsonFieldString String`() {
         val left = someCMStringField()
         val right = someString()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -299,7 +369,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldBoolean CMFieldBoolean`() {
+    fun `should support not equals to with CMJsonFieldBoolean CMJsonFieldBoolean`() {
         val left = someCMBooleanField()
         val right = someCMBooleanField()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -310,7 +380,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldBoolean BooleanType`() {
+    fun `should support not equals to with CMJsonFieldBoolean BooleanType`() {
         val left = someCMBooleanField()
         val right = someBooleanField()
         val expected = NotEqualsExpression(left.toDopeType(), right)
@@ -321,7 +391,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with BooleanType CMFieldBoolean`() {
+    fun `should support not equals to with BooleanType CMJsonFieldBoolean`() {
         val left = someBooleanField()
         val right = someCMBooleanField()
         val expected = NotEqualsExpression(left, right.toDopeType())
@@ -332,7 +402,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with Boolean CMFieldBoolean`() {
+    fun `should support not equals to with Boolean CMJsonFieldBoolean`() {
         val left = someBoolean()
         val right = someCMBooleanField()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
@@ -343,7 +413,7 @@ class EqualsTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not equals to with CMFieldBoolean Boolean`() {
+    fun `should support not equals to with CMJsonFieldBoolean Boolean`() {
         val left = someCMBooleanField()
         val right = someBoolean()
         val expected = NotEqualsExpression(left.toDopeType(), right.toDopeType())
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterOrEqualThanTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterOrEqualThanTest.kt
index a4184a80..77a7d7af 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterOrEqualThanTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterOrEqualThanTest.kt
@@ -3,8 +3,11 @@ package ch.ergon.dope.extensions.type.relational
 import ch.ergon.dope.DopeQueryManager
 import ch.ergon.dope.extension.type.relational.isGreaterOrEqualThan
 import ch.ergon.dope.helper.ManagerDependentTest
+import ch.ergon.dope.helper.someCMConverterNumberField
+import ch.ergon.dope.helper.someCMConverterStringField
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMStringField
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someString
@@ -19,7 +22,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support greater or equal than with CMFieldNumber CMFieldNumber`() {
+    fun `should support greater or equal than with CMJsonFieldNumber CMJsonFieldNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -30,7 +33,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with CMFieldNumber NumberType`() {
+    fun `should support greater or equal than with CMJsonFieldNumber NumberType`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right)
@@ -41,7 +44,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with NumberType CMFieldNumber`() {
+    fun `should support greater or equal than with NumberType CMJsonFieldNumer`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = GreaterOrEqualThanExpression(left, right.toDopeType())
@@ -52,7 +55,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with Number CMFieldNumber`() {
+    fun `should support greater or equal than with Number CMJsonFieldNumber`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -63,7 +66,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with CMFieldNumber Number`() {
+    fun `should support greater or equal than with CMJsonFieldNumber Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -74,7 +77,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with CMFieldString CMFieldString`() {
+    fun `should support greater or equal than with CMJsonFieldString CMJsonFieldString`() {
         val left = someCMStringField()
         val right = someCMStringField()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -85,7 +88,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with CMFieldString StringType`() {
+    fun `should support greater or equal than with CMJsonFieldString StringType`() {
         val left = someCMStringField()
         val right = someStringField()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right)
@@ -96,7 +99,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with StringType CMFieldNumber`() {
+    fun `should support greater or equal than with StringType CMJsonFieldNumer`() {
         val left = someStringField()
         val right = someCMStringField()
         val expected = GreaterOrEqualThanExpression(left, right.toDopeType())
@@ -107,7 +110,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with String CMFieldString`() {
+    fun `should support greater or equal than with String CMJsonFieldString`() {
         val left = someString()
         val right = someCMStringField()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -118,7 +121,7 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater or equal than with CMFieldString String`() {
+    fun `should support greater or equal than with CMJsonFieldString String`() {
         val left = someCMStringField()
         val right = someString()
         val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -127,4 +130,48 @@ class GreaterOrEqualThanTest : ManagerDependentTest {
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
+
+    @Test
+    fun `should support greater or equal than with CMConverterNumberField date`() {
+        val left = someCMConverterNumberField()
+        val right = someDate()
+        val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toInstant().epochSecond.toDopeType())
+
+        val actual = left.isGreaterOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support greater or equal than with date CMConverterNumberField`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = GreaterOrEqualThanExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.isGreaterOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support greater or equal than with CMConverterStringField date`() {
+        val left = someCMConverterStringField()
+        val right = someDate()
+        val expected = GreaterOrEqualThanExpression(left.toDopeType(), right.toInstant().epochSecond.toString().toDopeType())
+
+        val actual = left.isGreaterOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support greater or equal than with date CMConverterStringField`() {
+        val left = someDate()
+        val right = someCMConverterStringField()
+        val expected = GreaterOrEqualThanExpression(left.toInstant().epochSecond.toString().toDopeType(), right.toDopeType())
+
+        val actual = left.isGreaterOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterThanTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterThanTest.kt
index d9c5b3b9..66b3c1fa 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterThanTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/GreaterThanTest.kt
@@ -3,8 +3,11 @@ package ch.ergon.dope.extensions.type.relational
 import ch.ergon.dope.DopeQueryManager
 import ch.ergon.dope.extension.type.relational.isGreaterThan
 import ch.ergon.dope.helper.ManagerDependentTest
+import ch.ergon.dope.helper.someCMConverterNumberField
+import ch.ergon.dope.helper.someCMConverterStringField
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMStringField
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someString
@@ -19,7 +22,7 @@ class GreaterThanTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support greater than with CMFieldNumber CMFieldNumber`() {
+    fun `should support greater than with CMJsonFieldNumber CMJsonFieldNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = GreaterThanExpression(left.toDopeType(), right.toDopeType())
@@ -30,7 +33,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with CMFieldNumber NumberType`() {
+    fun `should support greater than with CMJsonFieldNumber NumberType`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = GreaterThanExpression(left.toDopeType(), right)
@@ -41,7 +44,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with NumberType CMFieldNumber`() {
+    fun `should support greater than with NumberType CMJsonFieldNumer`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = GreaterThanExpression(left, right.toDopeType())
@@ -52,7 +55,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with Number CMFieldNumber`() {
+    fun `should support greater than with Number CMJsonFieldNumber`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = GreaterThanExpression(left.toDopeType(), right.toDopeType())
@@ -63,7 +66,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with CMFieldNumber Number`() {
+    fun `should support greater than with CMJsonFieldNumber Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = GreaterThanExpression(left.toDopeType(), right.toDopeType())
@@ -74,7 +77,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with CMFieldString CMFieldString`() {
+    fun `should support greater than with CMJsonFieldString CMJsonFieldString`() {
         val left = someCMStringField()
         val right = someCMStringField()
         val expected = GreaterThanExpression(left.toDopeType(), right.toDopeType())
@@ -85,7 +88,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with CMFieldString StringType`() {
+    fun `should support greater than with CMJsonFieldString StringType`() {
         val left = someCMStringField()
         val right = someStringField()
         val expected = GreaterThanExpression(left.toDopeType(), right)
@@ -96,7 +99,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with StringType CMFieldNumber`() {
+    fun `should support greater than with StringType CMJsonFieldNumer`() {
         val left = someStringField()
         val right = someCMStringField()
         val expected = GreaterThanExpression(left, right.toDopeType())
@@ -107,7 +110,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with String CMFieldString`() {
+    fun `should support greater than with String CMJsonFieldString`() {
         val left = someString()
         val right = someCMStringField()
         val expected = GreaterThanExpression(left.toDopeType(), right.toDopeType())
@@ -118,7 +121,7 @@ class GreaterThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support greater than with CMFieldString String`() {
+    fun `should support greater than with CMJsonFieldString String`() {
         val left = someCMStringField()
         val right = someString()
         val expected = GreaterThanExpression(left.toDopeType(), right.toDopeType())
@@ -127,4 +130,48 @@ class GreaterThanTest : ManagerDependentTest {
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
+
+    @Test
+    fun `should support greater than with CMConverterNumberField date`() {
+        val left = someCMConverterNumberField()
+        val right = someDate()
+        val expected = GreaterThanExpression(left.toDopeType(), right.toInstant().epochSecond.toDopeType())
+
+        val actual = left.isGreaterThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support greater than with date CMConverterNumberField`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = GreaterThanExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.isGreaterThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support greater than with CMConverterStringField date`() {
+        val left = someCMConverterStringField()
+        val right = someDate()
+        val expected = GreaterThanExpression(left.toDopeType(), right.toInstant().epochSecond.toString().toDopeType())
+
+        val actual = left.isGreaterThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support greater than with date CMConverterStringField`() {
+        val left = someDate()
+        val right = someCMConverterStringField()
+        val expected = GreaterThanExpression(left.toInstant().epochSecond.toString().toDopeType(), right.toDopeType())
+
+        val actual = left.isGreaterThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/InTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/InTest.kt
index 16f24a20..a57b508b 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/InTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/InTest.kt
@@ -9,10 +9,14 @@ import ch.ergon.dope.helper.someBooleanField
 import ch.ergon.dope.helper.someBooleanFieldList
 import ch.ergon.dope.helper.someCMBooleanField
 import ch.ergon.dope.helper.someCMBooleanList
+import ch.ergon.dope.helper.someCMConverterBooleanList
+import ch.ergon.dope.helper.someCMConverterNumberList
+import ch.ergon.dope.helper.someCMConverterStringList
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMNumberList
 import ch.ergon.dope.helper.someCMStringField
 import ch.ergon.dope.helper.someCMStringList
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someNumberFieldList
@@ -30,7 +34,7 @@ class InTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support in array with CMFieldNumber ListNumber`() {
+    fun `should support in array with CMJsonFieldNumber ListNumber`() {
         val left = someCMNumberField()
         val right = someNumberFieldList()
         val expected = InExpression(left.toDopeType(), right)
@@ -41,7 +45,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldString ListString`() {
+    fun `should support in array with CMJsonFieldString ListString`() {
         val left = someCMStringField()
         val right = someStringFieldList()
         val expected = InExpression(left.toDopeType(), right)
@@ -52,7 +56,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldBoolean ListBoolean`() {
+    fun `should support in array with CMJsonFieldBoolean ListBoolean`() {
         val left = someCMBooleanField()
         val right = someBooleanFieldList()
         val expected = InExpression(left.toDopeType(), right)
@@ -63,7 +67,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldNumber CMListNumber`() {
+    fun `should support in array with CMJsonFieldNumber CMJsonListNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberList()
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -74,7 +78,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldString CMListString`() {
+    fun `should support in array with CMJsonFieldString CMJsonListString`() {
         val left = someCMStringField()
         val right = someCMStringList()
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -85,7 +89,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldBoolean CMListBoolean`() {
+    fun `should support in array with CMJsonFieldBoolean CMJsonListBoolean`() {
         val left = someCMBooleanField()
         val right = someCMBooleanList()
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -96,7 +100,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldNumber Collection`() {
+    fun `should support in array with CMJsonFieldNumber Collection`() {
         val left = someCMNumberField()
         val right = listOf(someNumberField())
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -107,7 +111,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldString Collection`() {
+    fun `should support in array with CMJsonFieldString Collection`() {
         val left = someCMStringField()
         val right = listOf(someStringField())
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -118,7 +122,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with CMFieldBoolean Collection`() {
+    fun `should support in array with CMJsonFieldBoolean Collection`() {
         val left = someCMBooleanField()
         val right = listOf(someBooleanField())
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -129,7 +133,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with Number CMList`() {
+    fun `should support in array with Number CMJsonList`() {
         val left = someNumber()
         val right = someCMNumberList()
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -140,7 +144,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with String CMList`() {
+    fun `should support in array with String CMJsonList`() {
         val left = someString()
         val right = someCMStringList()
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -151,7 +155,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support in array with Boolean CMList`() {
+    fun `should support in array with Boolean CMJsonList`() {
         val left = someBoolean()
         val right = someCMBooleanList()
         val expected = InExpression(left.toDopeType(), right.toDopeType())
@@ -162,7 +166,40 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldNumber ListNumber`() {
+    fun `should support in array with date CMConverterNumberField`() {
+        val left = someDate()
+        val right = someCMConverterNumberList()
+        val expected = InExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.inArray(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support in array with date CMConverterStringField`() {
+        val left = someDate()
+        val right = someCMConverterStringList()
+        val expected = InExpression(left.toInstant().epochSecond.toString().toDopeType(), right.toDopeType())
+
+        val actual = left.inArray(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support in array with date CMConverterBooleanField`() {
+        val left = someDate()
+        val right = someCMConverterBooleanList()
+        val expected = InExpression(true.toDopeType(), right.toDopeType())
+
+        val actual = left.inArray(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support not in array with CMJsonFieldNumber ListNumber`() {
         val left = someCMNumberField()
         val right = someNumberFieldList()
         val expected = NotInExpression(left.toDopeType(), right)
@@ -173,7 +210,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldString ListString`() {
+    fun `should support not in array with CMJsonFieldString ListString`() {
         val left = someCMStringField()
         val right = someStringFieldList()
         val expected = NotInExpression(left.toDopeType(), right)
@@ -184,7 +221,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldBoolean ListBoolean`() {
+    fun `should support not in array with CMJsonFieldBoolean ListBoolean`() {
         val left = someCMBooleanField()
         val right = someBooleanFieldList()
         val expected = NotInExpression(left.toDopeType(), right)
@@ -195,7 +232,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldNumber CMListNumber`() {
+    fun `should support not in array with CMJsonFieldNumber CMJsonListNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberList()
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -206,7 +243,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldString CMListString`() {
+    fun `should support not in array with CMJsonFieldString CMJsonListString`() {
         val left = someCMStringField()
         val right = someCMStringList()
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -217,7 +254,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldBoolean CMListBoolean`() {
+    fun `should support not in array with CMJsonFieldBoolean CMJsonListBoolean`() {
         val left = someCMBooleanField()
         val right = someCMBooleanList()
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -228,7 +265,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldNumber Collection`() {
+    fun `should support not in array with CMJsonFieldNumber Collection`() {
         val left = someCMNumberField()
         val right = listOf(someNumberField())
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -239,7 +276,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldString Collection`() {
+    fun `should support not in array with CMJsonFieldString Collection`() {
         val left = someCMStringField()
         val right = listOf(someStringField())
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -250,7 +287,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with CMFieldBoolean Collection`() {
+    fun `should support not in array with CMJsonFieldBoolean Collection`() {
         val left = someCMBooleanField()
         val right = listOf(someBooleanField())
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -261,7 +298,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with Number CMList`() {
+    fun `should support not in array with Number CMJsonList`() {
         val left = someNumber()
         val right = someCMNumberList()
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -272,7 +309,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with String CMList`() {
+    fun `should support not in array with String CMJsonList`() {
         val left = someString()
         val right = someCMStringList()
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
@@ -283,7 +320,7 @@ class InTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support not in array with Boolean CMList`() {
+    fun `should support not in array with Boolean CMJsonList`() {
         val left = someBoolean()
         val right = someCMBooleanList()
         val expected = NotInExpression(left.toDopeType(), right.toDopeType())
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsMissingTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsMissingTest.kt
index 3f7050f8..6af915a5 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsMissingTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsMissingTest.kt
@@ -17,7 +17,7 @@ class IsMissingTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support isMissing CMFieldNumber`() {
+    fun `should support isMissing CMJsonFieldNumber`() {
         val field = someCMNumberField()
         val expected = IsMissingExpression(field.toDopeType())
 
@@ -27,7 +27,7 @@ class IsMissingTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support isMissing CMFieldString`() {
+    fun `should support isMissing CMJsonFieldString`() {
         val field = someCMStringField()
         val expected = IsMissingExpression(field.toDopeType())
 
@@ -37,7 +37,7 @@ class IsMissingTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support isMissing CMFieldBoolean`() {
+    fun `should support isMissing CMJsonFieldBoolean`() {
         val field = someCMBooleanField()
         val expected = IsMissingExpression(field.toDopeType())
 
@@ -47,7 +47,7 @@ class IsMissingTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Missing CMFieldNumber`() {
+    fun `should support is not Missing CMJsonFieldNumber`() {
         val field = someCMNumberField()
         val expected = IsNotMissingExpression(field.toDopeType())
 
@@ -57,7 +57,7 @@ class IsMissingTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Missing CMFieldString`() {
+    fun `should support is not Missing CMJsonFieldString`() {
         val field = someCMStringField()
         val expected = IsNotMissingExpression(field.toDopeType())
 
@@ -67,7 +67,7 @@ class IsMissingTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Missing CMFieldBoolean`() {
+    fun `should support is not Missing CMJsonFieldBoolean`() {
         val field = someCMBooleanField()
         val expected = IsNotMissingExpression(field.toDopeType())
 
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsNullTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsNullTest.kt
index c43f1f8b..a7a48be2 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsNullTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsNullTest.kt
@@ -17,7 +17,7 @@ class IsNullTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support is Null CMFieldNumber`() {
+    fun `should support is Null CMJsonFieldNumber`() {
         val field = someCMNumberField()
         val expected = IsNullExpression(field.toDopeType())
 
@@ -27,7 +27,7 @@ class IsNullTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is Null CMFieldString`() {
+    fun `should support is Null CMJsonFieldString`() {
         val field = someCMStringField()
         val expected = IsNullExpression(field.toDopeType())
 
@@ -37,7 +37,7 @@ class IsNullTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is Null CMFieldBoolean`() {
+    fun `should support is Null CMJsonFieldBoolean`() {
         val field = someCMBooleanField()
         val expected = IsNullExpression(field.toDopeType())
 
@@ -47,7 +47,7 @@ class IsNullTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Null CMFieldNumber`() {
+    fun `should support is not Null CMJsonFieldNumber`() {
         val field = someCMNumberField()
         val expected = IsNotNullExpression(field.toDopeType())
 
@@ -57,7 +57,7 @@ class IsNullTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Null CMFieldString`() {
+    fun `should support is not Null CMJsonFieldString`() {
         val field = someCMStringField()
         val expected = IsNotNullExpression(field.toDopeType())
 
@@ -67,7 +67,7 @@ class IsNullTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Null CMFieldBoolean`() {
+    fun `should support is not Null CMJsonFieldBoolean`() {
         val field = someCMBooleanField()
         val expected = IsNotNullExpression(field.toDopeType())
 
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsValuedTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsValuedTest.kt
index 5cd52886..467a89df 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsValuedTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/IsValuedTest.kt
@@ -17,7 +17,7 @@ class IsValuedTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support  Valued CMFieldNumber`() {
+    fun `should support  Valued CMJsonFieldNumber`() {
         val field = someCMNumberField()
         val expected = IsValuedExpression(field.toDopeType())
 
@@ -27,7 +27,7 @@ class IsValuedTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support  Valued CMFieldString`() {
+    fun `should support  Valued CMJsonFieldString`() {
         val field = someCMStringField()
         val expected = IsValuedExpression(field.toDopeType())
 
@@ -37,7 +37,7 @@ class IsValuedTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support  Valued CMFieldBoolean`() {
+    fun `should support  Valued CMJsonFieldBoolean`() {
         val field = someCMBooleanField()
         val expected = IsValuedExpression(field.toDopeType())
 
@@ -47,7 +47,7 @@ class IsValuedTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Valued CMFieldNumber`() {
+    fun `should support is not Valued CMJsonFieldNumber`() {
         val field = someCMNumberField()
         val expected = IsNotValuedExpression(field.toDopeType())
 
@@ -57,7 +57,7 @@ class IsValuedTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Valued CMFieldString`() {
+    fun `should support is not Valued CMJsonFieldString`() {
         val field = someCMStringField()
         val expected = IsNotValuedExpression(field.toDopeType())
 
@@ -67,7 +67,7 @@ class IsValuedTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support is not Valued CMFieldBoolean`() {
+    fun `should support is not Valued CMJsonFieldBoolean`() {
         val field = someCMBooleanField()
         val expected = IsNotValuedExpression(field.toDopeType())
 
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessOrEqualThanTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessOrEqualThanTest.kt
index 75bedb50..4c55ff66 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessOrEqualThanTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessOrEqualThanTest.kt
@@ -3,8 +3,11 @@ package ch.ergon.dope.extensions.type.relational
 import ch.ergon.dope.DopeQueryManager
 import ch.ergon.dope.extension.type.relational.isLessOrEqualThan
 import ch.ergon.dope.helper.ManagerDependentTest
+import ch.ergon.dope.helper.someCMConverterNumberField
+import ch.ergon.dope.helper.someCMConverterStringField
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMStringField
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someString
@@ -19,7 +22,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support less or equal than with CMFieldNumber CMFieldNumber`() {
+    fun `should support less or equal than with CMJsonFieldNumber CMJsonFieldNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -30,7 +33,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with CMFieldNumber NumberType`() {
+    fun `should support less or equal than with CMJsonFieldNumber NumberType`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right)
@@ -41,7 +44,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with NumberType CMFieldNumber`() {
+    fun `should support less or equal than with NumberType CMJsonFieldNumer`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = LessOrEqualThanExpression(left, right.toDopeType())
@@ -52,7 +55,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with Number CMFieldNumber`() {
+    fun `should support less or equal than with Number CMJsonFieldNumber`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -63,7 +66,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with CMFieldNumber Number`() {
+    fun `should support less or equal than with CMJsonFieldNumber Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -74,7 +77,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with CMFieldString CMFieldString`() {
+    fun `should support less or equal than with CMJsonFieldString CMJsonFieldString`() {
         val left = someCMStringField()
         val right = someCMStringField()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -85,7 +88,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with CMFieldString StringType`() {
+    fun `should support less or equal than with CMJsonFieldString StringType`() {
         val left = someCMStringField()
         val right = someStringField()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right)
@@ -96,7 +99,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with StringType CMFieldNumber`() {
+    fun `should support less or equal than with StringType CMJsonFieldNumer`() {
         val left = someStringField()
         val right = someCMStringField()
         val expected = LessOrEqualThanExpression(left, right.toDopeType())
@@ -107,7 +110,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with String CMFieldString`() {
+    fun `should support less or equal than with String CMJsonFieldString`() {
         val left = someString()
         val right = someCMStringField()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -118,7 +121,7 @@ class LessOrEqualThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less or equal than with CMFieldString String`() {
+    fun `should support less or equal than with CMJsonFieldString String`() {
         val left = someCMStringField()
         val right = someString()
         val expected = LessOrEqualThanExpression(left.toDopeType(), right.toDopeType())
@@ -127,4 +130,48 @@ class LessOrEqualThanTest : ManagerDependentTest {
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
+
+    @Test
+    fun `should support less or equal than with CMConverterNumberField date`() {
+        val left = someCMConverterNumberField()
+        val right = someDate()
+        val expected = LessOrEqualThanExpression(left.toDopeType(), right.toInstant().epochSecond.toDopeType())
+
+        val actual = left.isLessOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support less or equal than with date CMConverterNumberField`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = LessOrEqualThanExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.isLessOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support less or equal than with CMConverterStringField date`() {
+        val left = someCMConverterStringField()
+        val right = someDate()
+        val expected = LessOrEqualThanExpression(left.toDopeType(), right.toInstant().epochSecond.toString().toDopeType())
+
+        val actual = left.isLessOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support less or equal than with date CMConverterStringField`() {
+        val left = someDate()
+        val right = someCMConverterStringField()
+        val expected = LessOrEqualThanExpression(left.toInstant().epochSecond.toString().toDopeType(), right.toDopeType())
+
+        val actual = left.isLessOrEqualThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessThanTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessThanTest.kt
index fcd9d2d4..a0c40c2e 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessThanTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LessThanTest.kt
@@ -3,8 +3,11 @@ package ch.ergon.dope.extensions.type.relational
 import ch.ergon.dope.DopeQueryManager
 import ch.ergon.dope.extension.type.relational.isLessThan
 import ch.ergon.dope.helper.ManagerDependentTest
+import ch.ergon.dope.helper.someCMConverterNumberField
+import ch.ergon.dope.helper.someCMConverterStringField
 import ch.ergon.dope.helper.someCMNumberField
 import ch.ergon.dope.helper.someCMStringField
+import ch.ergon.dope.helper.someDate
 import ch.ergon.dope.helper.someNumber
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someString
@@ -19,7 +22,7 @@ class LessThanTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support less than with CMFieldNumber CMFieldNumber`() {
+    fun `should support less than with CMJsonFieldNumber CMJsonFieldNumber`() {
         val left = someCMNumberField()
         val right = someCMNumberField()
         val expected = LessThanExpression(left.toDopeType(), right.toDopeType())
@@ -30,7 +33,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with CMFieldNumber NumberType`() {
+    fun `should support less than with CMJsonFieldNumber NumberType`() {
         val left = someCMNumberField()
         val right = someNumberField()
         val expected = LessThanExpression(left.toDopeType(), right)
@@ -41,7 +44,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with NumberType CMFieldNumber`() {
+    fun `should support less than with NumberType CMJsonFieldNumer`() {
         val left = someNumberField()
         val right = someCMNumberField()
         val expected = LessThanExpression(left, right.toDopeType())
@@ -52,7 +55,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with Number CMFieldNumber`() {
+    fun `should support less than with Number CMJsonFieldNumber`() {
         val left = someNumber()
         val right = someCMNumberField()
         val expected = LessThanExpression(left.toDopeType(), right.toDopeType())
@@ -63,7 +66,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with CMFieldNumber Number`() {
+    fun `should support less than with CMJsonFieldNumber Number`() {
         val left = someCMNumberField()
         val right = someNumber()
         val expected = LessThanExpression(left.toDopeType(), right.toDopeType())
@@ -74,7 +77,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with CMFieldString CMFieldString`() {
+    fun `should support less than with CMJsonFieldString CMJsonFieldString`() {
         val left = someCMStringField()
         val right = someCMStringField()
         val expected = LessThanExpression(left.toDopeType(), right.toDopeType())
@@ -85,7 +88,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with CMFieldString StringType`() {
+    fun `should support less than with CMJsonFieldString StringType`() {
         val left = someCMStringField()
         val right = someStringField()
         val expected = LessThanExpression(left.toDopeType(), right)
@@ -96,7 +99,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with StringType CMFieldNumber`() {
+    fun `should support less than with StringType CMJsonFieldNumer`() {
         val left = someStringField()
         val right = someCMStringField()
         val expected = LessThanExpression(left, right.toDopeType())
@@ -107,7 +110,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with String CMFieldString`() {
+    fun `should support less than with String CMJsonFieldString`() {
         val left = someString()
         val right = someCMStringField()
         val expected = LessThanExpression(left.toDopeType(), right.toDopeType())
@@ -118,7 +121,7 @@ class LessThanTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support less than with CMFieldString String`() {
+    fun `should support less than with CMJsonFieldString String`() {
         val left = someCMStringField()
         val right = someString()
         val expected = LessThanExpression(left.toDopeType(), right.toDopeType())
@@ -127,4 +130,48 @@ class LessThanTest : ManagerDependentTest {
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
+
+    @Test
+    fun `should support less than with CMConverterNumberField date`() {
+        val left = someCMConverterNumberField()
+        val right = someDate()
+        val expected = LessThanExpression(left.toDopeType(), right.toInstant().epochSecond.toDopeType())
+
+        val actual = left.isLessThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support less than with date CMConverterNumberField`() {
+        val left = someDate()
+        val right = someCMConverterNumberField()
+        val expected = LessThanExpression(left.toInstant().epochSecond.toDopeType(), right.toDopeType())
+
+        val actual = left.isLessThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support less than with CMConverterStringField date`() {
+        val left = someCMConverterStringField()
+        val right = someDate()
+        val expected = LessThanExpression(left.toDopeType(), right.toInstant().epochSecond.toString().toDopeType())
+
+        val actual = left.isLessThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support less than with date CMConverterStringField`() {
+        val left = someDate()
+        val right = someCMConverterStringField()
+        val expected = LessThanExpression(left.toInstant().epochSecond.toString().toDopeType(), right.toDopeType())
+
+        val actual = left.isLessThan(right)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LikeTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LikeTest.kt
index 530d2e0b..1a96f59f 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LikeTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/LikeTest.kt
@@ -16,7 +16,7 @@ class LikeTest : ManagerDependentTest {
     override lateinit var manager: DopeQueryManager
 
     @Test
-    fun `should support extensions for is like with CMField`() {
+    fun `should support extensions for is like with CMJsonField`() {
         val someCMStringField = someCMStringField()
         val right = "%".toDopeType()
         val expected = LikeExpression(someCMStringField.toDopeType(), right)
@@ -27,7 +27,7 @@ class LikeTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support extensions for is not like with CMField`() {
+    fun `should support extensions for is not like with CMJsonField`() {
         val someCMStringField = someCMStringField()
         val right = "%".toDopeType()
         val expected = NotLikeExpression(someCMStringField.toDopeType(), right)
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/SatisfiesTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/SatisfiesTest.kt
index 7bdd8739..fb94e356 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/SatisfiesTest.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/type/relational/SatisfiesTest.kt
@@ -10,8 +10,8 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.arithmetic.mod
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction.upper
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isEqualTo
 import ch.ergon.dope.toDopeType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMObjectList
 import com.schwarz.crystalapi.schema.Schema
 import kotlin.test.Test
@@ -22,18 +22,18 @@ class SatisfiesTest : ManagerDependentTest {
 
     class Dummy(path: String = "") : Schema {
         val objectList: CMObjectList<Dummy2> = CMObjectList(Dummy2(path), "objectList", path)
-        val stringList: CMList<String> = CMList("stringList", path)
-        val numberList: CMList<Number> = CMList("numberList", path)
-        val booleanList: CMList<Boolean> = CMList("booleanList", path)
+        val stringList: CMJsonList<String> = CMJsonList("stringList", path)
+        val numberList: CMJsonList<Number> = CMJsonList("numberList", path)
+        val booleanList: CMJsonList<Boolean> = CMJsonList("booleanList", path)
     }
 
     class Dummy2(path: String = "") : Schema {
-        val type: CMField<String> = CMField("type", path)
+        val type: CMJsonField<String> = CMJsonField("type", path)
         val otherObjectList: CMObjectList<Dummy3> = CMObjectList(Dummy3(path), "otherObjectList", path)
     }
 
     class Dummy3(path: String = "") : Schema {
-        val something: CMField<Number> = CMField("something", path)
+        val something: CMJsonField<Number> = CMJsonField("something", path)
     }
 
     @Test
@@ -65,7 +65,7 @@ class SatisfiesTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support any satisfies with cmList number`() {
+    fun `should support any satisfies with CMJsonList number`() {
         val expected = DopeQuery(
             queryString = "ANY `iterator1` IN `numberList` SATISFIES (`iterator1` % 2) = 1 END",
             parameters = emptyMap(),
@@ -77,7 +77,7 @@ class SatisfiesTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support any satisfies with cmList string`() {
+    fun `should support any satisfies with CMJsonList string`() {
         val expected = DopeQuery(
             queryString = "ANY `iterator1` IN `stringList` SATISFIES UPPER(`iterator1`) = \"some value\" END",
             parameters = emptyMap(),
@@ -89,7 +89,7 @@ class SatisfiesTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support any satisfies with cmList boolean`() {
+    fun `should support any satisfies with CMJsonList boolean`() {
         val expected = DopeQuery(
             queryString = "ANY `iterator1` IN `booleanList` SATISFIES `iterator1` END",
             parameters = emptyMap(),
@@ -144,7 +144,7 @@ class SatisfiesTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support every satisfies with cmList number`() {
+    fun `should support every satisfies with CMJsonList number`() {
         val expected = DopeQuery(
             queryString = "EVERY `iterator1` IN `numberList` SATISFIES (`iterator1` % 2) = 1 END",
             parameters = emptyMap(),
@@ -156,7 +156,7 @@ class SatisfiesTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support every satisfies with cmList string`() {
+    fun `should support every satisfies with CMJsonList string`() {
         val expected = DopeQuery(
             queryString = "EVERY `iterator1` IN `stringList` SATISFIES UPPER(`iterator1`) = \"some value\" END",
             parameters = emptyMap(),
@@ -168,7 +168,7 @@ class SatisfiesTest : ManagerDependentTest {
     }
 
     @Test
-    fun `should support every satisfies with cmList boolean`() {
+    fun `should support every satisfies with CMJsonList boolean`() {
         val expected = DopeQuery(
             queryString = "EVERY `iterator1` IN `booleanList` SATISFIES `iterator1` END",
             parameters = emptyMap(),
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/helper/Builder.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/helper/Builder.kt
index f1f12f83..555dea46 100644
--- a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/helper/Builder.kt
+++ b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/helper/Builder.kt
@@ -15,22 +15,44 @@ import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
-import com.schwarz.crystalapi.schema.CMField
-import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.ITypeConverter
+import com.schwarz.crystalapi.schema.CMConverterField
+import com.schwarz.crystalapi.schema.CMConverterList
+import com.schwarz.crystalapi.schema.CMJsonField
+import com.schwarz.crystalapi.schema.CMJsonList
+import java.time.Instant
+import java.util.*
 
 fun someBucket(name: String = "someBucket") = UnaliasedBucket(name)
 
-fun someCMNumberField(name: String = "CMNumberField", path: String = "") = CMField<Number>(name, path)
-fun someCMStringField(name: String = "CMStringField", path: String = "") = CMField<String>(name, path)
-fun someCMBooleanField(name: String = "CMBooleanField", path: String = "") = CMField<Boolean>(name, path)
+fun someCMNumberField(name: String = "CMNumberField", path: String = "") = CMJsonField<Number>(name, path)
+fun someCMStringField(name: String = "CMStringField", path: String = "") = CMJsonField<String>(name, path)
+fun someCMBooleanField(name: String = "CMBooleanField", path: String = "") = CMJsonField<Boolean>(name, path)
+
+fun someCMConverterNumberField(name: String = "CMConverterNumberField", path: String = "") =
+    CMConverterField(name, path, DateNumberConverterInstance)
+fun someCMConverterStringField(name: String = "CMConverterStringField", path: String = "") =
+    CMConverterField(name, path, DateStringConverterInstance)
+fun someCMConverterBooleanField(name: String = "CMConverterBooleanField", path: String = "") =
+    CMConverterField(name, path, DateBooleanConverterInstance)
+
+fun someCorruptField(name: String = "corruptField", path: String = "") =
+    CMConverterField(name, path, CorruptStringNumberConverterInstance)
 
 fun someNumberFieldList(name: String = "numberFieldList", path: String = "") = Field<ArrayType<NumberType>>(name, path)
 fun someStringFieldList(name: String = "stringFieldList", path: String = "") = Field<ArrayType<StringType>>(name, path)
 fun someBooleanFieldList(name: String = "booleanFieldList", path: String = "") = Field<ArrayType<BooleanType>>(name, path)
 
-fun someCMNumberList(name: String = "CMNumberList", path: String = "") = CMList<Number>(name, path)
-fun someCMStringList(name: String = "CMStringList", path: String = "") = CMList<String>(name, path)
-fun someCMBooleanList(name: String = "CMBooleanList", path: String = "") = CMList<Boolean>(name, path)
+fun someCMNumberList(name: String = "CMNumberList", path: String = "") = CMJsonList<Number>(name, path)
+fun someCMStringList(name: String = "CMStringList", path: String = "") = CMJsonList<String>(name, path)
+fun someCMBooleanList(name: String = "CMBooleanList", path: String = "") = CMJsonList<Boolean>(name, path)
+
+fun someCMConverterNumberList(name: String = "CMConverterNumberList", path: String = "") =
+    CMConverterList(name, path, DateNumberConverterInstance)
+fun someCMConverterStringList(name: String = "CMConverterStringList", path: String = "") =
+    CMConverterList(name, path, DateStringConverterInstance)
+fun someCMConverterBooleanList(name: String = "CMConverterBooleanList", path: String = "") =
+    CMConverterList(name, path, DateBooleanConverterInstance)
 
 fun someSelect(expression: Expression = AsteriskExpression()) = SelectClause(expression)
 fun someFrom(fromable: Fromable = someBucket(), selectClause: SelectClause = someSelect()) = FromClause(fromable, selectClause)
@@ -45,6 +67,8 @@ fun someString(value: String = "someString") = value
 
 fun someBoolean(value: Boolean = true) = value
 
+fun someDate(value: Date = Date(12345)) = value
+
 fun someNumberField(name: String = "numberField", bucket: Bucket = someBucket("")) = Field<NumberType>(name, getBucketName(bucket))
 fun someStringField(name: String = "stringField", bucket: Bucket = someBucket("")) = Field<StringType>(name, getBucketName(bucket))
 fun someBooleanField(name: String = "booleanField", bucket: Bucket = someBucket("")) = Field<BooleanType>(name, getBucketName(bucket))
@@ -53,3 +77,37 @@ private fun getBucketName(bucket: Bucket) = when (bucket) {
     is AliasedBucket -> bucket.alias
     is UnaliasedBucket -> bucket.name
 }
+
+object DateNumberConverterInstance : DateNumberConverter()
+
+abstract class DateNumberConverter : ITypeConverter<Date, Number> {
+    override fun write(value: Date?): Number? =
+        value?.toInstant()?.epochSecond
+
+    override fun read(value: Number?): Date? = value?.toLong()?.let { Date.from(Instant.ofEpochSecond(it)) }
+}
+
+object DateStringConverterInstance : DateStringConverter()
+
+abstract class DateStringConverter : ITypeConverter<Date, String> {
+    override fun write(value: Date?): String? =
+        value?.toInstant()?.epochSecond.toString()
+
+    override fun read(value: String?): Date? = value?.toLong()?.let { Date.from(Instant.ofEpochSecond(it)) }
+}
+
+object DateBooleanConverterInstance : DateBooleanConverter()
+
+abstract class DateBooleanConverter : ITypeConverter<Date, Boolean> {
+    override fun write(value: Date?): Boolean? = value != null
+
+    override fun read(value: Boolean?): Date? = Date(1)
+}
+
+object CorruptStringNumberConverterInstance : CorruptStringNumberConverter()
+
+abstract class CorruptStringNumberConverter : ITypeConverter<String, Number> {
+    override fun write(value: String?) = null
+
+    override fun read(value: Number?) = null
+}