JSON to Kotlin Data Class

{"order_id": 4021, "customer email": "sam@example.com", "shipped_at": null}

import kotlinx.serialization.*
import kotlinx.serialization.json.*
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.*

@Serializable
data class Root (
    @SerialName("order_id")
    val orderId: Long,

    @SerialName("customer email")
    val customerEmail: String,

    @SerialName("shipped_at")
    val shippedAt: JsonElement? = null
)

All three keys need renaming to reach a Kotlin property, and each keeps its wire spelling in @SerialName — including the one holding a space. shipped_at was null everywhere, so it lands as JsonElement? defaulted to null.

{"cart id": 88, "coupon_code": "SPRING"}

data class Root (
    val cartId: Long,
    val couponCode: String
)

Plain classes drop the imports, the @Serializable line and any record of what the wire said: nothing maps couponCode back to coupon_code. A chip names every key that lost its spelling.

{"device_id": "kit-9", "firmware": "1.4.2"}

{"device_id": "kit-3"}

import kotlinx.serialization.*
import kotlinx.serialization.json.*
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.*

@Serializable
data class Device (
    @SerialName("device_id")
    val deviceId: String,

    val firmware: String? = null
)

The second reading has no firmware, so it is declared String? = null while deviceId, present in both, stays non-null. firmware shows the quiet half of the rule too: a name already matching its key needs no annotation.

{"amount": 1.0, "count": 3, "ratio": 0.5}

import kotlinx.serialization.*
import kotlinx.serialization.json.*
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.*

@Serializable
data class Root (
    val amount: Long,
    val count: Long,
    val ratio: Double
)

1.0 has no fractional part, so it is read as an integer and amount is typed Long — a chip says so. Only ratio, carrying a real fraction, becomes Double.

[1, 2, 3]

typealias Root = ArrayList<Long>

A top level that is not an object has no properties to declare, so the file states the type it really is rather than refusing.

{"id": 7, "customer": {"first_name": "Ada", "vip": true}, "tags": ["a", "b"]}

import com.fasterxml.jackson.annotation.*

data class Order (
    @get:JsonProperty(required=true)@field:JsonProperty(required=true)
    val id: Long,

    @get:JsonProperty(required=true)@field:JsonProperty(required=true)
    val customer: Customer,

    @get:JsonProperty(required=true)@field:JsonProperty(required=true)
    val tags: List<String>
)

data class Customer (
    @get:JsonProperty("first_name", required=true)@field:JsonProperty("first_name", required=true)
    val firstName: String,

    @get:JsonProperty(required=true)@field:JsonProperty(required=true)
    val vip: Boolean
)

A nested object earns its own declaration in the same file, named after the key. Jackson marks a property required when every sample carried it, and annotates getter and field alike.