object LongRangeSerializer: KSerializer<LongRange> {
    override val descriptor = buildClassSerialDescriptor("LongRange") {
        element<Long>("first")
        element<Long>("last")
    }

    override fun deserialize(decoder: Decoder): LongRange {
        var first = 0L
        var last = 0L

        decoder.decodeStructure(descriptor) {
            first = decodeLongElement(descriptor, 0)
            last = decodeLongElement(descriptor, 1)
        }

        return first..last
    }

    override fun serialize(encoder: Encoder, value: LongRange) {
        encoder.encodeStructure(descriptor) {
            encodeLongElement(descriptor, 0, value.first)
            encodeLongElement(descriptor, 1, value.last)
        }
    }
}

@Serializable class Container(@Serializable(with = LongRangeSerializer::class) val ranges: Array<LongRange>)

@Contextual

Kotlin: Serializer has not been found for type 'LongRange'. To use context serializer as fallback, explicitly annotate type or property with @Contextual

@JsonFormat(pattern = "yyyy-MM-dd")

kotlinx.serialization.SerializationException: Serializer for class 'Pagination' is not found.

import kotlinx.serialization.Serializable

@Serializable
data class Pagination<T>(
    val count: Int,
    val next: String? = null,
    val previous: String? = null,
    val results: List<T>
)

plugins {
    id("com.android.application")
    kotlin("android")
    id("kotlin-android-extensions")
    kotlin("plugin.serialization") version Versions.kotlin
}

@Serializable(with=...)

@Serializable
data class MyClass(
    @Serializable(with=???)
    val mySet: Set<UUID>
)

@Serializable

it.mapValues { (_, value) ->
                when (value) {
                    is JsonPrimitive -> value.content
                    JsonNull -> null
                    is JsonObject -> TODO()
                    is JsonArray -> value.map { it.jsonPrimitive.content }
                }
            }

val jvmJar by tasks.getting(Jar::class) {
    doFirst {
        manifest {
            attributes["Main-Class"] = "${ProjectSettings.packageName}.backend.BackendAppKt"
            from(
                configurations
                    .getByName("runtimeClasspath")
                    .map { if (it.isDirectory) it else zipTree(it) }
            )
        }
    }
}

> Task :backend:jvmJar FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':backend:jvmJar'.
> Cannot convert the provided notation to a File or URI: ZIP '/Users/mustafa.ozhan/.gradle/caches/modules-2/files-2.1/io.ktor/ktor-serialization/1.6.0/8377a04c8a0e11d31ef17f1c0c06bda6c7b2fdc4/ktor-serialization-jvm-1.6.0.jar'.
  The following types/formats are supported:
    - A String or CharSequence path, for example 'src/main/java' or '/usr/include'.
    - A String or CharSequence URI, for example 'file:/usr/include'.
    - A File instance.
    - A Path instance.
    - A Directory instance.
    - A RegularFile instance.
    - A URI or URL instance.
    - A TextResource instance.

val json = Json {
    contextual(MyInterface::class, MyInterfaceSerializer)
}

kotlinx.serialization.SerializationException: Serializer for class 'MyInterfaceImpl' is not found.

encodeToString

Caused by: java.lang.AssertionError: Couldn't load KotlinClass

@Serializable
data class SocketMessage<T>(
    val timestamp: Long?,
    val message: T
)

@Contextual

@Ref

id

data class Video(
    val name: String,
    @Ref val user: User,
)

// serialized to:

{
    name: "example",
    user: {
        id: "123"
    }
}

kotlinx.serialization

@Serializable
data class ChangeOrderInput(
    val oldProposal: OldProposal,
    val newProposals: List<NewProposal>
)

@Serializable
data class OldProposal(
    val product: Product
)

@Serializable
data class NewProposal(
    val id: String,
    val product: Product,
    val changeOrderType: ChangeOrderType? = null
)

@Serializable(with = ProductSerializer::class)
sealed class Product {
    abstract val type: ProductType
    abstract val bundle: ProductBundle
}

object ProductSerializer : JsonContentPolymorphicSerializer<Product>(Product::class) {
    override fun selectDeserializer(element: JsonElement): DeserializationStrategy<out Product> {
        val typeString = element.jsonObject["type"]?.jsonPrimitive?.content ?: error("`type` wasn't provided for `product`")
        return when (ProductType.valueOf(typeString)) {
            ProductType.Cash -> CashProduct.serializer()
            <http://ProductType.Loan|ProductType.Loan> -> LoanProduct.serializer()
        }
    }
}

@Serializable
data class CashProduct(
    override val type: ProductType = ProductType.Cash,
    override val bundle: ProductBundle,
    val totalPrice: BigDecimal
) : Product()

@Serializable
data class LoanProduct(
    override val type: ProductType = <http://ProductType.Loan|ProductType.Loan>,
    override val bundle: ProductBundle,
    val vendor: String,
    val term: BigDecimal,
    val apr: BigDecimal,
    val totalPrice: BigDecimal
) : Product()

@Serializable
data class ExampleResponse(
    val version: String = "",
    val outputObjects: List<NewProposal>? = listOf()
)

val inputJsonString = input.reader().use { it.readText() }
val request = Serialization.json.decodeFromString(ChangeOrderInput.serializer(), inputJsonString)
val response = runBlocking {
    changeOrderWrapper.handleRequest(request)
}
val outputJsonString = Serialization.json.encodeToString(response)
output.writer().use { it.write(outputJsonString) }

ExampleResponse

NewProposal#type

#class

@Serializable
data class Foo(
    val list: List<String> = emptyList()
)
val foo = Json.encodeToString(Foo())
println(foo)

{}

@Serializable
data class Foo(
    val list: List<String>
)
val foo = Json.encodeToString(Foo(emptyList()))
println(foo)

{
  "list": []
}

{
  "list": []
}

{
  "accountNo": "",
  "address": "4",
  "amount": 1719000,
  "bankCode": "950012",
  "channel": "6015",
  "customerCode": "Evn15",
  "customerName": "EXIM",
  "localDateTime": "20210713203042",
  "providerCode": "196000",
  "senderInfo": "Evn15",
  "serviceCode": "000010",
  "sign": "",
  "trace": "000295",
  "vnpayDateTime": "20210713204024"
}

Unexpected JSON token at offset 300: Expected quotation mark '\"', but had '\"' instead\nJSON input: .....gn\": \"\",\n\t\"trace\": \"000295\",\n\t\"vnpayDateTi

kotlinx.serialization.MissingFieldException: Field 'properties' is required for type with serial name 'solid.box', but it was missing.

propertiese

public var properties: Config? = null
        protected set

kotlinx.serialization.json.internal.JsonDecodingException: Expected class kotlinx.serialization.json.JsonObject (Kotlin reflection is not available) as the serialized body of kotlinx.serialization.Polymorphic<List>, but had class kotlinx.serialization.json.JsonArray (Kotlin reflection is not available)

[ //internal structure of json object ]

List<R>

internal inline fun <reified R : Any> String.convertToDataClass() =
    Json {
        ignoreUnknownKeys = true
    }.decodeFromString(R::class.serializer(), this)

"[…]".convertToDataClass<List<SomeDataClass>()

It also uses Kotlin 1.5.20 as default.