Declarative, type-safe runtime validation for data via immutable schemas, automatic schema-to-type inference, feature-rich API, extensible custom rules, zero dependencies and detailed error reporting.
ZodKmp is a Kotlin Multiplatform implementation of the popular Zod TypeScript validation library. It provides a declarative, type-safe way to validate data in your Kotlin Multiplatform projects. For detail documentation .
ZodKmp supports the following platforms:
Add the following to your build.gradle.kts:
kotlin {
sourceSets {
val commonMain by getting {
dependencies {
implementation("io.github.piashcse:zodkmp:1.2.0")
}
}
}
}
[versions]
zodkmp = "1.2.0"
[libraries]
zodkmp = { module = "io.github.piashcse:zodkmp", version.ref = "zodkmp" }
ZodKmp allows you to define validation schemas and use them to validate data:
Validate string values with various constraints:
val stringSchema = Zod.string()
// With constraints
val constrainedString = Zod.string()
.min(5, "String must be at least 5 characters")
.max(100, "String must be at most 100 characters")
.length(, )
.email()
.url()
.regex(Regex(), )
.startsWith(, )
.endsWith(, )
.includes(, )
.toLowerCase()
.toUpperCase()
.trim()
Validate numeric values:
val numberSchema = Zod.number()
// With constraints
val constrainedNumber = Zod.number()
.gt(, )
.gte(, )
.lt(, )
.lte(, )
.min(, )
.max(, )
.int()
.positive()
.negative()
.nonPositive()
.nonNegative()
.multipleOf(, )
Validate boolean values:
val booleanSchema = Zod.boolean()
Validate date values:
val dateSchema = Zod.date()
// With constraints
val constrainedDate = Zod.date()
.min(LocalDateTime(2020, 1, 1, 0, 0), "Date must be after 2020")
.max(LocalDateTime(2030, 12, 31, 23, 59), "Date must be before 2030")
Validate null and undefined values:
val nullSchema = Zod.null()
val undefinedSchema = Zod.undefined()
Validate exact literal values:
val literalSchema = Zod.literal("admin")
val numberLiteral = Zod.literal(42)
val booleanLiteral = Zod.literal(true)
Validate array values with constraints:
val stringArray = Zod.array(Zod.string())
// With constraints
val constrainedArray = Zod.array(Zod.string())
.min(2, "Array must have at least 2 elements")
.max(10, "Array must have at most 10 elements")
.length(5, "Array must have exactly 5 elements")
.nonempty("Array must not be empty")
Validate complex objects:
Validate enum values:
// String enums
val roleSchema = Zod.enum("admin", "user", "guest")
// Using collections
val roles = listOf("admin", "user", "guest")
val roleSchema = Zod.enum(roles)
Validate values that match any of multiple schemas:
val stringOrNumber = Zod.union(Zod.string(), Zod.number())
val complexUnion = Zod.union(
Zod.string(),
Zod.number(),
Zod.objectSchema<Point>({
number("x", Zod.number())
number("y", Zod.number())
}) { map ->
Point(
x = (map["x"] as Number).toDouble(),
y = (map["y"] as Number).toDouble()
)
}
)
Validate fixed-length arrays with specific types for each position:
val coordinates = Zod.tuple(listOf(Zod.number(), Zod.number()))
// Usage
val result = coordinates.safeParse(listOf(10.0, 20.0))
Validate objects with string keys and uniform value types:
val stringRecord = Zod.record(Zod.string())
val numberRecord = Zod.record(Zod.number())
// Usage
val userData = mapOf("name" to "John", "city" to "NYC")
val result = stringRecord.safeParse(userData)
Validate values that must satisfy multiple schemas:
val personSchema = Zod.objectSchema<Person>({
string("name", Zod.string())
}) { map ->
Person(name = map["name"] as String)
}
val employeeSchema = Zod.objectSchema<Employee>({
string("employeeId", Zod.string())
}) { map ->
Employee(employeeId = map["employeeId"] as String)
}
val personEmployeeSchema = Zod.intersection(personSchema, employeeSchema)
Mark schemas as accepting null values:
val nullableString = Zod.string().nullable()
// Usage
val result1 = nullableString.safeParse("hello") // Success
val result2 = nullableString.safeParse(null) // Success
val result3 = nullableString.safeParse(42) // Failure
Mark schemas as accepting undefined values:
val optionalString = Zod.string().optional()
// Usage
val result1 = optionalString.safeParse("hello") // Success
val result2 = optionalString.safeParse(null) // Success (undefined)
Transform values during validation:
val uppercaseString = Zod.string().transform { it.uppercase() }
val toString = Zod.number().transform { it.toInt().toString() }
// Usage
val result = toString.safeParse(42.5) // Success with "42"
Add custom validation rules:
val evenNumber = Zod.number().refine({ it.toInt() % 2 == 0 }) { "Number must be even" }
val strongPassword = Zod.string().refine({ it.length >= 8 && it.any { char -> char.isDigit() } }) { "Password must be at least 8 characters with numbers" }
Provide default values for schemas:
val stringWithDefault = Zod.string().default("unknown")
val numberWithDefault = Zod.number().default { 0.0 }
// Usage
val result1 = stringWithDefault.safeParse(null) // Success with "unknown"
val result2 = stringWithDefault.safeParse("hello") // Success with "hello"
val addressSchema = Zod.objectSchema<Address>({
string("street", Zod.string().min(5))
string("city", Zod.string().min())
string(, Zod.string().regex(Regex())
}) { map ->
Address(
street = map[] String,
city = map[] String,
zipCode = map[] String
)
}
userWithAddressSchema = Zod.objectSchema<UserWithAddress>({
string(, Zod.string().min())
field(, addressSchema)
}) { map ->
UserWithAddress(
name = map[] String,
address = map[] Address
)
}
// Custom validation based on other fields
val conditionalSchema = Zod.objectSchema<Conditional>({
string("type", Zod.enum("email", "phone"))
string("value", Zod.string())
}) { map ->
Conditional(
type = map[] String,
value = map[] String
)
}.refine({ obj ->
(obj.type) {
-> obj.value.contains()
-> obj.value.all { it.isDigit() || it == }
->
}
}) { }
ZodKmp provides detailed error information:
val userSchema = Zod.objectSchema<User>({
string("name", Zod.string().min(2))
string("email", Zod.string().email())
}) { map ->
User(
name = map["name"] String,
email = map[] String
)
}
result = userSchema.safeParse(mapOf( to , to ))
(result) {
ZodResult.Success -> {
println()
}
ZodResult.Failure -> {
result.error.errors.forEach { error ->
println()
}
}
}
Contributions are welcome! Please feel free to submit a Pull Request.
git checkout -b feature/AmazingFeature)git commit -m 'Add some AmazingFeature')git push origin feature/AmazingFeature)Mehedi Hassan Piash
import com.piashcse.zodkmp.Zod
// Define a schema
val userSchema = Zod.objectSchema<User>({
string("name", Zod.string().min(2))
string("email", Zod.string().email())
number("age", Zod.number().min(0).max(120))
}) { map ->
User(
name = map["name"] as String,
email = map["email"] as String,
age = (map["age"] as Number).toDouble()
)
}
// Use the schema
val userData = mapOf(
"name" to "John Doe",
"email" to "john@example.com",
"age" to 30.0
)
val result = userSchema.safeParse(userData)
when (result) {
is ZodResult.Success -> println("Valid user: ${result.data}")
is ZodResult.Failure -> println("Validation errors: ${result.error.errors}")
}
val userSchema = Zod.objectSchema<User>({
string("name", Zod.string().min(2))
string("email", Zod.string().email())
number("age", Zod.number().min(0).max(120))
field("isActive", Zod.boolean().default(true))
}) { map ->
User(
name = map["name"] as String,
email = map["email"] as String,
age = (map["age"] as Number).toDouble(),
isActive = map["isActive"] as? Boolean ?: true
)
}
// Strict objects (reject unknown keys)
val strictUserSchema = Zod.objectSchema<User>({
string("name", Zod.string().min(2))
string("email", Zod.string().email())
}) { map ->
User(
name = map["name"] as String,
email = map["email"] as String
)
}.strict()
MIT License
Copyright (c) 2025 Mehedi Hassan Piash
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Surfaced from shared tags and platforms — no rankings paid for.