ERROR

customSerializers: Map<KClass<*>, KSerializer<*>>

@Deprecated(
    level = DeprecationLevel.ERROR,
    message = "This method was removed during serialization 1.0 API stabilization, " +
            "please use SerializersModule builder instead" // No replacement deliberately
)
public fun serializersModuleOf(map: Map<KClass<*>, KSerializer<*>>): SerializersModule = noImpl()

List<MyType>.serializer()

{
  "thread": {
    "name": "Kotlin serialization question",
    "messages": {
      "xSDkj3402": {
        "text": "How would you guys..."
        "author" "kollstrom"
      }, 
      "-3krdjdfs03": {
        "text": "I see! The solution to all of your problems is..."
        "author": "helpful_person"
      }
    }
  }
}

data class Thread(
  val name: String,
  val messages: Map<String, Message>
)

data class Message(
  val text: String,
  val author: String
)

private var parser = kotlinx.serialization.json.Json(JsonConfiguration.Stable.copy(ignoreUnknownKeys = true))
var stringToParse = "{\"gvlSpecificationVersion\":2}"
var parsedReturn: VendorList = parser.parse(VendorList.serializer(), stringToParse)

@Serializable
abstract class VendorList(
    open var lastUpdated: String?,
    open var gvlSpecificationVersion: Int?,
    open var vendorListVersion: Int?,
    open var tcfPolicyVersion: Int?,
    open var vendors: Map<String, Vendor>?,

    @Transient override var purposes: Map<String, Purpose>? = null,
    @Transient override var features: Map<String, Feature>? = null,
    @Transient override var specialFeatures: Map<String, Feature>? = null,
    @Transient override var specialPurposes: Map<String, Purpose>? = null,
    @Transient override var stacks: Map<String, Stack>? = null
): Declarations(
    purposes = purposes,
    features = features,
    specialFeatures = specialFeatures,
    specialPurposes = specialPurposes,
    stacks = stacks
)

@Serializable
open class Declarations(
    open var purposes: Map<String, Purpose>?,
    open var specialPurposes: Map<String, Purpose>?,
    open var features: Map<String, Feature>?,
    open var specialFeatures: Map<String, Feature>?,
    open var stacks: Map<String, Stack>?
)

@Serializable
data class Overflow (
    var httpGetLimit: Int
)

@Serializable
data class Vendor(
    var purposes: List<Int>,
    var legIntPurposes: List<Int>,
    var flexiblePurposes: List<Int>,
    var specialPurposes: List<Int>,
    var features: List<Int>,
    var specialFeatures: List<Int>,
    var policyUrl: String,
    var deletedDate: @ContextualSerialization Any?,
    var overflow: Overflow?,
    override var id: Int,
    override var name: String
): GVLMapItem

interface GVLMapItem {
    var id: Int
    var name: String
}

@Serializable
data class Purpose(
    var description: String,
    var descriptionLegal: String,
    override var id: Int,
    override var name: String
): GVLMapItem

@Serializable
data class Feature(
    var description: String,
    var descriptionLegal: String,
    override var id: Int,
    override var name: String
): GVLMapItem

@Serializable
data class Stack(
    var purposes: List<Int>,
    var specialFeatures: List<Int>,
    var description: String,
    override var id: Int,
    override var name: String
): GVLMapItem

kotlin.Throwable: Key type is missing in the map.

interface Field<Value> {...}

interface InputField<InputT> : Field<InputT> {...}
interface SelectorField<ValueT> : Field<ValueT> {...}

abstract class NumberField : InputField<Number> {...}
abstract class BooleanField : SelectorField<Boolean> {...}

@Serializable
data class NumberFieldImpl(...): NumberField()

@Serializable
data class BooleanFieldImpl(...): BooleanField()

// Need to add serializable on base class else compiler complains
@Serializable
abstract class MapBackedContainer<K, V>(val storage: MutableMap<K, V>) : MutableMap<K, V> by storage

@Serializable // Currently fails compile, message below
class FieldContainer : MapBackedContainer<String, Field<*>>

@Serializable // This one has no errors, ActionImpl is non generic and annotated with @Serializable
class ActionContainer : MapBackedContainer<String, ActionImpl>

FieldContainer

@Serializable

Field<*>

@Contextual

ListSerializer(ListingStateVO.serializer()).serialize(
				encoder = ???,
				value = it
			)

{
  "data": {
    "type1": [
      {
        "id": 1,
        "payload": {
          "fieldA": "123",
          "fieldB": "321"
        }
      }
    ],
    "type2": [
      {
        "id": 1,
        "payload": {
          "fieldC": "789",
          "fieldD": "101112"
        }
      }
    ]
  }
}

Map<String, List<Item>>

type1, type2

data class Item(
    val id: Int,
    val payload: ItemPayload
)
sealed class ItemPayload {
    data class PayloadOne(
        val fieldA: String,
        val fieldB: String
    )

    data class PayloadTwo(
        val fieldC: String
        val fieldD: String
    )
}

JsonObject

ItemPayload

JsonObject

ItemPayload

type1, type2

JsonObject

KSerializer

ApiResponse<T>

kotlinx.serialization

ApiResponseSerializer

data class ApiResponse<T>(
    val data: T? = null,
    val error: ApiError? = null
)

respond(
    HttpStatusCode.Created,
    ApiResponse(data = response.data)
)

data

ApiResponse

e: java.lang.NoClassDefFoundError: org/jetbrains/kotlin/com/intellij/openapi/util/io/JarUtil
	at org.jetbrains.kotlinx.serialization.compiler.diagnostic.VersionReader.getVersionsFromManifest(VersionReader.kt:34)

data class Reference(val id: String)

// appears in the json as just String
...
"reference" : "the-reference-id"
...

buildJson

val files = buildJsonArray {
 ficheros.forEach {
  add(buildJsonObject {
      put("name", JsonPrimitive(it))
  })
 }
}

@Serializable(with = ...)

json{}

buildJsonObject{}

jsonArray { //version 0.20.0
 +"fic.sld"
 +json {
   "age" to 123
 }
}

buildJsonArray { //version 1.0
 add("fic.sld")
 add(buildJsonObject {
    put("age", JsonPrimitive(123))
 })
}

someField: SomeType? = null

null

null

kotlinx-serialization-core

kotlinx-serialization-json

kotlinx-serialization-core

kotlinx-serialization

runtime

import kotlinx.serialization.json.JsonDecodingException

Back-end (JVM) Internal error: wrong bytecode generated

Your current kotlinx.serialization core version is too low, while current Kotlin compiler plugin 1.4.0 requires at least 1.0-M1-SNAPSHOT. Please update your kotlinx.serialization runtime dependency.

ByteArraySegment

descriptor

@Serializer(forClass = ByteArraySegment::class)
companion object : KSerializer<ByteArraySegment> {
    override val descriptor: SerialDescriptor
        get() = ByteArraySerializer().descriptor

    override fun serialize(encoder: Encoder, value: ByteArraySegment) {
        encoder.encode(ByteArraySerializer(), value.asArray)
    }

    override fun deserialize(decoder: Decoder): ByteArraySegment {
        return ByteArraySegment(decoder.decode(ByteArraySerializer()))
    }
}