diff --git a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Any.kt b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Any.kt
index 8fbe9975..4186b547 100644
--- a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Any.kt
+++ b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Any.kt
@@ -22,14 +22,116 @@ import dev.nesk.akkurate.constraints.constrain
 import dev.nesk.akkurate.constraints.otherwise
 import dev.nesk.akkurate.validatables.Validatable
 
+/**
+ * The validatable value must be null when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Int?> { isNull() }
+ * validate(null) // Success
+ * validate(1234) // Failure (message: Must be null)
+ * ```
+ */
 public fun <T> Validatable<T?>.isNull(): Constraint = constrain { it == null } otherwise { "Must be null" }
+
+/**
+ * The validatable value must not be null when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Int?> { isNotNull() }
+ * validate(1234) // Success
+ * validate(null) // Failure (message: Must not be null)
+ * ```
+ */
 public fun <T> Validatable<T?>.isNotNull(): Constraint = constrain { it != null } otherwise { "Must not be null" }
 
+/**
+ * The validatable value must be equal to [other] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<String> { isEqualTo("foo") }
+ * validate("foo") // Success
+ * validate("bar") // Failure (message: Must be equal to "foo")
+ * ```
+ */
 public fun <T> Validatable<T?>.isEqualTo(other: T?): Constraint = constrain { it == other } otherwise { "Must be equal to \"$other\"" }
+
+/**
+ * The validatable value must be equal to [other] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Pair<String, String>> { first.isEqualTo(second) }
+ * validate("foo" to "foo") // Success
+ * validate("foo" to "bar") // Failure (message: Must be equal to "bar")
+ * ```
+ */
 public fun <T> Validatable<T?>.isEqualTo(other: Validatable<T>): Constraint = constrain { it == other.unwrap() } otherwise { "Must be equal to \"${other.unwrap()}\"" }
 
+/**
+ * The validatable value must be different from [other] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<String> { isNotEqualTo("foo") }
+ * validate("bar") // Success
+ * validate("foo") // Failure (message: Must be different from "foo")
+ * ```
+ */
 public fun <T> Validatable<T?>.isNotEqualTo(other: T?): Constraint = constrain { it != other } otherwise { "Must be different from \"$other\"" }
+
+/**
+ * The validatable value must be different from [other] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Pair<String, String>> { first.isNotEqualTo(second) }
+ * validate("foo" to "bar") // Success
+ * validate("foo" to "foo") // Failure (message: Must be different from "foo")
+ * ```
+ */
 public fun <T> Validatable<T?>.isNotEqualTo(other: Validatable<T>): Constraint = constrain { it != other.unwrap() } otherwise { "Must be different from \"${other.unwrap()}\"" }
 
+/**
+ * The validatable value must be identical to [other] when this constraint is applied.
+ *
+ * The values are considered identical [if they are referentially equal.](https://kotlinlang.org/docs/equality.html#referential-equality)
+ *
+ * Code example:
+ *
+ * ```
+ * data object Foo
+ * data object Bar
+ *
+ * val validate = Validator<Any> { isIdenticalTo(Foo) }
+ * validate(Foo) // Success
+ * validate(Bar) // Failure (message: Must be identical to "Foo")
+ * ```
+ */
 public fun <T> Validatable<T?>.isIdenticalTo(other: T?): Constraint = constrain { it === other } otherwise { "Must be identical to \"$other\"" }
+
+/**
+ * The validatable value must not be identical to [other] when this constraint is applied.
+ *
+ * The values are considered not identical [if they are not referentially equal.](https://kotlinlang.org/docs/equality.html#referential-equality)
+ *
+ * Code example:
+ *
+ * ```
+ * data object Foo
+ * data object Bar
+ *
+ * val validate = Validator<Any> { isNotIdenticalTo(Foo) }
+ * validate(Bar) // Success
+ * validate(Foo) // Failure (message: Must not be identical to "Foo")
+ * ```
+ */
 public fun <T> Validatable<T?>.isNotIdenticalTo(other: T?): Constraint = constrain { it !== other } otherwise { "Must not be identical to \"$other\"" }
diff --git a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Array.kt b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Array.kt
index 84740579..d9e28ee7 100644
--- a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Array.kt
+++ b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Array.kt
@@ -31,46 +31,171 @@ import dev.nesk.akkurate.validatables.Validatable
  * union types in Kotlin, we must duplicate the code for each of those types.
  */
 
+/**
+ * The validatable [Array] must be empty when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { isNotEmpty() }
+ * validate(arrayOf('a', 'b', 'c')) // Success
+ * validate(emptyArray()) // Failure (message: Must not be empty)
+ * ```
+ */
 @JvmName("arrayIsEmpty")
 public fun <T> Validatable<Array<out T>?>.isEmpty(): Constraint =
     constrainIfNotNull { it.isEmpty() } otherwise { "Must be empty" }
 
+/**
+ * The validatable [Array] must not be empty when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { isEmpty() }
+ * validate(emptyArray()) // Success
+ * validate(arrayOf('a', 'b', 'c')) // Failure (message: Must be empty)
+ * ```
+ */
 @JvmName("arrayIsNotEmpty")
 public fun <T> Validatable<Array<out T>?>.isNotEmpty(): Constraint =
     constrainIfNotNull { it.isNotEmpty() } otherwise { "Must not be empty" }
 
+/**
+ * The validatable [Array] must have a size equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { hasSizeEqualTo(3) }
+ * validate(arrayOf('a', 'b', 'c')) // Success
+ * validate(arrayOf('a', 'b')) // Failure (message: The number of items must be equal to 3)
+ * ```
+ */
 @JvmName("arrayHasSizeEqualTo")
 public fun <T> Validatable<Array<out T>?>.hasSizeEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size == size } otherwise { "The number of items must be equal to $size" }
 
+/**
+ * The validatable [Array] must have a size different from [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { hasSizeNotEqualTo(3) }
+ * validate(arrayOf('a', 'b')) // Success
+ * validate(arrayOf('a', 'b', 'c')) // Failure (message: The number of items must be different from 3)
+ * ```
+ */
 @JvmName("arrayHasSizeNotEqualTo")
 public fun <T> Validatable<Array<out T>?>.hasSizeNotEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size != size } otherwise { "The number of items must be different from $size" }
 
+/**
+ * The validatable [Array] must have a size lower than [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { hasSizeLowerThan(3) }
+ * validate(arrayOf('a', 'b')) // Success
+ * validate(arrayOf('a', 'b', 'c')) // Failure (message: The number of items must be lower than 3)
+ * ```
+ */
 @JvmName("arrayHasSizeLowerThan")
 public fun <T> Validatable<Array<out T>?>.hasSizeLowerThan(size: Int): Constraint =
     constrainIfNotNull { it.size < size } otherwise { "The number of items must be lower than $size" }
 
+/**
+ * The validatable [Array] must have a size lower than or equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { hasSizeLowerThanOrEqualTo(2) }
+ * validate(arrayOf('a')) // Success
+ * validate(arrayOf('a', 'b')) // Success
+ * validate(arrayOf('a', 'b', 'c')) // Failure (message: The number of items must be lower than or equal to 2)
+ * ```
+ */
 @JvmName("arrayHasSizeLowerThanOrEqualTo")
 public fun <T> Validatable<Array<out T>?>.hasSizeLowerThanOrEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size <= size } otherwise { "The number of items must be lower than or equal to $size" }
 
+/**
+ * The validatable [Array] must have a size greater than [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { hasSizeGreaterThan(2) }
+ * validate(arrayOf('a', 'b', 'c')) // Success
+ * validate(arrayOf('a', 'b')) // Failure (message: The number of items must be greater than 2)
+ * ```
+ */
 @JvmName("arrayHasSizeGreaterThan")
 public fun <T> Validatable<Array<out T>?>.hasSizeGreaterThan(size: Int): Constraint =
     constrainIfNotNull { it.size > size } otherwise { "The number of items must be greater than $size" }
 
+/**
+ * The validatable [Array] must have a size greater than or equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { hasSizeGreaterThanOrEqualTo(2) }
+ * validate(arrayOf('a', 'b', 'c')) // Success
+ * validate(arrayOf('a', 'b')) // Success
+ * validate(arrayOf('a')) // Failure (message: The number of items must be greater than or equal to 2)
+ * ```
+ */
 @JvmName("arrayHasSizeGreaterThanOrEqualTo")
 public fun <T> Validatable<Array<out T>?>.hasSizeGreaterThanOrEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size >= size } otherwise { "The number of items must be greater than or equal to $size" }
 
+/**
+ * The validatable [Array] must have a size [within the provided range][range] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { hasSizeBetween(1..2) }
+ * validate(emptyArray()) // Failure (message: The number of items must be between 1 and 2)
+ * validate(arrayOf('a')) // Success
+ * validate(arrayOf('a', 'b')) // Success
+ * validate(arrayOf('a', 'b', 'c')) // Failure (message: The number of items must be between 1 and 2)
+ * ```
+ */
 @JvmName("arrayHasSizeBetween")
 public fun <T> Validatable<Array<out T>?>.hasSizeBetween(range: IntRange): Constraint =
     constrainIfNotNull { it.size in range } otherwise { "The number of items must be between ${range.first} and ${range.last}" }
 
+/**
+ * The validatable [Array] must contain [element] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { isContaining('b') }
+ * validate(arrayOf('a', 'b', 'c')) // Success
+ * validate(emptyArray()) // Failure (message: Must contain "b")
+ * ```
+ */
 @JvmName("arrayIsContaining")
 public fun <T> Validatable<Array<out T>?>.isContaining(element: T): Constraint =
     constrainIfNotNull { it.contains(element) } otherwise { "Must contain \"$element\"" }
 
+/**
+ * The validatable [Array] must not contain [element] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Array<Char>> { isNotContaining('b') }
+ * validate(emptyArray()) // Success
+ * validate(arrayOf('a', 'b', 'c')) // Failure (message: Must not contain "b")
+ * ```
+ */
 @JvmName("arrayIsNotContaining")
 public fun <T> Validatable<Array<out T>?>.isNotContaining(element: T): Constraint =
     constrainIfNotNull { !it.contains(element) } otherwise { "Must not contain \"$element\"" }
diff --git a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Collection.kt b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Collection.kt
index 5e1e9395..92622cff 100644
--- a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Collection.kt
+++ b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Collection.kt
@@ -31,46 +31,171 @@ import dev.nesk.akkurate.validatables.Validatable
  * union types in Kotlin, we must duplicate the code for each of those types.
  */
 
+/**
+ * The validatable [Collection] must be empty when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { isNotEmpty() }
+ * validate(listOf('a', 'b', 'c')) // Success
+ * validate(emptyList()) // Failure (message: Must not be empty)
+ * ```
+ */
 @JvmName("collectionIsEmpty")
 public fun <T> Validatable<Collection<T>?>.isEmpty(): Constraint =
     constrainIfNotNull { it.isEmpty() } otherwise { "Must be empty" }
 
+/**
+ * The validatable [Collection] must not be empty when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { isEmpty() }
+ * validate(emptyList()) // Success
+ * validate(listOf('a', 'b', 'c')) // Failure (message: Must be empty)
+ * ```
+ */
 @JvmName("collectionIsNotEmpty")
 public fun <T> Validatable<Collection<T>?>.isNotEmpty(): Constraint =
     constrainIfNotNull { it.isNotEmpty() } otherwise { "Must not be empty" }
 
+/**
+ * The validatable [Collection] must have a size equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { hasSizeEqualTo(3) }
+ * validate(listOf('a', 'b', 'c')) // Success
+ * validate(listOf('a', 'b')) // Failure (message: The number of items must be equal to 3)
+ * ```
+ */
 @JvmName("collectionHasSizeEqualTo")
 public fun <T> Validatable<Collection<T>?>.hasSizeEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size == size } otherwise { "The number of items must be equal to $size" }
 
+/**
+ * The validatable [Collection] must have a size different from [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { hasSizeNotEqualTo(3) }
+ * validate(listOf('a', 'b')) // Success
+ * validate(listOf('a', 'b', 'c')) // Failure (message: The number of items must be different from 3)
+ * ```
+ */
 @JvmName("collectionHasSizeNotEqualTo")
 public fun <T> Validatable<Collection<T>?>.hasSizeNotEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size != size } otherwise { "The number of items must be different from $size" }
 
+/**
+ * The validatable [Collection] must have a size lower than [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { hasSizeLowerThan(3) }
+ * validate(listOf('a', 'b')) // Success
+ * validate(listOf('a', 'b', 'c')) // Failure (message: The number of items must be lower than 3)
+ * ```
+ */
 @JvmName("collectionHasSizeLowerThan")
 public fun <T> Validatable<Collection<T>?>.hasSizeLowerThan(size: Int): Constraint =
     constrainIfNotNull { it.size < size } otherwise { "The number of items must be lower than $size" }
 
+/**
+ * The validatable [Collection] must have a size lower than or equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { hasSizeLowerThanOrEqualTo(2) }
+ * validate(listOf('a')) // Success
+ * validate(listOf('a', 'b')) // Success
+ * validate(listOf('a', 'b', 'c')) // Failure (message: The number of items must be lower than or equal to 2)
+ * ```
+ */
 @JvmName("collectionHasSizeLowerThanOrEqualTo")
 public fun <T> Validatable<Collection<T>?>.hasSizeLowerThanOrEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size <= size } otherwise { "The number of items must be lower than or equal to $size" }
 
+/**
+ * The validatable [Collection] must have a size greater than [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { hasSizeGreaterThan(2) }
+ * validate(listOf('a', 'b', 'c')) // Success
+ * validate(listOf('a', 'b')) // Failure (message: The number of items must be greater than 2)
+ * ```
+ */
 @JvmName("collectionHasSizeGreaterThan")
 public fun <T> Validatable<Collection<T>?>.hasSizeGreaterThan(size: Int): Constraint =
     constrainIfNotNull { it.size > size } otherwise { "The number of items must be greater than $size" }
 
+/**
+ * The validatable [Collection] must have a size greater than or equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { hasSizeGreaterThanOrEqualTo(2) }
+ * validate(listOf('a', 'b', 'c')) // Success
+ * validate(listOf('a', 'b')) // Success
+ * validate(listOf('a')) // Failure (message: The number of items must be greater than or equal to 2)
+ * ```
+ */
 @JvmName("collectionHasSizeGreaterThanOrEqualTo")
 public fun <T> Validatable<Collection<T>?>.hasSizeGreaterThanOrEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size >= size } otherwise { "The number of items must be greater than or equal to $size" }
 
+/**
+ * The validatable [Collection] must have a size [within the provided range][range] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { hasSizeBetween(1..2) }
+ * validate(emptyList()) // Failure (message: The number of items must be between 1 and 2)
+ * validate(listOf('a')) // Success
+ * validate(listOf('a', 'b')) // Success
+ * validate(listOf('a', 'b', 'c')) // Failure (message: The number of items must be between 1 and 2)
+ * ```
+ */
 @JvmName("collectionHasSizeBetween")
 public fun <T> Validatable<Collection<T>?>.hasSizeBetween(range: IntRange): Constraint =
     constrainIfNotNull { it.size in range } otherwise { "The number of items must be between ${range.first} and ${range.last}" }
 
+/**
+ * The validatable [Collection] must contain [element] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { isContaining('b') }
+ * validate(listOf('a', 'b', 'c')) // Success
+ * validate(emptyList()) // Failure (message: Must contain "b")
+ * ```
+ */
 @JvmName("collectionIsContaining")
 public fun <T> Validatable<Collection<T>?>.isContaining(element: T): Constraint =
     constrainIfNotNull { it.contains(element) } otherwise { "Must contain \"$element\"" }
 
+/**
+ * The validatable [Collection] must not contain [element] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Collection<Char>> { isNotContaining('b') }
+ * validate(emptyList()) // Success
+ * validate(listOf('a', 'b', 'c')) // Failure (message: Must not contain "b")
+ * ```
+ */
 @JvmName("collectionIsNotContaining")
 public fun <T> Validatable<Collection<T>?>.isNotContaining(element: T): Constraint =
     constrainIfNotNull { !it.contains(element) } otherwise { "Must not contain \"$element\"" }
diff --git a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Map.kt b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Map.kt
index 636f728e..77183622 100644
--- a/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Map.kt
+++ b/library/src/jvmMain/kotlin/dev/nesk/akkurate/constraints/builders/Map.kt
@@ -31,50 +31,197 @@ import dev.nesk.akkurate.validatables.Validatable
  * union types in Kotlin, we must duplicate the code for each of those types.
  */
 
+/**
+ * The validatable [Map] must be empty when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { isNotEmpty() }
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Success
+ * validate(emptyMap()) // Failure (message: Must not be empty)
+ * ```
+ */
 @JvmName("mapIsEmpty")
 public fun <T> Validatable<Map<*, T>?>.isEmpty(): Constraint =
     constrainIfNotNull { it.isEmpty() } otherwise { "Must be empty" }
 
+/**
+ * The validatable [Map] must not be empty when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { isEmpty() }
+ * validate(emptyMap()) // Success
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Failure (message: Must be empty)
+ * ```
+ */
 @JvmName("mapIsNotEmpty")
 public fun <T> Validatable<Map<*, T>?>.isNotEmpty(): Constraint =
     constrainIfNotNull { it.isNotEmpty() } otherwise { "Must not be empty" }
 
+/**
+ * The validatable [Map] must have a size equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { hasSizeEqualTo(3) }
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2)) // Failure (message: The number of items must be equal to 3)
+ * ```
+ */
 @JvmName("mapHasSizeEqualTo")
 public fun <T> Validatable<Map<*, T>?>.hasSizeEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size == size } otherwise { "The number of items must be equal to $size" }
 
+/**
+ * The validatable [Map] must have a size different from [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { hasSizeNotEqualTo(3) }
+ * validate(mapOf('a' to 1, 'b' to 2)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Failure (message: The number of items must be different from 3)
+ * ```
+ */
 @JvmName("mapHasSizeNotEqualTo")
 public fun <T> Validatable<Map<*, T>?>.hasSizeNotEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size != size } otherwise { "The number of items must be different from $size" }
 
+/**
+ * The validatable [Map] must have a size lower than [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { hasSizeLowerThan(3) }
+ * validate(mapOf('a' to 1, 'b' to 2)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Failure (message: The number of items must be lower than 3)
+ * ```
+ */
 @JvmName("mapHasSizeLowerThan")
 public fun <T> Validatable<Map<*, T>?>.hasSizeLowerThan(size: Int): Constraint =
     constrainIfNotNull { it.size < size } otherwise { "The number of items must be lower than $size" }
 
+/**
+ * The validatable [Map] must have a size lower than or equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { hasSizeLowerThanOrEqualTo(2) }
+ * validate(mapOf('a' to 1)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Failure (message: The number of items must be lower than or equal to 2)
+ * ```
+ */
 @JvmName("mapHasSizeLowerThanOrEqualTo")
 public fun <T> Validatable<Map<*, T>?>.hasSizeLowerThanOrEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size <= size } otherwise { "The number of items must be lower than or equal to $size" }
 
+/**
+ * The validatable [Map] must have a size greater than [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { hasSizeGreaterThan(2) }
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2)) // Failure (message: The number of items must be greater than 2)
+ * ```
+ */
 @JvmName("mapHasSizeGreaterThan")
 public fun <T> Validatable<Map<*, T>?>.hasSizeGreaterThan(size: Int): Constraint =
     constrainIfNotNull { it.size > size } otherwise { "The number of items must be greater than $size" }
 
+/**
+ * The validatable [Map] must have a size greater than or equal to [size] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { hasSizeGreaterThanOrEqualTo(2) }
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2)) // Success
+ * validate(mapOf('a' to 1)) // Failure (message: The number of items must be greater than or equal to 2)
+ * ```
+ */
 @JvmName("mapHasSizeGreaterThanOrEqualTo")
 public fun <T> Validatable<Map<*, T>?>.hasSizeGreaterThanOrEqualTo(size: Int): Constraint =
     constrainIfNotNull { it.size >= size } otherwise { "The number of items must be greater than or equal to $size" }
 
+/**
+ * The validatable [Map] must have a size [within the provided range][range] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { hasSizeBetween(1..2) }
+ * validate(emptyMap()) // Failure (message: The number of items must be between 1 and 2)
+ * validate(mapOf('a' to 1)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2)) // Success
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Failure (message: The number of items must be between 1 and 2)
+ * ```
+ */
 @JvmName("mapHasSizeBetween")
 public fun <T> Validatable<Map<*, T>?>.hasSizeBetween(range: IntRange): Constraint =
     constrainIfNotNull { it.size in range } otherwise { "The number of items must be between ${range.first} and ${range.last}" }
 
+/**
+ * The validatable [Map] must contain [the provided key][key] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { isContainingKey('b') }
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Success
+ * validate(emptyMap()) // Failure (message: Must contain key "b")
+ * ```
+ */
 public fun <K> Validatable<Map<out K, *>?>.isContainingKey(key: K): Constraint =
     constrainIfNotNull { it.containsKey(key) } otherwise { "Must contain key \"$key\"" }
 
+/**
+ * The validatable [Map] must not contain [the provided key][key] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { isNotContainingKey('b') }
+ * validate(emptyMap()) // Success
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Failure (message: Must not contain key "b")
+ * ```
+ */
 public fun <K> Validatable<Map<out K, *>?>.isNotContainingKey(key: K): Constraint =
-    constrainIfNotNull { !it.containsKey(key) } otherwise { "Must contain key \"$key\"" }
+    constrainIfNotNull { !it.containsKey(key) } otherwise { "Must not contain key \"$key\"" }
 
+/**
+ * The validatable [Map] must contain [the provided value][value] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { isContainingValue(2) }
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Success
+ * validate(emptyMap()) // Failure (message: Must contain value "2")
+ * ```
+ */
 public fun <V> Validatable<Map<*, V>?>.isContainingValue(value: V): Constraint =
     constrainIfNotNull { it.containsValue(value) } otherwise { "Must contain value \"$value\"" }
 
+/**
+ * The validatable [Map] must not contain [the provided value][value] when this constraint is applied.
+ *
+ * Code example:
+ *
+ * ```
+ * val validate = Validator<Map<Char, Int>> { isNotContainingValue(2) }
+ * validate(emptyMap()) // Success
+ * validate(mapOf('a' to 1, 'b' to 2, 'c' to 3)) // Failure (message: Must not contain value "2")
+ * ```
+ */
 public fun <V> Validatable<Map<*, V>?>.isNotContainingValue(value: V): Constraint =
-    constrainIfNotNull { !it.containsValue(value) } otherwise { "Must contain value \"$value\"" }
+    constrainIfNotNull { !it.containsValue(value) } otherwise { "Must not contain value \"$value\"" }