A modern programming language that makes developers happier.

kotlinlang

```1. this should deserilize to Message&lt;SimmplePayload&gt;
{ 
  id = "1",
  type = "simple",
  payload =  {
    name = "Blah"
  }
}


2. this should deserilize to Message&lt;AdvancedPayload&gt;
{ 
  id = "2",
  type = "advanced",
  payload =  {
    name = "WOW",
    description = "WOW WOW"
  }
}```

See <https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/polymorphism.md#custom-subclass-serial-name>, you just need to set the `@SerialName`s

Wait, I didn't see `Message`.  You should probably define a data type for deserializing the message using custom serial names, that has methods to transform it into `Message`

<@UCVH2FJ2V> since the type is outside the payload, I'm having issue deserializing it.

Something like:
```// your Payload classes

sealed class Message&lt;out T: Payload&gt;(val typeName: String){
  abstract val id: String
  abstract val payload: T

  @SerialName("advanced")
  data class AdvMessage(override val id: String, override val payload: AdvancedPayload): Message("advanced) 
  @SerialName("simple")
  data class SimpleMessage(override val id: String, override val payload: SimplePayload): Message("simple")
}```

There's probably more elegant ways, and I think there may be some bugs with sealed classes + type params, but that should work

A better solution might to use a serializer module with a polymorphic default, see <https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/polymorphism.md#default-polymorphic-type-handler-for-deserialization>

Something like
```default{ when(it){
  "simple" -&gt; Message.serializer(SimplePayload.serializer())
  "advanced" -&gt; Message.serializer(AdvancedPayload.serializer())
  else -&gt; error("") // not sure if there's a null serializer but you could use that
} }```

Not really how it's intended to be used though, and I'm not sure if it would work

The sealed Message class that <@UCVH2FJ2V> suggested (but without the generics) is the only way to do what you want without a custom serializer.

The default thing won't quite work, because you'll need to annotate the message class with a polymorphic serializer to use it, but if you do that, the serializer that you're trying to get in the default lambda won't exist.