Hello,

const val START_ACTION = "start"
enum class Actions(val info: String) {
    START(START_ACTION)
}
---------------------------------------------------------------------------
@Serializable
data class ActionRequest(
    @SerialName("action_type")
    val actionType: Actions  ----> enum is compulsory to use here
)
---------------------------------------------------------------------------
val actionRequest = ActionRequest(actionType = START)
---------------------------------------------------------------------------```

Here, I am getting output is "START" rather than "start". Can someone please help me with how to get the value of action here?

Is there any way to mark a generic type parameter as being serializable? So that I can do something like:

class Test<T>(val t: T) {
  val serializer = T::class.serializer() // I know this doesn't work
}

This message was deleted.

I have the following

Either<L, R>

construct which is a third party (and therefore created its own serialiser:

EitherSerializer

). However, deserialising straight to it doesn't work. typealias doesn't work either.

// yields kotlinx.serialization.SerializationException: Serializer for class 'Either' is not found.
Json.decodeFromString<Either<SchemaObject, ReferenceObject>>(json)


// yields  kotlinx.serialization.SerializationException: Serializer for class 'Either' is not found.
typealias EitherAlias<L, R> = @Serializable(EitherSerializer::class) Either<L, R>
...
Json.decodeFromString<EitherAlias>(json)


// works fine!
@Serializable
data class NestedInAClass(val schema: @Serializable(EitherSerializer::class) Either<SchemaObject, ReferenceObject>)
...
Json.decodeFromString<NestedInAClass>(json)

It looks like it would work only if it is nested within a serialised class. I don't see why typealias wouldn't work. Any help would be appreciated!

If I have a json string blob like:

{
  foo: [1, 2, 3]
}

Is there a way to deserialize that into

data class MyClass(val foo: String)

and have the value of

MyClass.foo

be the string

"[1, 2, 3]"

?

I need to serialize delegated properties , is there anyway I can work around this !!

abstract class MapNode {

    // Node Properties
    var isGroup by mutableStateOf(false)
    var colorIndex by mutableStateOf(0)

    // Node Children
    @Serializable(with = SnapshotStateListSerializer::class)
    var left = mutableStateListOf<MapNode>()

}

How can I write a Custom Serializer for this class ?? that serializes all these properties ! (including delegated properties)

Hey, guys. I have an KMM module with many serializable classes generating code for JVM, iOS and JS. I just realized today that my JS bundle (IR) is huge and the main cause is the

$serializer

synthetic property that is created for each class/companion. If I remove all my

@Serializable

, my module reduce its size by 80%. JVM an iOS are fine, but I can't pay that price in JS. Question is: Is there a way to disable kotlinx-serialization

$serializer

generation just in the JS backend? If I could disable it just in JS, I could still use the

kotlinx-serialization

serializer for all backends and I'd roll my own for JS, but I would still be able to use my data classes in JS.

Is it possible to set the “encode defaults” on a per-class or even per-property basis?

Is it possible to create a custom serializer for a field (not the class that has this field) that treats the non-nullable field as absent in some cases? I have a structure that could be empty and I would like for serialization to treat absent value as an empty structure and empty structure as absent.

Hello, Im using retrofit + koltin serializer and Kotlin Serialization Converter (Jake library). I want to see request and responses on the logcat. I added a convert into retrofit

private val contentType =  "application/json".toMediaType()
private val json = Json {
    prettyPrint = true
    ignoreUnknownKeys = true
}

..

..addConverterFactory(json.asConverterFactory(contentType))

But i cannot see the logs on logcat screen. Any idea how to display it?

Are there standard serializers for java.time types i.e LocalTime, LocalDate, Instant, etc..? Does such a thing exist. The idea being that they can be imported into a project so that Kotlinx serialization can serialize java.time types automatically?

Anyone have a general idea of the iOS app size increase implications using the kotlinx serialization protobuf library? Adding the library to our ios code with 5 very small @Serializable classes has resulted in a 377 Kb increase in app size. Does this sound correct? Is the majority of the cost coming from the library or generated code - and how does with scale when adding significantly more Serializable classes?

I created a library that depends on kotlin serialization library but in project I have to specify

classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"

how can I avoid this , my project does not need serialization library , only the dependent library needs it so anyone if uses my library does not need to put classpath like this

is there a way to directly deserialize json from a byte array without converting it to a string first?

im trying to do this https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/formats.md#format-specific-types, but with

List<Byte>

, so a specific generic type. Is it possible, and if so how?

I have an interface for Events that has multiple concrete sealed class implementations, like so:

// in package com.example.platform
interface Event

// in package com.example.customer
@Serializable
sealed class CustomerEvent : Event {
    object CustomerEvent1
    ...
}

// in package com.example.supplier
@Serializable
sealed class SupplierEvent : Event {
    object SupplierEvent1
    ...
}

I would like to be able to serialize/deserialize

Event

, but I don't really want to have all the event trees in one package, so using one big

sealed class

hierarchy doesn't work well. Does anyone have any idea how to go about registering

Event

as polymorphically serializable?

Hello! I have some weird error trying to run a Ktor call with a body:

W/System.err: kotlinx.serialization.SerializationException: Serializer for class 'Companion' is not found.
    Mark the class as @Serializable or provide the serializer explicitly.

The place I am trying to use:

try {
            api.createAccount(Account(handle = "some", displayname = "Some name"))
        } catch (e: Exception) {
            e.printStackTrace()
        }

And the class itself:

import kotlinx.serialization.Serializable

@Serializable
data class Account(val handle: String, val displayname: String)

Ktor's HttpClient config contains:

install(JsonFeature) {
            serializer = KotlinxSerializer(Json {
                ignoreUnknownKeys = true
                encodeDefaults = true
                useAlternativeNames = false
            })
        }

In my build.gradle.kts of the module I have:

plugins {
    kotlin("multiplatform")
    kotlin("plugin.serialization")
    id("com.squareup.sqldelight")
    id("com.android.library")
}

kotlin {
    ...
    sourceSets {

        val serializationVersion = "1.2.2"
        val ktorVersion = "1.6.2"


        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:$serializationVersion")
                implementation("io.ktor:ktor-client-core:$ktorVersion")
                implementation("io.ktor:ktor-client-serialization:$ktorVersion")
                implementation("io.ktor:ktor-client-logging:$ktorVersion")
            }
        }
        val androidMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-okhttp:$ktorVersion")
            }
        }
        val iosMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-ios:$ktorVersion")
            }
        }
    }
}

What am I doing wrong?

Hi, how can I use

decodeNullableSerializableElement

on a

Byte?

value ? Or in other words, how can I deSerialize a

Byte?

?

And how can I make optional deletaged properties ? I'm coupling serialization with Compose and I have a

val state by mutableStateOf(MyEnum.FIRST_VALUE)

, I want to omit the field if it is equal to

MyEnum.FIRST_VALUE

as it is the default one and most used through my code, but I don't understand how 🤔 I have a custom Serialiazer and I'm encoding the value as Nullable and I've set

encodeDefaults = false

in my Json configuration, but it's still emitted and when I try to read the JSON I get this

Exception in thread "AWT-EventQueue-0" kotlinx.serialization.json.internal.JsonDecodingException: Unexpected JSON token at offset 8: Expected numeric literal
JSON input: [{"task":"test #1","state":null},{"task":"test #2","state":null}]

What would be the recommended approach to deserialize a JSON structure that has two different keys that represent the same values? Examples are in the thread. Edit: (One possible solution is in the thread, turns out I wasn’t reading the error message correctly 😬)

2. Is it possible to use a field as a discriminator and also have it in the deserialized object? I.e., we are successfully using

type

as the discriminator, but we'd also like to have a

val type

inside the deserialized object, containing the same content as

type

from the serialization logic. I imagine that the tricky part here would be that there's no guarantees that the

val type

would always line up with the class discriminator when serializing or mutating a deserialized class?

Hey guys, I am working with an API that either returns a success response or an error response (both HTTP 200). They are 2 different JSON. How would I deserialize this using Kotlinx Serialization and Ktor? Would like to deserialize this into a sealed class like so:

sealed class ApiResponse {
    data class Success(val fields: String) : ApiResponse()
    data class Error(val errorCode: String, val errorMessage: String): ApiResponse()
}

Is there any tutorial on how to do something like this?

I have a complicated problem (as always). I have a large json that could have something like

{ $ref: 2}

instead of some of its nodes. My task is to find those nodes and replace them by objects those refs are referencing to. The problem is that I do not know in advance on which level those refs will appear. It is quite easy to create either custom decoder o custom serializer that checks specific node and replaced it if it is ref, but I can't see a way to propagate this decoder/serializer logic recursively to sub-nodes. Does anybody have a similar expirience? I know that is is possible to do in @pdvrieze's XML processor by applying custom decoder logic to configuration.

Is there any way to write custom literals when defining a

KSerializer<T>

? Use case would be writing a BigDecimal without precision-loss as

{ "myValue": 0.12345 }

, but without using a Double along the way. Likewise it would be nice to be able to use a

decoder.decodeUnquotedString

or something, to parse the above value into a string rather than double without needing to set

isLenient

Hi, is it possible to make some property not serialized conditionally, based on property value?

Are there any plans on supporting polymorphic serialization of sealed interfaces?

How would I go about deserializing a top-level JsonArray (

["v1", "v2", "v3"]

) as a data class?

@Serializable
data class VersionResponse(val versions: List<String>)

I've made several attempts with

JsonTransformingSerializer

, but no dice! 😔

How can I view the generated code from @Serializable classes in Android Studio?

Hey all, I haven't had the chance to make use of kotlinx.serialization yet, but from looking at the docs I'm really excited for it, and it actually reminds me a lot of the rust library serde. One of my hopes, since kotlinx.serialization is implemented via a compiler plugin was that the compiler would be able to warn you at compile-time if you try to serialize a class that isn't serializable. This would resolve one of my major gripes with libraries like GSON: I don't want to have to try to serialize something where the serialization wasn't set up correctly, only to get a cryptic error at run time. Currently, as I understand it reading the docs, this doesn't happen -- and you get a runtime exception instead. Are there any plans currently to support this kind of compile time checking in kotlinx.serialization?